AstroSolve.jl

AstroSolve provides a framework for solving astrodynamics design problems through constrained optimization and event-driven architecture. AstroSolve builds an event sequence as a Directed Acyclic Graph (DAG), which will soon be fully differentiable using AD. The DAG model for optimization is inspired by the architecture used in NASA's Copernicus software.

Reference: Jacob Williams, Robert Falck, and Izaak Beekman. "Application of Modern Fortran to Spacecraft Trajectory Design and Optimization." AIAA/AAS Space Flight Mechanics Meeting, Kissimmee, FL, 2018. Available online

AstroSolve's architecture is based on a few key user-facing components:

Component	Description
Models	Spacecraft, maneuvers, propagators, etc. that model the physics of the system
SolverVariables	Optimization variables that the solver can adjust during trajectory design
Constraints	Equality and inequality constraints that must be satisfied in the solution
Events	Discrete mission phases that execute actions (propagate, maneuver, etc.) and apply constraints
Sequence	DAG structure that defines event dependencies and execution order

Quick Start

The example below uses AstroSolve's Event Sequence architecture to solve a simple orbit raising problem using IPOPT.

using Epicycle

# ============================================================================
# Shared Resources
# ============================================================================

# Create spacecraft with default orbital state
sat = Spacecraft()

# Create force models, integrator, and propagator
gravity = PointMassGravity(earth, (moon, sun))
forces  = ForceModel(gravity)
integ   = IntegratorConfig(Tsit5(); dt=10.0, reltol=1e-9, abstol=1e-9)
prop    = OrbitPropagator(forces, integ)

# ============================================================================
# Event 1: TOI - Transfer Orbit Insertion
# ============================================================================

# Define TOI maneuver
toi = ImpulsiveManeuver(
    axes = VNB(),
    element1 = 0.1,
)

# Define solver variable for TOI delta-V
toi_var = SolverVariable(
    calc = ManeuverCalc(toi, sat, DeltaVVector()),
    name = "toi",
    lower_bound = [-10.0, 0.0, 0.0],
    upper_bound = [10.0, 0.0, 0.0],
)

# Define TOI event struct with event function, solver variables, and constraints
toi_fun() = maneuver!(sat, toi) 
toi_event = Event(
    name = "TOI Maneuver", 
    event = toi_fun,
    vars = [toi_var],
    funcs = []
)

# ============================================================================
# Event 2: Propagate to Apoapsis
# ============================================================================

# Define constraint on position magnitude at apoapsis
pos_target = 55000.0
pos_con = Constraint(
    calc = OrbitCalc(sat, PosMag()),
    lower_bounds = [pos_target],
    upper_bounds = [pos_target],
    scale = [1.0],
)

# Define propagation event to apoapsis with position constraint
prop_fun() = propagate!(prop, sat, StopAt(sat, PosDotVel(), 0.0; direction=-1))
prop_event = Event(
    name = "Propagate to Apoapsis", 
    event = prop_fun,
    funcs = [pos_con]
)

# ============================================================================
# Trajectory Optimization
# ============================================================================

# Create sequence and add events
seq = Sequence()
add_sequence!(seq, toi_event, prop_event) 

# Solve trajectory optimization using default settings (finite differences, IPOPT)
result = solve_trajectory!(seq)

# Write a report documenting sequence and solution
report_sequence(seq)
report_solution(seq, result)

Core Functions

This section contains reference material for the key user facing elements of AstroSolve. Note: Constraint is currently in the AstroCallbacks module but will be moved to AstroSolve in a future release.

AstroSolve.SolverVariable — Type

SolverVariable{C<:AbstractCalc}

Represents a solver-controlled variable defined by a calculation container for trajectory optimization.

Fields

calc::C: Calculation container (e.g., OrbitCalc, ManeuverCalc, BodyCalc)
numvars::Int: Number of scalar variables for this calculation
lower_bound::Vector{Float64}: Lower bounds for optimization (length numvars, defaults to -Inf)
upper_bound::Vector{Float64}: Upper bounds for optimization (length numvars, defaults to +Inf)
shift::Vector{Float64}: Variable shifting for numerical conditioning (length numvars, defaults to 0.0)
scale::Vector{Float64}: Variable scaling for numerical conditioning (length numvars, defaults to 1.0)
name::String: Optional human-readable identifier

Constructor

SolverVariable(; calc, lower_bound=nothing, upper_bound=nothing, shift=nothing,
scale=nothing, name="")

Arguments

calc: Calculation container implementing AbstractCalc interface
lower_bound: Scalar or vector of lower bounds (broadcast to numvars if scalar)
upper_bound: Scalar or vector of upper bounds (broadcast to numvars if scalar)
shift: Scalar or vector of shift values for numerical conditioning
scale: Scalar or vector of scale factors for numerical conditioning
name: Optional descriptive name for the variable

Notes

See AbstractCalc for supported calculation types
numvars is automatically determined from the calculation variable type
Bounds, shift, and scale vectors are stored as Float64 for optimizer compatibility
The calculation must support setting values (calc_is_settable(calc.var) == true)

Examples

using Epicycle

# Spacecraft and maneuver objects
sc = Spacecraft(); toi = ImpulsiveManeuver()

# 3D delta-V vector variable with individual component bounds
var_toi = SolverVariable(
    calc = ManeuverCalc(toi, sc, DeltaVVector()),
    lower_bound = [-2.0, -2.0, -2.0],
    upper_bound = [2.0, 2.0, 2.0],
    scale = [1.0, 1.0, 1.0],  
    name = "Departure DV Vector"
)

# Orbital element variable
var_sma = SolverVariable(
    calc = OrbitCalc(sc, SMA()),
    lower_bound = 6700.0,   
    upper_bound = 42000.0,  
    name = "Target Semi-Major Axis"
)

AstroSolve.jl

Quick Start

Core Functions

API Reference

A More Complex Example