Access Properties¶

use brahe as bh;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    bh::initialize_eop()?;

    // Create location (San Francisco area)
    let location = bh::PointLocation::new(
        -122.4194,
        37.7749,
        0.0
    );

    // Create propagator from TLE (ISS example)
    let tle_line1 = "1 25544U 98067A   25306.42331346  .00010070  00000-0  18610-3 0  9999";
    let tle_line2 = "2 25544  51.6344 342.0717 0004969   8.9436 351.1640 15.49700017536601";
    let propagator = bh::SGPPropagator::from_tle(tle_line1, tle_line2, 60.0)?;

    // Define time period (24 hours from epoch)
    let epoch_start = bh::Epoch::from_datetime(2025, 11, 2, 0, 0, 0.0, 0.0, bh::TimeSystem::UTC);
    let epoch_end = epoch_start + 86400.0;

    // Create elevation constraint
    let constraint = bh::ElevationConstraint::new(Some(10.0), None)?;

    // Compute access windows
    let windows = bh::location_accesses(
        &location,
        &propagator,
        epoch_start,
        epoch_end,
        &constraint,
        None,
        None,
    )?;

    // Access core properties from first window
    if !windows.is_empty() {
        let window = &windows[0];
        let props = &window.properties;

        println!("Window ");
        let t_start = window.window_open;
        let t_end = window.window_close;
        println!("  Start: {}", t_start);
        println!("  End:   {}", t_end);
        println!("  Duration: {:.1} seconds", window.duration());
        println!("  Midtime: {}", window.midtime());

        println!("\nProperties:");

        // Azimuth values (open and close)
        let az_open = props.azimuth_open;
        let az_close = props.azimuth_close;
        println!("  Azimuth - Min: {:.1}°, Max: {:.1}°", az_open, az_close);

        // Elevation range (min and max)
        let elev_min = props.elevation_min;
        let elev_max = props.elevation_max;
        println!("  Elevation - Min: {:.1}°, Max: {:.1}°", elev_min, elev_max);

        // Off-nadir range (min and max)
        let off_nadir_min = props.off_nadir_min;
        let off_nadir_max = props.off_nadir_max;
        println!("  Off-nadir - Min: {:.1}°, Max: {:.1}°", off_nadir_min, off_nadir_max);

        // Local solar time at midpoint (local_time is in seconds since midnight)
        let local_time = props.local_time;
        let hours = (local_time / 3600.0).floor() as i32;
        let minutes = (local_time - hours as f64 * 3600.0) / 60.0;
        println!("  Local time: {:02}:{:05.2}", hours, minutes);

        // Look direction
        let look = &props.look_direction;
        println!("  Look direction: {}", look);

        // Ascending/Descending
        let asc_dsc = &props.asc_dsc;
        println!("  Ascending/Descending: {}", asc_dsc);
    }

    Ok(())
}

//! ```

use brahe::access::SamplingConfig;

fn main() {
    // Single sample at window midpoint (default)
    let config = SamplingConfig::Midpoint;
    println!("Midpoint: {:?}", config);

    // Specific relative points [0.0, 1.0] from window start to end
    let config = SamplingConfig::RelativePoints(vec![0.0, 0.25, 0.5, 0.75, 1.0]);
    println!("Relative points: {:?}", config);

    // Fixed time interval in seconds
    let config = SamplingConfig::FixedInterval {
        interval: 1.0,  // 1 second
        offset: 0.0
    };
    println!("Fixed interval (1s): {:?}", config);

    // Fixed number of evenly-spaced points
    let config = SamplingConfig::FixedCount(50);
    println!("Fixed count (50): {:?}", config);
}

//! ```

