Skip to content

Groundstation Datasets

Overview

Groundstation datasets provide geographic locations and metadata for commercial satellite ground facilities worldwide. This data is essential for:

  • Computing contact opportunities: Determine when satellites are visible from ground stations
  • Network planning: Analyze coverage and redundancy across multiple providers
  • Mission design: Evaluate downlink opportunities for different orbit configurations

Brahe includes embedded GeoJSON data for 6 major commercial groundstation providers, totaling 50+ facilities globally. All data is:

  • Offline-capable: No network requests required
  • Comprehensive: Global coverage across multiple providers
  • Standardized: Consistent format with geographic coordinates and metadata
  • Up-to-date: Maintained as provider networks evolve

When to Use

Use groundstation datasets when you need to:

  • Compute visibility windows for satellite-to-ground contacts
  • Plan downlink schedules for data collection
  • Analyze network coverage and redundancy
  • Compare provider capabilities across different locations

Available Providers

Brahe includes groundstation data from six major commercial providers:

Provider Description
Atlas Atlas Space Operations
AWS Amazon Web Services Ground Station
KSAT Kongsberg Satellite Services
Leaf Leaf Space
NASA DSN NASA Deep Space Network
NASA NEN NASA Near Earth Network
SSC Swedish Space Corporation
Viasat Viasat

Usage

Loading Groundstations

Load groundstation data from one or more providers:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
import brahe as bh

# Initialize EOP data
bh.initialize_eop()

# Load groundstations from a single provider
ksat_stations = bh.datasets.groundstations.load("ksat")
print(f"KSAT stations: {len(ksat_stations)}")

# Load all available providers at once
all_stations = bh.datasets.groundstations.load_all()
print(f"Total stations (all providers): {len(all_stations)}")

# List available providers
providers = bh.datasets.groundstations.list_providers()
print(f"\nAvailable providers: {', '.join(providers)}")

# Load multiple specific providers
aws_stations = bh.datasets.groundstations.load("aws")
ssc_stations = bh.datasets.groundstations.load("ssc")
combined = aws_stations + ssc_stations
print(f"\nCombined AWS + SSC: {len(combined)} stations")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
use brahe as bh;

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

    // Load groundstations from a single provider
    let ksat_stations = bh::datasets::groundstations::load_groundstations("ksat").unwrap();
    println!("KSAT stations: {}", ksat_stations.len());

    // Load all available providers at once
    let all_stations = bh::datasets::groundstations::load_all_groundstations().unwrap();
    println!("Total stations (all providers): {}", all_stations.len());

    // List available providers
    let providers = bh::datasets::groundstations::list_providers();
    println!("\nAvailable providers: {}", providers.join(", "));

    // Load multiple specific providers
    let aws_stations = bh::datasets::groundstations::load_groundstations("aws").unwrap();
    let ssc_stations = bh::datasets::groundstations::load_groundstations("ssc").unwrap();
    let combined: Vec<_> = aws_stations
        .iter()
        .chain(ssc_stations.iter())
        .cloned()
        .collect();
    println!("\nCombined AWS + SSC: {} stations", combined.len());

}
Output 
1
2
3
4
5
6
KSAT stations: 36
Total stations (all providers): 117

Available providers: atlas, aws, ksat, leaf, nasa dsn, nasa nen, ssc, viasat

Combined AWS + SSC: 22 stations

1
2
3
4
5
6
KSAT stations: 36
Total stations (all providers): 117

Available providers: atlas, aws, ksat, leaf, nasa dsn, nasa nen, ssc, viasat

Combined AWS + SSC: 22 stations

Accessing Properties

Each groundstation includes geographic coordinates and metadata:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import brahe as bh

# Initialize EOP data
bh.initialize_eop()

# Load KSAT groundstations
stations = bh.datasets.groundstations.load("ksat")

# Access the first station
station = stations[0]

# Geographic coordinates (degrees and meters)
name = station.get_name() if station.get_name() else "Unknown"
print(f"Station: {name}")
print(f"Latitude: {station.lat:.4f}°")
print(f"Longitude: {station.lon:.4f}°")
print(f"Altitude: {station.alt:.1f} m")

