Ground Station Optimizer

This repository provides an application for determining the optimal ground station provider and station provider for a given satellite mission. It contains the code and examples supporting the associated paper presented at the 2025 IEEE Aerospace Conference. You can read more about the problem definition and formulation in the preprint paper.

Ground Station Optimizer helps satellite operators determine the optimal ground station provider and station provider for a given satellite mission. The application solves the multi-objective optimization problem to determine the optimal set of locations to support a mission.

Usage

The tool comes in three parts: the core optimization libraries, example scripts, and a streamlit application. Any of these can be used to define and solve a problem.

Examples

To aid users in understanding and using the optimization framework of the library we have provided four examples in the examples/ folder. These examples are:

• full_example.py: A generic example demonstrating setting up a problem and applying many different constraints to the problem
• max_data_opt.py: A total data downlink maximization problem. Optimization is subject to maximum cost constraints.
• min_cost_opt.py: A formulation of the mission-cost minimization problem. Optimization is subject to minimum data constraints.
• max_gap_opt.py: A formulation of the maximum contact-gap minimization problem. Problem formulation is subject to minimum data downlink constraints.

These scripts can be copied and modified for your specific application.

Python Library

The optimization library is structured as follows:

./gsopt
├── analysis.py           # Helper scripts for analyzing simulation outputs
├── app.py                # Main entry point for streamlit application
├── ephemeris.py          # Functions for fetching, storing, and loading satellite ephemeris
├── logging.py            # Logging utilities and configuration
├── milp_constraints.py   # Constraint definition
├── milp_core.py          # Core data models for IP formulation
├── milp_objectives.py    # Objective definition
├── milp_optimizer.py     # IP optimizer class definition
├── models.py             # Common data models for problem modeling
├── optimizer.py          # Base optimizer class
├── plots.py              # Plotting utilities
├── scenarios.py          # Simulation scenario definition and generation tools
├── sim_analysis.py       # Additional helper functions for simulation analysis
├── utils.py              # Misc. utilities
└── widgets.py            # Streamlit widgets for application definition

For most script based applciations users will want to add new constraints or objectives in milp_constraint.py or milp_objectives.py respectively. In rare cases where more core constraints must be added that is done in the milp_optimizer.py file. The scenarios.py file provides utilities to enable users to define new randomized scenarios for evaluation.

Installation

Currently, the repository can be installed as a local package. We would like to add docker support and the streamlit application eventually.

Local Installation

To install the application using a local Python environment, first clone the repository:

git clone https://github.com/sisl/ground-station-optimizer
cd gsopt

Then, create a new Python environment. It is strongly recommended to use a virtual environment to avoid conflicts with other Python packages.

Prerequisites

Note

Note currently MacOS and Linux distributions are supported. The repository relies on upstream dependencies which do not support Windows.

Prior to using the repository you need to install an ILP solver. This project currently supports Gurobi, SCIP, coin-or, and GLPK. Gurobi is the preferred solver that is more robust and performant, but requires a commercial license for non-academic users. SCIP, Coin-Or CBC, and GLPK are open-source solvers that can be used as a free alternative.

The preferred free solver is Coin-Or CBC. You install their branch-and-cut mixed integer programming solver (coin-or cbc) via the installation instructions. For MacOS and Ubuntu you can install it via

• MacOS:

  brew install cbc

• Ubuntu:

  sudo apt-get install  coinor-cbc coinor-libcbc-dev

Another performant free-solver is SCIP which can be dowloaded and installed from their main website. If following this installation method, make sure that the scip executable is in your path and can be found with which scip.

If using GLPK, you can install the GNU Linear Programming Kit (GLPK) via:

• MacOS:

  brew install glpk

• Ubuntu:

  sudo apt install glpk-utils libglpk-dev

Note

It should be noted that the Gurobi solver is significantly faster and more robust than coin-or.

Additionally, any problems that involve a maximum-gap objective or constraints will significantly increase the problem size of the optimization problems, likely beyond what coin-or can solve in a reasonable amount of time.

For some performance comparisons, solving the problem ./examples/max_data_opt.py with each solver on an AMD Ryzen 9 7950X3D 16-Core Processor with 128GB of RAM, the following results were obtained:

Problem	Gurobi	SCIP	Coin-OR	GLPK
max_data_opt.py	1.03s	257.54s	91.93s	Did not finish after 1 hour

uv

The recommended way to install and manage your python environment for this project is through uv. You can install uv along with its shell autocompletions by following the installation instructions.

After installing uv. First check the install python versions and install a specific version

uv python list # Show python environments
uv python install -p 3.12 # Install latest python 3.12 release

Create and activate a local virtual environment

uv venv -p 3.12
source .venv/bin/activate

Then instlal the project dependencies with

uv pip install -e .

Pyenv + Pyenv-vritualenv

Pyenv and Pyenv-virtualenv provide one mechanism of managing python environments. To install Pyenv follow the instructions here, and to install Pyenv-virtualenv follow the instructions here.

Once Pyenv and Pyenv-virtualenv are installed, create a new Python environment and install the required packages:

pyenv install 3.11.9

Next, create a new virtual environment:

pyenv virtualenv 3.11.9 gsopt

Finally set the local Python version to the new virtual environment:

pyenv local gsopt

Now, install the required packages:

pip install -e .

You can then execute one of the examples out of the examples folder.

python examples/full_example.py

Citation & Acknowledgement

If data or software from this repository is used in a publication, please cite the associated paper:

@misc{eddy2024optimalgroundstationselection,
      title={Optimal Ground Station Selection for Low-Earth Orbiting Satellites}, 
      author={Duncan Eddy and Michelle Ho and Mykel J. Kochenderfer},
      year={2024},
      eprint={2410.16282},
      archivePrefix={arXiv},
      primaryClass={cs.NI},
      url={https://arxiv.org/abs/2410.16282}, 
}

If you incorporate this software engineering technique or system into your product, please include a clear and visible acknowledgement to the authors.

License

This project is licensed under the MIT License - see the LICENSE file for details.