Brahe¶

use brahe as bh;

use brahe::{R_EARTH, orbital_period};

fn main() {
    // Define the semi-major axis of a low Earth orbit (in meters)
    let semi_major_axis = R_EARTH + 400e3; // 400 km altitude

    // Calculate the orbital period
    let period = orbital_period(semi_major_axis); 

    println!("Orbital Period: {:.2} minutes", period / 60.0);
}

use brahe::{Epoch, TimeSystem};

fn main() {
    // Create an epoch from a specific date and time
    let epc = Epoch::from_datetime(2024, 1, 1, 12, 0, 0.0, 0.0, TimeSystem::UTC);

    // Print as ISO 8601 string
    println!("Epoch in UTC: {}", epc.isostring());
    let mjd_tai = epc.mjd_as_time_system(TimeSystem::TAI);
    println!("MJD in TAI: {}", mjd_tai);
    let jd_gps = epc.jd_as_time_system(TimeSystem::GPS);
    println!("JD in GPS: {}", jd_gps);
    let epc2 = Epoch::from_datetime(2024, 1, 2, 13, 30, 0.0, 0.0, TimeSystem::GPS);
    let delta_seconds = epc2 - epc;
    println!("Difference between epochs in seconds: {}", delta_seconds);
    let epc_utc = epc2.to_string_as_time_system(TimeSystem::UTC);
    println!("Epoch in GPS: {}", epc2);
    println!("Epoch in UTC: {}", epc_utc);
}

use brahe as bh;
use brahe::{Epoch, TimeSystem, R_EARTH, state_koe_to_eci,
            state_eci_to_ecef, state_ecef_to_eci, state_eci_to_koe, AngleFormat};
use nalgebra::Vector6;

fn main() {
    // Initialize EOP
    bh::initialize_eop().unwrap();

    // Define orbital elements
    let a = R_EARTH + 700e3;    // Semi-major axis in meters (700 km altitude)
    let e = 0.001;              // Eccentricity
    let i = 98.7;               // Inclination in degrees
    let raan = 15.0;            // Right Ascension of Ascending Node in degrees
    let arg_periapsis = 30.0;   // Argument of Periapsis in degrees
    let mean_anomaly = 45.0;    // Mean Anomaly in degrees

    // Create a state vector from orbital elements
    let state_kep = Vector6::new(a, e, i, raan, arg_periapsis, mean_anomaly);

    // Convert Keplerian state to ECI coordinates
    let state_eci = state_koe_to_eci(state_kep, AngleFormat::Degrees);
    println!("ECI Coordinates: {:?}", state_eci);
    let epoch = Epoch::from_datetime(2024, 6, 1, 12, 0, 0.0, 0.0, TimeSystem::UTC);

    // Convert ECI coordinates to ECEF coordinates at the given epoch
    let state_ecef = state_eci_to_ecef(epoch, state_eci);
    println!("ECEF Coordinates: {:?}", state_ecef);
    let state_eci_2 = state_ecef_to_eci(epoch, state_ecef);
    println!("Recovered ECI Coordinates: {:?}", state_eci_2);
    let state_kep_2 = state_eci_to_koe(state_eci_2, AngleFormat::Degrees);
    println!("Recovered Keplerian Elements: {:?}", state_kep_2);
}

use brahe as bh;
use brahe::{Epoch, R_EARTH, KeplerianPropagator, AngleFormat};
use brahe::traits::{SStatePropagator, Trajectory};
use nalgebra::Vector6;

fn main() {
    // Define the initial Keplerian elements
    let a = R_EARTH + 700e3;  // Semi-major axis: 700 km altitude
    let e = 0.001;            // Eccentricity
    let i = 98.7;             // Inclination in degrees
    let raan = 15.0;          // Right Ascension of Ascending Node in degrees
    let argp = 30.0;          // Argument of Perigee in degrees
    let mean_anomaly = 75.0;  // Mean Anomaly at epoch in degrees

    let initial_state = Vector6::new(a, e, i, raan, argp, mean_anomaly);

    // Define the epoch time
    let epoch = Epoch::now();

    // Create the Keplerian Orbit Propagator
    let dt = 60.0;  // Time step in seconds
    let mut propagator = KeplerianPropagator::from_keplerian(
        epoch,
        initial_state,
        AngleFormat::Degrees,
        dt
    );

    // Propagate the orbit for 3 time steps
    propagator.propagate_steps(3);

    // States are stored as a Trajectory object
    assert_eq!(propagator.trajectory.len(), 4);  // Initial state + 3 propagated states

    // Convert trajectory to ECI coordinates
    let eci_trajectory = propagator.trajectory.to_eci();

    // Iterate over all stored states
    for i in 0..eci_trajectory.len() {
        let epoch = eci_trajectory.epochs[i];
        let state = eci_trajectory.states[i].clone();
        println!(
            "Epoch: {}, Position (ECI): {:.2} km, {:.2} km, {:.2} km",
            epoch,
            state[0] / 1e3,
            state[1] / 1e3,
            state[2] / 1e3
        );
    }
    // Output (will vary based on current time):
    // Epoch: 2025-10-24 22:14:56.707 UTC, Position (ECI): -1514.38 km, -1475.59 km, 6753.03 km
    // Epoch: 2025-10-24 22:15:56.707 UTC, Position (ECI): -1935.70 km, -1568.01 km, 6623.80 km
    // Epoch: 2025-10-24 22:16:56.707 UTC, Position (ECI): -2349.19 km, -1654.08 km, 6467.76 km
    // Epoch: 2025-10-24 22:17:56.707 UTC, Position (ECI): -2753.17 km, -1733.46 km, 6285.55 km

    // Propagate for 7 days
    let end_epoch = epoch + 86400.0 * 7.0;  // 7 days later
    propagator.propagate_to(end_epoch);

    // Confirm the final epoch is close to expected time
    let time_diff = (propagator.current_epoch() - end_epoch).abs();
    assert!(time_diff < 1.0e-6, "Final epoch should be within 1 second of target");
    println!("Propagation complete. Final epoch: {}", propagator.current_epoch());
    // Output (will vary based on current time):
    // Propagation complete. Final epoch: 2025-10-31 22:18:40.413 UTC
}

use brahe as bh;
use brahe::{Epoch, PointLocation, ElevationConstraint, location_accesses};
use brahe::celestrak::CelestrakClient;
use brahe::utils::Identifiable;

fn main() {
    // Initialize EOP
    bh::initialize_eop().unwrap();

    // Set the location
    let location = PointLocation::new(-122.4194, 37.7749, 0.0)
        .with_name("San Francisco");

    // Get the latest TLE for the ISS (NORAD ID 25544) from Celestrak
    let client = CelestrakClient::new();
    let propagator = client.get_sgp_propagator_by_catnr(25544, 60.0).unwrap();

    // Configure Search Window
    let epoch_start = Epoch::now();
    let epoch_end = epoch_start + 7.0 * 86400.0;  // 7 days later

    // Set access constraints -> Must be above 10 degrees elevation
    let constraint = ElevationConstraint::new(Some(10.0), None).unwrap();

    // Compute access windows
    let windows = location_accesses(
        &location,
        &propagator,
        epoch_start,
        epoch_end,
        &constraint,
        None,
        None,
    ).unwrap();

    assert!(!windows.is_empty(), "Should find at least one access window");

    // Print first 3 access windows
    for window in windows.iter().take(3) {
        println!(
            "Access Window: {} to {}, Duration: {:.2} minutes",
            window.window_open,
            window.window_close,
            window.duration() / 60.0
        );
    }
}