# Access metadata properties
props = station.properties
print(f"\nProvider: {props['provider']}")
print(f"Frequency bands: {', '.join(props['frequency_bands'])}")

# Show all stations with their locations
print(f"\n{len(stations)} KSAT Stations:")
for i, gs in enumerate(stations, 1):
    gs_name = gs.get_name() if gs.get_name() else "Unknown"
    print(f"{i:2d}. {gs_name:30s} ({gs.lat:7.3f}°, {gs.lon:8.3f}°)")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
use brahe as bh;
use bh::utils::Identifiable;

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

    // Load KSAT groundstations
    let stations = bh::datasets::groundstations::load_groundstations("ksat").unwrap();

    // Access the first station
    let station = &stations[0];

    // Geographic coordinates (degrees and meters)
    let name = station.get_name().unwrap_or("Unknown");
    println!("Station: {}", name);
    println!("Latitude: {:.4}°", station.lat());
    println!("Longitude: {:.4}°", station.lon());
    println!("Altitude: {:.1} m", station.alt());

    // Show all stations with their locations
    println!("\n{} KSAT Stations:", stations.len());
    for (i, gs) in stations.iter().enumerate() {
        let gs_name = gs.get_name().unwrap_or("Unknown");
        println!(
            "{:2}. {:30} ({:7.3}°, {:8.3}°)",
            i + 1,
            gs_name,
            gs.lat(),
            gs.lon()
        );
    }

}
Output 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Station: Prudhoe Bay
Latitude: 70.2000°
Longitude: -148.4700°
Altitude: 0.0 m

Provider: KSAT
Frequency bands: S, X

36 KSAT Stations:
 1. Prudhoe Bay                    ( 70.200°, -148.470°)
 2. Athens                         ( 37.850°,   22.620°)
 3. Awarua                         (-46.530°,  168.380°)
 4. Azores                         ( 36.990°,  -25.130°)
 5. Bangalore                      ( 12.900°,   77.370°)
 6. Long Beach                     ( 33.820°, -118.150°)
 7. Cordoba                        (-33.200°,  -66.100°)
 8. Dubai                          ( 25.230°,   55.470°)
 9. Fairbanks                      ( 64.820°, -147.720°)
10. Miami                          ( 25.610°,  -80.380°)
11. Thomaston                      ( 32.950°,  -84.260°)
12. Hartebeesthoek                 (-25.890°,   27.710°)
13. Hawaii                         ( 20.820°, -156.450°)
14. Hokkaido                       ( 42.600°,  143.450°)
15. Inuvik                         ( 68.330°, -133.610°)
16. Jan Mayen                      ( 70.920°,   -8.720°)
17. Jeju                           ( 33.390°,  126.320°)
18. Kourou                         (  5.250°,  -52.800°)
19. Maspalomas                     ( 27.770°,  -15.640°)
20. Mauritius                      (-20.500°,   57.450°)
21. Mingenew                       (-29.010°,  115.340°)
22. Nuuk                           ( 64.190°,  -51.700°)
23. Okinawa                        ( 26.360°,  127.810°)
24. Peterborough                   (-32.960°,  138.850°)
25. Puertollano                    ( 38.670°,   -4.160°)
26. Punta Arenas                   (-52.940°,  -70.870°)
27. Singapore                      (  1.320°,  103.700°)
28. Svalbard                       ( 78.230°,   15.410°)
29. Thermopylae                    ( 38.820°,   22.690°)
30. Tokyo                          ( 36.000°,  139.350°)
31. Tolhuin                        (-54.510°,  -67.120°)
32. Troll                          (-72.000°,    2.530°)
33. Tromso                         ( 69.660°,   18.950°)
34. Tuskuba                        ( 36.130°,  140.080°)
35. Vardo                          ( 70.340°,   31.030°)
36. Weilheim                       ( 47.880°,   11.080°)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
Station: Prudhoe Bay
Latitude: 70.2000°
Longitude: -148.4700°
Altitude: 0.0 m

