AeroSandbox is a Python package for aircraft design optimization that leverages modern tools for reverse-mode automatic differentiation and large-scale design optimization.
At its heart, AeroSandbox is a collection of end-to-end automatic-differentiable models and analysis tools for aircraft design applications. This property of automatic-differentiability dramatically improves performance on large problems; design problems with thousands or tens of thousands of decision variables solve in seconds on a laptop. Using AeroSandbox, you can simultaneously optimize an aircraft's aerodynamics, structures, propulsion, mission trajectory, stability, and more.
AeroSandbox has powerful aerodynamics solvers (VLM, 3D panel) written from the ground up, and AeroSandbox can also be used as a standalone aerodynamics solver if desired. Like all other modules, these solvers are end-to-end automatic-differentiable. Therefore, in half a second, you can calculate not only the aerodynamic performance of an airplane, but also the sensitivity of aerodynamic performance with respect to an arbitary number of design variables.
VLM3 simulation of a glider, aileron deflections of +-30°. Runtime of 0.35 sec on a typical laptop (i7-8750H).
PANEL1 simulation of a wing (extruded NACA2412, α=15°, AR=4). Note the strong three-dimensionality of the flow near the tip.
pip install AeroSandbox. Requires Python 3.7. Nearly all features work in Python 3.8+, although automated interfacing with XFoil for 2D aerodynamic analysis does not.
To get examples as well, clone from master on GitHub. (Nightly builds available on develop branch.)
There are many example cases you can try out in the
/examples/ directory! A good place to start is
AeroSandbox is designed to have extremely intuitive, high-level, and human-readable code. You (yes, you!) can probably learn to analyze a simple airplane and visualize airflow around it within 5 minutes of downloading AeroSandbox. For example, here is all the code that is needed to design a glider, analyze its aerodynamics in flight, and visualize it (found in
from aerosandbox import * glider = Airplane( name="Peter's Glider", xyz_ref=[0, 0, 0], # CG location wings=[ Wing( name="Main Wing", xyz_le=[0, 0, 0], # Coordinates of the wing's leading edge symmetric=True, # Should we mirror the wing across the XZ plane? xsecs=[ # The wing's cross ("X") sections WingXSec( # Root cross ("X") section xyz_le=[0, 0, 0], # Coordinates of the XSec's leading edge, relative to the wing's leading edge. chord=0.18, twist=2, # degrees airfoil=Airfoil(name="naca4412"), control_surface_type='symmetric', # Flap # Control surfaces are applied between a given XSec and the next one. control_surface_deflection=0, # degrees control_surface_hinge_point=0.75 # as chord fraction ), WingXSec( # Mid xyz_le=[0.01, 0.5, 0], chord=0.16, twist=0, airfoil=Airfoil(name="naca4412"), control_surface_type='asymmetric', # Aileron control_surface_deflection=0, control_surface_hinge_point=0.75 ), WingXSec( # Tip xyz_le=[0.08, 1, 0.1], chord=0.08, twist=-2, airfoil=Airfoil(name="naca4412"), ) ] ), Wing( name="Horizontal Stabilizer", xyz_le=[0.6, 0, 0.1], symmetric=True, xsecs=[ WingXSec( # root xyz_le=[0, 0, 0], chord=0.1, twist=-10, airfoil=Airfoil(name="naca0012"), control_surface_type='symmetric', # Elevator control_surface_deflection=0, control_surface_hinge_point=0.75 ), WingXSec( # tip xyz_le=[0.02, 0.17, 0], chord=0.08, twist=-10, airfoil=Airfoil(name="naca0012") ) ] ), Wing( name="Vertical Stabilizer", xyz_le=[0.6, 0, 0.15], symmetric=False, xsecs=[ WingXSec( xyz_le=[0, 0, 0], chord=0.1, twist=0, airfoil=Airfoil(name="naca0012"), control_surface_type='symmetric', # Rudder control_surface_deflection=0, control_surface_hinge_point=0.75 ), WingXSec( xyz_le=[0.04, 0, 0.15], chord=0.06, twist=0, airfoil=Airfoil(name="naca0012") ) ] ) ] ) aero_problem = vlm3( # Analysis type: Vortex Lattice Method, version 3 airplane=glider, op_point=OperatingPoint( velocity=10, # airspeed, m/s alpha=5, # angle of attack, deg beta=0, # sideslip angle, deg p=0, # x-axis rotation rate, rad/sec q=0, # y-axis rotation rate, rad/sec r=0, # z-axis rotation rate, rad/sec ), ) aero_problem.run() # Runs and prints results to console aero_problem.draw() # Creates an interactive display of the surface pressures and streamlines
The best part is that by adding just a few more lines of code, you can not only get the performance at a specified design point, but also the derivatives of any performance variable with respect to any design variable. Thanks to reverse-mode automatic differentiation, this process only requires the time of one additional flow solution, regardless of the number of design variables. For an example of this, see "/examples/gradient_test_vlm2.py".
One final point to note: as we're all sensible and civilized human beings here, all inputs and outputs to AeroSandbox are expressed in base metric units, or derived units thereof (meters, newtons, meters per second, kilograms, etc.). The only exception to this rule is when units are explicitly noted in a variable name: for example,
battery_capacity would be in units of joules,
elastic_modulus would be in units of pascals, and
battery_capacity_watt_hours would be in units of watt-hours.
The fastest way to ensure that all dependencies are satisfied is by simply running "pip install AeroSandbox" in your command prompt. However, you can also install dependencies on your own if you'd like: see "requirements.txt" for the list.
- User-friendly, concise, high-level, object-oriented structure for airplane geometry definition and analysis.
- Fully reverse-mode AD compatible vortex-lattice method flow solver ("VLM3")! Very fast (~0.35s for typical problems) and fully compatible with arbitrary combinations of lifting surfaces. With this, you can get the gradient of a design space with arbitrary dimensionality almost instantly.
The primary purpose for this repository is to explore existing methods for aerodynamic analysis and develop new methods within a unified code base.
This package eventually seeks to develop the following:
An aerodynamics tool that models flow around any general triangulated 3D shape (with non-separated flow) using strongly-coupled viscous/inviscid methods. If successful, this could be orders of magnitude faster than volume-mesh-based CFD while retaining high accuracy (XFoil is a 2D example of this).
This code is made open-source in hopes that the aerospace community can benefit from this work. I've benefitted so much from open-source aerospace tools that came before me (XFoil, AVL, QProp, GPKit, XFLR5, OpenVSP, SU2, and SUAVE, just to name a few), so I hope to pay it forward, at least in small part!