#[allow(unused_imports)]
use brahe as bh;
use bh::access::{DopplerComputer, SamplingConfig, PropertyValue};
use bh::utils::Identifiable;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    bh::initialize_eop()?;

    // S-band downlink only (8.4 GHz)
    let _doppler = DopplerComputer::new(
        None,  // No uplink
        Some(8.4e9),  // Downlink frequency
        SamplingConfig::FixedInterval { interval: 0.1, offset: 0.0 }  // 0.1 seconds
    );
    println!("Downlink only: uplink=None, downlink=8.4e9 Hz");

    // Both uplink (2.0 GHz) and downlink (8.4 GHz)
    let doppler = DopplerComputer::new(
        Some(2.0e9),  // Uplink frequency
        Some(8.4e9),  // Downlink frequency
        SamplingConfig::FixedCount(100)
    );
    println!("Both frequencies: uplink=2.0e9 Hz, downlink=8.4e9 Hz");

    // ISS orbit
    let tle_line1 = "1 25544U 98067A   25306.42331346  .00010070  00000-0  18610-3 0  9999";
    let tle_line2 = "2 25544  51.6344 342.0717 0004969   8.9436 351.1640 15.49700017536601";
    let propagator = bh::SGPPropagator::from_tle(tle_line1, tle_line2, 60.0)?
        .with_name("ISS");

    let epoch_start = propagator.epoch;
    let epoch_end = epoch_start + 24.0 * 3600.0;

    // Ground station (lon, lat, alt)
    let location = bh::PointLocation::new(-74.0060, 40.7128, 0.0);

    // Compute accesses with Doppler
    let constraint = bh::ElevationConstraint::new(Some(10.0), None)?;
    let windows = bh::location_accesses(
        &location,
        &propagator,
        epoch_start,
        epoch_end,
        &constraint,
        Some(&[&doppler]),  // Property computers
        None,  // Use default config
    )?;

    // Access computed properties
    let window = &windows[0];
    let doppler_data = window.properties.additional.get("doppler_downlink").unwrap();

    // Extract values from TimeSeries
    let values = match doppler_data {
        PropertyValue::TimeSeries { values, .. } => values,
        _ => panic!("Expected TimeSeries"),
    };

    let min_val = values.iter().fold(f64::INFINITY, |a: f64, &b| a.min(b));
    let max_val = values.iter().fold(f64::NEG_INFINITY, |a: f64, &b| a.max(b));

    println!("\nFirst pass downlink Doppler shift range: {:.1} to {:.1} Hz", min_val, max_val);

    Ok(())
}

//! ```

#[allow(unused_imports)]
use brahe as bh;
use bh::access::{RangeComputer, SamplingConfig, PropertyValue};
use bh::utils::Identifiable;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    bh::initialize_eop()?;

    // Compute range at 50 evenly-spaced points
    let range_comp = RangeComputer::new(
        SamplingConfig::FixedCount(50)
    );
    println!("Range computer: sampling=FixedCount(50)");

    // ISS orbit
    let tle_line1 = "1 25544U 98067A   25306.42331346  .00010070  00000-0  18610-3 0  9999";
    let tle_line2 = "2 25544  51.6344 342.0717 0004969   8.9436 351.1640 15.49700017536601";
    let propagator = bh::SGPPropagator::from_tle(tle_line1, tle_line2, 60.0)?
        .with_name("ISS");

    let epoch_start = propagator.epoch;
    let epoch_end = epoch_start + 24.0 * 3600.0;

    // Ground station
    let location = bh::PointLocation::new(-74.0060, 40.7128, 0.0);

    // Compute accesses with range
    let constraint = bh::ElevationConstraint::new(Some(10.0), None)?;
    let windows = bh::location_accesses(
        &location,
        &propagator,
        epoch_start,
        epoch_end,
        &constraint,
        Some(&[&range_comp]),  // Property computers
        None,  // Use default config
    )?;

    // Access computed properties
    let window = &windows[0];
    let range_data = window.properties.additional.get("range").unwrap();

    // Extract values from TimeSeries
    let distances_m = match range_data {
        PropertyValue::TimeSeries { values, .. } => values,
        _ => panic!("Expected TimeSeries"),
    };

    // Convert to km
    let min_km = distances_m.iter().fold(f64::INFINITY, |a: f64, &b| a.min(b)) / 1000.0;
    let max_km = distances_m.iter().fold(f64::NEG_INFINITY, |a: f64, &b| a.max(b)) / 1000.0;

    println!("\nRange varies from {:.1} to {:.1} km", min_km, max_km);

    Ok(())
}

//! ```