36 KSAT Stations:
 1. Prudhoe Bay                    ( 70.200°, -148.470°)
 2. Athens                         ( 37.850°,   22.620°)
 3. Awarua                         (-46.530°,  168.380°)
 4. Azores                         ( 36.990°,  -25.130°)
 5. Bangalore                      ( 12.900°,   77.370°)
 6. Long Beach                     ( 33.820°, -118.150°)
 7. Cordoba                        (-33.200°,  -66.100°)
 8. Dubai                          ( 25.230°,   55.470°)
 9. Fairbanks                      ( 64.820°, -147.720°)
10. Miami                          ( 25.610°,  -80.380°)
11. Thomaston                      ( 32.950°,  -84.260°)
12. Hartebeesthoek                 (-25.890°,   27.710°)
13. Hawaii                         ( 20.820°, -156.450°)
14. Hokkaido                       ( 42.600°,  143.450°)
15. Inuvik                         ( 68.330°, -133.610°)
16. Jan Mayen                      ( 70.920°,   -8.720°)
17. Jeju                           ( 33.390°,  126.320°)
18. Kourou                         (  5.250°,  -52.800°)
19. Maspalomas                     ( 27.770°,  -15.640°)
20. Mauritius                      (-20.500°,   57.450°)
21. Mingenew                       (-29.010°,  115.340°)
22. Nuuk                           ( 64.190°,  -51.700°)
23. Okinawa                        ( 26.360°,  127.810°)
24. Peterborough                   (-32.960°,  138.850°)
25. Puertollano                    ( 38.670°,   -4.160°)
26. Punta Arenas                   (-52.940°,  -70.870°)
27. Singapore                      (  1.320°,  103.700°)
28. Svalbard                       ( 78.230°,   15.410°)
29. Thermopylae                    ( 38.820°,   22.690°)
30. Tokyo                          ( 36.000°,  139.350°)
31. Tolhuin                        (-54.510°,  -67.120°)
32. Troll                          (-72.000°,    2.530°)
33. Tromso                         ( 69.660°,   18.950°)
34. Tuskuba                        ( 36.130°,  140.080°)
35. Vardo                          ( 70.340°,   31.030°)
36. Weilheim                       ( 47.880°,   11.080°)

Computing Access Windows

Use groundstation data with brahe's access computation to find contact opportunities:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import brahe as bh
import numpy as np

# Initialize EOP data
bh.initialize_eop()

# Load groundstations from a provider
stations = bh.datasets.groundstations.load("ksat")
print(f"Computing access for {len(stations)} KSAT stations")

# Create a sun-synchronous orbit satellite
epoch = bh.Epoch.from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, bh.TimeSystem.UTC)
oe = np.array([bh.R_EARTH + 600e3, 0.001, 97.8, 0.0, 0.0, 0.0])
state = bh.state_koe_to_eci(oe, bh.AngleFormat.DEGREES)
propagator = bh.KeplerianPropagator.from_eci(epoch, state, 60.0).with_name("EO-Sat")

# Define access constraint (minimum 5° elevation)
constraint = bh.ElevationConstraint(min_elevation_deg=5.0)

# Compute access windows for 24 hours
duration = 24.0 * 3600.0  # seconds
windows = bh.location_accesses(
    stations, [propagator], epoch, epoch + duration, constraint
)

# Display results
print(f"\nTotal access windows: {len(windows)}")
print("\nFirst 5 windows:")
for i, window in enumerate(windows[:5], 1):
    duration_min = (window.end - window.start) / 60.0
    print(f"{i}. {window.location_name:20s} -> {window.satellite_name:10s}")
    print(f"   Start: {window.start}")
    print(f"   Duration: {duration_min:.1f} minutes")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
use brahe as bh;
use bh::access::location_accesses;
use bh::utils::Identifiable;
use nalgebra as na;

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

    // Load groundstations from a provider
    let stations = bh::datasets::groundstations::load_groundstations("ksat").unwrap();
    println!("Computing access for {} KSAT stations", stations.len());

    // Create a sun-synchronous orbit satellite
    let epoch = bh::Epoch::from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, bh::TimeSystem::UTC);
    let oe = na::SVector::<f64, 6>::new(
        bh::R_EARTH + 600e3,
        0.001,
        97.8_f64.to_radians(),
        0.0,
        0.0,
        0.0,
    );
    let state = bh::state_koe_to_eci(oe, bh::AngleFormat::Radians);
    let propagator =
        bh::KeplerianPropagator::from_eci(epoch, state, 60.0).with_name("EO-Sat");

    // Define access constraint (minimum 5° elevation)
    let constraint = bh::ElevationConstraint::new(Some(5.0), None).unwrap();

    // Compute access windows for 24 hours
    let duration = 24.0 * 3600.0; // seconds
    let windows = location_accesses(
        &stations,
        &vec![propagator],
        epoch,
        epoch + duration,
        &constraint,
        None,
        None,
    ).unwrap();

    // Display results
    println!("\nTotal access windows: {}", windows.len());
    println!("\nFirst 5 windows:");
    for (i, window) in windows.iter().take(5).enumerate() {
        let duration_min = (window.end() - window.start()) / 60.0;
        let loc_name = window.location_name.as_deref().unwrap_or("Unknown");
        let sat_name = window.satellite_name.as_deref().unwrap_or("Unknown");
        println!(
            "{}. {:20} -> {:10}",
            i + 1,
            loc_name,
            sat_name
        );
        println!("   Start: {}", window.start());
        println!("   Duration: {:.1} minutes", duration_min);
    }

}
Output 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
Computing access for 36 KSAT stations

Total access windows: 213

First 5 windows:
1. Long Beach           -> EO-Sat    
   Start: 2024-01-01 00:05:08.309 UTC
   Duration: 9.2 minutes
2. Thomaston            -> EO-Sat    
   Start: 2024-01-01 00:07:15.027 UTC
   Duration: 2.1 minutes
3. Inuvik               -> EO-Sat    
   Start: 2024-01-01 00:13:53.156 UTC
   Duration: 10.4 minutes
4. Fairbanks            -> EO-Sat    
   Start: 2024-01-01 00:14:39.829 UTC
   Duration: 9.1 minutes
5. Prudhoe Bay          -> EO-Sat    
   Start: 2024-01-01 00:15:18.847 UTC
   Duration: 10.0 minutes

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
Computing access for 36 KSAT stations

Total access windows: 213

First 5 windows:
1. Long Beach           -> EO-Sat    
   Start: 2024-01-01 00:05:08.309 UTC
   Duration: 9.2 minutes
2. Thomaston            -> EO-Sat    
   Start: 2024-01-01 00:07:15.027 UTC
   Duration: 2.1 minutes
3. Inuvik               -> EO-Sat    
   Start: 2024-01-01 00:13:53.156 UTC
   Duration: 10.4 minutes
4. Fairbanks            -> EO-Sat    
   Start: 2024-01-01 00:14:39.829 UTC
   Duration: 9.1 minutes
5. Prudhoe Bay          -> EO-Sat    
   Start: 2024-01-01 00:15:18.847 UTC
   Duration: 10.0 minutes

Data Format

Each groundstation is represented as a PointLocation with standardized properties:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import brahe as bh

stations = bh.datasets.groundstations.load("ksat")
station = stations[0]

# Geographic coordinates (WGS84)
lon = station.lon()      # Longitude in degrees
lat = station.lat()      # Latitude in degrees
alt = station.alt()      # Altitude in meters

# Metadata properties
props = station.properties
name = station.get_name()              # Station name
provider = props["provider"]            # Provider name (e.g., "KSAT")
bands = props["frequency_bands"]        # Supported bands (e.g., ["S", "X"])

All groundstations include these standard properties:

  • provider: Provider name (string, e.g., "KSAT", "Atlas")
  • frequency_bands: List of supported frequency bands (e.g., ["S", "X", "Ka"])

Additional properties may be included in future releases as data becomes available.

See Also