#[allow(unused_imports)]
use brahe as bh;
use bh::access::{RangeRateComputer, SamplingConfig, PropertyValue};
use bh::utils::Identifiable;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    bh::initialize_eop()?;

    // Compute range rate every 0.5 seconds
    let range_rate = RangeRateComputer::new(
        SamplingConfig::FixedInterval { interval: 0.5, offset: 0.0 }  // 0.5 seconds
    );
    println!("Range rate computer: sampling=FixedInterval(0.5s)");

    // ISS orbit
    let tle_line1 = "1 25544U 98067A   25306.42331346  .00010070  00000-0  18610-3 0  9999";
    let tle_line2 = "2 25544  51.6344 342.0717 0004969   8.9436 351.1640 15.49700017536601";
    let propagator = bh::SGPPropagator::from_tle(tle_line1, tle_line2, 60.0)?
        .with_name("ISS");

    let epoch_start = propagator.epoch;
    let epoch_end = epoch_start + 24.0 * 3600.0;

    // Ground station
    let location = bh::PointLocation::new(-74.0060, 40.7128, 0.0);

    // Compute accesses with range rate
    let constraint = bh::ElevationConstraint::new(Some(10.0), None)?;
    let windows = bh::location_accesses(
        &location,
        &propagator,
        epoch_start,
        epoch_end,
        &constraint,
        Some(&[&range_rate]),  // Property computers
        None,  // Use default config
    )?;

    // Access computed properties
    let window = &windows[0];
    let rr_data = window.properties.additional.get("range_rate").unwrap();

    // Extract values from TimeSeries
    let velocities_mps = match rr_data {
        PropertyValue::TimeSeries { values, .. } => values,
        _ => panic!("Expected TimeSeries"),
    };

    let min_vel = velocities_mps.iter().fold(f64::INFINITY, |a: f64, &b| a.min(b));
    let max_vel = velocities_mps.iter().fold(f64::NEG_INFINITY, |a: f64, &b| a.max(b));

    println!("\nRange rate varies from {:.1} to {:.1} m/s", min_vel, max_vel);
    println!("Negative = approaching (decreasing distance)");
    println!("Positive = receding (increasing distance)");

    Ok(())
}

use brahe as bh;
use bh::access::{AccessPropertyComputer, AccessWindow, PropertyValue, SamplingConfig};
use bh::utils::{BraheError, Identifiable};
use std::collections::HashMap;

struct MaxSpeedComputer {
    sampling_config: SamplingConfig,
}

impl AccessPropertyComputer for MaxSpeedComputer {
    fn sampling_config(&self) -> SamplingConfig {
        self.sampling_config.clone()
    }

    fn compute(
        &self,
        _window: &AccessWindow,
        _sample_epochs: &[f64],
        sample_states_ecef: &[nalgebra::SVector<f64, 6>],
        _location_ecef: &nalgebra::Vector3<f64>,
        _location_geodetic: &nalgebra::Vector3<f64>,
    ) -> Result<HashMap<String, PropertyValue>, BraheError> {
        let mut max_speed = 0.0;

        for state in sample_states_ecef {
            let velocity = state.fixed_rows::<3>(3);
            let speed = velocity.norm();
            if speed > max_speed {
                max_speed = speed;
            }
        }

        let mut props = HashMap::new();
        props.insert("max_ground_speed".to_string(), PropertyValue::Scalar(max_speed));
        Ok(props)
    }

    fn property_names(&self) -> Vec<String> {
        vec!["max_ground_speed".to_string()]
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    bh::initialize_eop()?;

    // ISS orbit
    let tle_line1 = "1 25544U 98067A   25306.42331346  .00010070  00000-0  18610-3 0  9999";
    let tle_line2 = "2 25544  51.6344 342.0717 0004969   8.9436 351.1640 15.49700017536601";
    let propagator = bh::SGPPropagator::from_tle(tle_line1, tle_line2, 60.0)?
        .with_name("ISS");

    let epoch_start = propagator.epoch;
    let epoch_end = epoch_start + 24.0 * 3600.0;

    // Ground station
    let location = bh::PointLocation::new(-74.0060, 40.7128, 0.0);

    // Compute with custom property
    let max_speed = MaxSpeedComputer {
        sampling_config: SamplingConfig::FixedInterval {
            interval: 0.5,  // 0.5 seconds
            offset: 0.0,
        },
    };

    let constraint = bh::ElevationConstraint::new(Some(10.0), None)?;
    let windows = bh::location_accesses(
        &location,
        &propagator,
        epoch_start,
        epoch_end,
        &constraint,
        Some(&[&max_speed]),  // Property computers
        None,  // Use default config
    )?;

    for window in &windows {
        let speed = match window.properties.additional.get("max_ground_speed").unwrap() {
            PropertyValue::Scalar(s) => s,
            _ => panic!("Expected Scalar"),
        };
        println!("Max speed: {:.1} m/s", speed);
    }

    Ok(())
}