API Documentation

import os
import requests

API = "https://aerodule.com/api/v1/propulsion"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

payload = {
    "sim_params": {
        "input_units":  {"system": "imperial"},
        "output_units": {"system": "imperial"},
        "atmosphere": {"altitude": 0},
    },
    "propulsion_params": {
        "motor": "scorpion-s-ii-2205-v2",
        "propeller": "apc-9-625x3-75n",
    },
    "airspeed": {"from": 0, "to": 120, "step": 40},
    "voltage":  {"from": 7.4, "to": 14.8, "step": 3.7},
}

r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=30)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

if data["units"]["system"] == "imperial":
    speed, force, length, density = "ft/s", "lbf", "ft", "slug/ft^3"
else:
    speed, force, length, density = "m/s", "N", "m", "kg/m^3"

motor, prop, atm = data["motor"], data["propeller"], data["atmosphere"]
print(f"Model      : {data['model']['name']} {data['model']['version']}")
print(f"Units      : {data['units']['system']}")
print(f"Motor      : {motor['name']} ({motor['id']}), {motor['kv']} kV")
print(f"Propeller  : {prop['name']} ({prop['id']}), "
      f"diameter {prop['diameter']} {length}, pitch {prop['pitch']} {length}")
line = f"Atmosphere : density {atm['density']} {density}"
if "altitude" in atm:
    line += f", altitude {atm['altitude']} {length}"
print(line)

g = data["grid"]
tables = [
    ("thrust",    f"Thrust ({force})"),
    ("amps",      "Current (A)"),
    ("rpm",       "RPM"),
    ("eta_motor", "Motor efficiency"),
    ("eta_prop",  "Propeller efficiency"),
    ("eta_total", "Total efficiency"),
]
corner = f"V / {speed}"
for key, title in tables:
    # One row per voltage, one column per airspeed. None is an omitted point.
    print(f"\n{title}")
    print(f"{corner:>10}" + "".join(f"{a:>10g}" for a in g["airspeeds"]))
    for v, row in zip(g["voltages"], g[key]):
        cells = "".join(f"{'-':>10}" if x is None else f"{x:>10g}" for x in row)
        print(f"{v:>10g}" + cells)

print(f"\nOmitted points: {data['omitted']['count']}")
for o in data["omitted"]["points"]:
    print(f"  {o['voltage']:g} V, {o['airspeed']:g} {speed}: {o['reason']}")

u = data["usage"]
print(f"\nAPI quota used by this request : {u['compute_seconds']} s")
print(f"API quota left this period     : {u['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {u['reserve_remaining_seconds']} s")

import os
import requests

API = "https://aerodule.com/api/v1/wing"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

payload = {
    "sim_params": {
        "input_units":  {"system": "imperial", "angle": "deg"},
        "output_units": {"system": "imperial", "angle": "deg", "derivative": "1/deg"},
        "airspeed": 60,
        "atmosphere": {"altitude": 0},
    },
    "wing_params": {
        "span": 8,
        "root_chord": 1.25,
        "tip_chord": 0.75,
        "sweep": {"angle": 0, "reference": 0.25},
        "dihedral": 3,
        "twist": -2,
        "airfoil": {"catalog": "naca2412.dat"},
    },
}

r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=120)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

units = data["units"]
length, area = ("ft", "ft^2") if units["system"] == "imperial" else ("m", "m^2")
angle, per = units["angle"], units["derivative"]

print(f"Model  : {data['model']['name']} {data['model']['version']}")
print(f"Units  : {units['system']}, angles in {angle}, derivatives in {per}")

# Everything solved, then the planform, tip device and section echoed back.
geo = data["geometry"]
print("\nGeometry")
for name, unit in [("sref", area), ("AR", ""), ("TR", ""), ("MAC", length),
                   ("span", length), ("root_chord", length), ("tip_chord", length),
                   ("sweep_ref", ""), ("sweep", angle), ("dihedral", angle), ("twist", angle),
                   ("wingtip_type", "")]:
    print(f"  {name:<14} {geo[name]} {unit}".rstrip())
# One to three parameters, depending on the device: height and chord for an
# endplate; height, quarter-chord sweep and taper for a winglet; none at all
# when no device is fitted.
for i in (1, 2, 3):
    key = f"wingtip_param_{i}"
    if key in geo:
        print(f"  {key:<14} {geo[key]}")
print(f"  airfoil        {len(geo['airfoil_x'])} coordinate pairs, "
      f"first ({geo['airfoil_x'][0]}, {geo['airfoil_y'][0]})")

aero = data["aerodynamics"]
print("\nAerodynamics")
print(f"  CL_alpha       {aero['CL_alpha']} {per}")
print(f"  CY_beta        {aero['CY_beta']} {per}")
print(f"  CMl_beta       {aero['CMl_beta']} {per}")
print(f"  CMn_beta       {aero['CMn_beta']} {per}")
print(f"  CMm0           {aero['CMm0']}")
print(f"  interference_factor {aero['interference_factor']}")
print(f"  root_le_to_ac  {aero['root_le_to_ac']} {length}")
print(f"  stall_alpha    {aero['stall']['stall_alpha']} {angle}")
print(f"  stall_y        {aero['stall']['stall_y']} {length}")

# Parallel arrays on one AOA grid, from zero lift up to stall.
print(f"\n{'alpha (' + angle + ')':>12}{'CL':>12}{'CDi':>12}")
for alpha, cl, cdi in zip(aero["aoas"], aero["CL"], aero["CDi"]):
    print(f"{alpha:>12g}{cl:>12.6f}{cdi:>12.6f}")

# Present only when the solve has something to flag.
warnings = data.get("warnings", [])
print(f"\nWarnings: {len(warnings)}")
for w in warnings:
    print(f"  {w}")

u = data["usage"]
print(f"\nAPI quota used by this request : {u['compute_seconds']} s")
print(f"API quota left this period     : {u['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {u['reserve_remaining_seconds']} s")

import os
import requests

API = "https://aerodule.com/api/v1/wing"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

payload = {
    "sim_params": {
        "input_units":  {"system": "imperial", "angle": "deg"},
        "output_units": {"system": "imperial", "angle": "deg", "derivative": "1/deg"},
        "airspeed": 60,
        "atmosphere": {"altitude": 0},
    },
    "wing_params": {
        "span": 8,
        "root_chord": 1.25,
        "tip_chord": 0.75,
        "sweep": {"angle": 0, "reference": 0.25},
        "dihedral": 3,
        "twist": -2,
        "airfoil": {"catalog": "naca2412.dat"},
    },
    "parasite_drag": {
        "roughness": 0.0000167,
        "crud_factor": 1.2,
        "interference_factor": 1.1,
    },
}

r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=120)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

units = data["units"]
length, area = ("ft", "ft^2") if units["system"] == "imperial" else ("m", "m^2")
angle, per = units["angle"], units["derivative"]

print(f"Model  : {data['model']['name']} {data['model']['version']}")
print(f"Units  : {units['system']}, angles in {angle}, derivatives in {per}")

# Everything solved, then the planform, tip device and section echoed back.
geo = data["geometry"]
print("\nGeometry")
for name, unit in [("sref", area), ("AR", ""), ("TR", ""), ("MAC", length),
                   ("span", length), ("root_chord", length), ("tip_chord", length),
                   ("sweep_ref", ""), ("sweep", angle), ("dihedral", angle), ("twist", angle),
                   ("wingtip_type", "")]:
    print(f"  {name:<14} {geo[name]} {unit}".rstrip())
# One to three parameters, depending on the device: height and chord for an
# endplate; height, quarter-chord sweep and taper for a winglet; none at all
# when no device is fitted.
for i in (1, 2, 3):
    key = f"wingtip_param_{i}"
    if key in geo:
        print(f"  {key:<14} {geo[key]}")
print(f"  airfoil        {len(geo['airfoil_x'])} coordinate pairs, "
      f"first ({geo['airfoil_x'][0]}, {geo['airfoil_y'][0]})")

aero = data["aerodynamics"]
print("\nAerodynamics")
print(f"  CL_alpha       {aero['CL_alpha']} {per}")
print(f"  CY_beta        {aero['CY_beta']} {per}")
print(f"  CMl_beta       {aero['CMl_beta']} {per}")
print(f"  CMn_beta       {aero['CMn_beta']} {per}")
print(f"  CMm0           {aero['CMm0']}")
print(f"  interference_factor {aero['interference_factor']}")
print(f"  root_le_to_ac  {aero['root_le_to_ac']} {length}")
print(f"  stall_alpha    {aero['stall']['stall_alpha']} {angle}")
print(f"  stall_y        {aero['stall']['stall_y']} {length}")

# Parallel arrays on one AOA grid, from zero lift up to stall. With parasite_drag
# sent, the drag build-up is included: CD = CDi + CD0, CD0 = CD_friction + CD_form.
columns = ["CL", "CD", "CDi", "CD0", "CD_friction", "CD_form"]
print(f"\n{'alpha (' + angle + ')':>12}" + "".join(f"{name:>12}" for name in columns))
for i, alpha in enumerate(aero["aoas"]):
    print(f"{alpha:>12g}" + "".join(f"{aero[name][i]:>12.6f}" for name in columns))

# Present only when the solve has something to flag.
warnings = data.get("warnings", [])
print(f"\nWarnings: {len(warnings)}")
for w in warnings:
    print(f"  {w}")

u = data["usage"]
print(f"\nAPI quota used by this request : {u['compute_seconds']} s")
print(f"API quota left this period     : {u['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {u['reserve_remaining_seconds']} s")

import os
import requests

API = "https://aerodule.com/api/v1/aircraft"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

units = {"system": "imperial", "angle": "deg", "derivative": "1/deg"}

payload = {
    "sim_params": {
        "input_units": units,
        "output_units": units,
        "airspeed": 60,
        "atmosphere": {"altitude": 0},
        "parasite_drag": False,
        "grow_tail_to_trim": False,
    },
    "wing_params": {
        "span": 8,
        "root_chord": 1.25,
        "tip_chord": 0.75,
        "sweep": {"angle": 0, "reference": 0.25},
        "dihedral": 3,
        "twist": -2,
        "incidence": 2,
        "cg_to_ac": 0.1,
        "ac_z_from_cg": 0,
        "aerodynamics": "simulate",
        "airfoil": {"catalog": "naca2412.dat"},
        "tip_device": {"type": "endplate", "height": 0.45, "chord": 0.5},
    },
    "tail_params": {
        "configuration": "conventional/cruciform",
        "elevator": {"chord_ratio": 0.33, "max_deflection": 30},
        "horizontal": {
            "AR": 4,
            "TR": 0.6,
            "sweep": {"angle": 0, "reference": 0.25},
            "arm": 3.5,
            "sizing": {"method": "stability", "value": -0.03},
            "incidence": 0,
            "root_z_from_cg": 0,
            "aerodynamics": "simulate",
            "airfoil": {"catalog": "n0012.dat"},
        },
        "vertical": {
            "AR": 1.5,
            "TR": 0.5,
            "sweep": {"angle": 15, "reference": 0},
            "arm": 3.5,
            "sizing": {"method": "stability", "value": 0.001},
            "root_z_from_cg": 0,
            "aerodynamics": "simulate",
            "airfoil": {"catalog": "n0012.dat"},
        },
    },
}

# The wing is simulated first, then the aircraft: allow a generous timeout.
r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=300)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

u = data["units"]
length, area = ("ft", "ft^2") if u["system"] == "imperial" else ("m", "m^2")
angle, per = u["angle"], u["derivative"]

print(f"Model  : {data['model']['name']} {data['model']['version']}")
print(f"Units  : {u['system']}, angles in {angle}, derivatives in {per}")

# Geometry is grouped the way the exported workbooks are: the aircraft, the wing
# it was built on, then the tail.
geo = data["geometry"]
print("\nGeometry: aircraft")
for name, unit in [("Swet_fus", area), ("x_cg_to_wing_ac", length),
                   ("z_wing_ac_from_cg", length), ("wing_incidence", angle),
                   ("tail_configuration", "")]:
    print(f"  {name:<18} {geo['aircraft'][name]} {unit}".rstrip())

# The wing geometry always comes back: every figure in it follows from the
# planform that was sent, whether or not the wing was solved here.
w = geo["wing"]
print("\nGeometry: wing")
for name, unit in [("sref", area), ("AR", ""), ("TR", ""), ("MAC", length),
                   ("span", length), ("root_chord", length), ("tip_chord", length),
                   ("sweep_ref", ""), ("sweep", angle), ("dihedral", angle),
                   ("twist", angle), ("wingtip_type", "")]:
    print(f"  {name:<18} {w[name]} {unit}".rstrip())
# One to three parameters, depending on the device: height and chord for an
# endplate; height, quarter-chord sweep and taper for a winglet; none at all
# when no device is fitted.
for i in (1, 2, 3):
    key = f"wingtip_param_{i}"
    if key in w:
        print(f"  {key:<18} {w[key]}")
# The section is there only where one was given: a wing handed in as a polar
# names no airfoil.
if "airfoil_x" in w:
    print(f"  airfoil            {len(w['airfoil_x'])} coordinate pairs, "
          f"first ({w['airfoil_x'][0]}, {w['airfoil_y'][0]})")

tail = geo["tail"]
print(f"\nGeometry: tail ({tail['tail_configuration']})")
dims = [("area", area), ("span", length), ("root_chord", length), ("tip_chord", length),
        ("MAC", length), ("x_ac_from_root_LE", length), ("root_z_from_cg", length),
        ("AR", ""), ("TR", ""), ("sweep_ref", ""), ("sweep", angle), ("arm", length),
        ("incidence", angle)]
for surface in ("horizontal", "vertical"):
    if surface not in tail:            # no vertical block on a v-tail or a-tail
        continue
    s = tail[surface]
    print(f"\nGeometry: {surface} tail")
    for name, unit in dims:
        if name in s:                  # incidence is the horizontal tail's alone
            print(f"  {name:<18} {s[name]} {unit}".rstrip())
    if "airfoil_x" in s:               # only where a section was given
        print(f"  airfoil            {len(s['airfoil_x'])} coordinate pairs, "
              f"first ({s['airfoil_x'][0]}, {s['airfoil_y'][0]})")
if "dihedral" in tail:                 # v-tail or a-tail only
    print(f"\n  dihedral           {tail['dihedral']} {angle}")

aero = data["aerodynamics"]["aircraft"]
print("\nStability")
print(f"  CMm_aoa  {aero['CMm_aoa']} {per}")
print(f"  CMn_beta {aero['CMn_beta']} {per}")
print(f"  CMl_beta {aero['CMl_beta']} {per}")
print(f"  SM       {aero['SM']}")
print(f"  NP       {aero['NP']} {length}")
print("\nPropwash")
print(f"  propwash_HT {aero['propwash_HT']}")
if "propwash_VT" in aero:              # not returned for a v-tail or a-tail
    print(f"  propwash_VT {aero['propwash_VT']}")

# Parallel arrays on one AOA grid, from zero lift up to the maximum trim AOA.
# The CD_ components sum to CD. CD_VT is null throughout on a v-tail or a-tail.
columns = ["CL", "CD", "CD_wing", "CD_fus", "CD_HT", "CD_VT",
           "CD_trim", "CD_nac", "CD_misc", "de_trim"]
print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>11}" for name in columns))
for i, alpha in enumerate(aero["aoas"]):
    cells = "".join(f"{'-':>11}" if aero[name][i] is None else f"{aero[name][i]:>11.6f}"
                    for name in columns)
    print(f"{alpha:>11g}" + cells)

# The wing the aircraft was built on, on its own AOA grid: it runs below the
# aircraft's, because the aircraft reaches zero lift beneath the wing's own.
wing_aero = data["aerodynamics"].get("wing")
if wing_aero:
    print("\nWing aerodynamics")
    for name, unit in [("CL_alpha", per), ("CY_beta", per), ("CMl_beta", per),
                       ("CMn_beta", per), ("CMm0", ""), ("interference_factor", ""),
                       ("root_le_to_ac", length)]:
        print(f"  {name:<20} {wing_aero[name]} {unit}".rstrip())
    # The parasite columns are there only when parasite drag was modelled; CD is
    # the plain sum of CDi and CD0, with the interference factor left to apply.
    wcols = [c for c in ("CL", "CD", "CDi", "CD0", "CD_friction", "CD_form")
             if c in wing_aero]
    print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>13}" for name in wcols))
    for i, alpha in enumerate(wing_aero["aoas"]):
        print(f"{alpha:>11g}" + "".join(f"{wing_aero[name][i]:>13.6f}" for name in wcols))

# Present only when the solve has something to flag.
warnings = data.get("warnings", [])
print(f"\nWarnings: {len(warnings)}")
for w in warnings:
    print(f"  {w}")

usage = data["usage"]
print(f"\nAPI quota used by this request : {usage['compute_seconds']} s")
print(f"API quota left this period     : {usage['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {usage['reserve_remaining_seconds']} s")

import os
import requests

API = "https://aerodule.com/api/v1/aircraft"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

units = {"system": "imperial", "angle": "deg", "derivative": "1/deg"}

payload = {
    "sim_params": {
        "input_units": units,
        "output_units": units,
        "airspeed": 70,
        "atmosphere": {"altitude": 2000},
        "parasite_drag": True,
        "max_trim_aoa": 14,
        "grow_tail_to_trim": False,
    },
    "wing_params": {
        "span": 9,
        "root_chord": 1.3,
        "tip_chord": 0.8,
        "sweep": {"angle": 3, "reference": 0.25},
        "dihedral": 4,
        "twist": -2,
        "incidence": 2,
        "cg_to_ac": 0.12,
        "ac_z_from_cg": 0.15,
        "aerodynamics": "simulate",
        "airfoil": {"catalog": "naca2412.dat"},
        "tip_device": {
            "type": "winglet",
            "height": 0.5,
            "taper": 0.45,
            "sweep": {"angle": 28, "reference": 0.25},
        },
        "roughness": 1.67e-05,
        "crud_factor": 1.2,
        "interference_factor": 1.1,
    },
    "tail_params": {
        "configuration": "v_tail",
        "elevator": {"chord_ratio": 0.33, "max_deflection": 30},
        "horizontal": {
            "AR": 4,
            "TR": 0.6,
            "sweep": {"angle": 10, "reference": 0.25},
            "arm": 3.6,
            "sizing": {"method": "volume_coefficient", "value": 0.6},
            "incidence": 0,
            "root_z_from_cg": 0.3,
            "aerodynamics": "simulate",
            "airfoil": {"catalog": "n0012.dat"},
            "roughness": 1.67e-05,
            "crud_factor": 1.2,
            "interference_factor": 1.15,
        },
        "vertical": {
            "sizing": {"method": "volume_coefficient", "value": 0.04},
        },
    },
    "fuselage_params": {
        "nose": {"length": 1, "angle": 12},
        "center": {"length": 3, "angle": 0},
        "tail": {"length": 1.5, "angle": 8},
        "nose_to_cg": 1.8,
        "fwd_center_diameter": 0.55,
        "aft_center_diameter": 0.45,
        "roughness": 1.67e-05,
        "crud_factor": 1.2,
        "interference_factor": 1,
    },
    "propeller_params": {
        "diameter": 1.2,
        "count": 1,
        "blades": 2,
        "thrust": 6,
        "hub_to_cg": -2.2,
        "hub_z_from_cg": 0.1,
        "blanket_ratio": {"horizontal": 0.4},
    },
    "misc_drag_params": {
        "sources": [{"cd": 0.8, "area": 0.05, "z_from_cg": 0.3}],
        "nacelles": [
            {
                "length": 0.9,
                "diameter": 0.25,
                "roughness": 1.67e-05,
                "interference_factor": 1.1,
            },
        ],
        "nacelle_crud_factor": 1.2,
    },
}

# The wing is simulated first, then the aircraft: allow a generous timeout.
r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=300)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

u = data["units"]
length, area = ("ft", "ft^2") if u["system"] == "imperial" else ("m", "m^2")
angle, per = u["angle"], u["derivative"]

print(f"Model  : {data['model']['name']} {data['model']['version']}")
print(f"Units  : {u['system']}, angles in {angle}, derivatives in {per}")

# Geometry is grouped the way the exported workbooks are: the aircraft, the wing
# it was built on, then the tail.
geo = data["geometry"]
print("\nGeometry: aircraft")
for name, unit in [("Swet_fus", area), ("x_cg_to_wing_ac", length),
                   ("z_wing_ac_from_cg", length), ("wing_incidence", angle),
                   ("tail_configuration", "")]:
    print(f"  {name:<18} {geo['aircraft'][name]} {unit}".rstrip())

# The wing geometry always comes back: every figure in it follows from the
# planform that was sent, whether or not the wing was solved here.
w = geo["wing"]
print("\nGeometry: wing")
for name, unit in [("sref", area), ("AR", ""), ("TR", ""), ("MAC", length),
                   ("span", length), ("root_chord", length), ("tip_chord", length),
                   ("sweep_ref", ""), ("sweep", angle), ("dihedral", angle),
                   ("twist", angle), ("wingtip_type", "")]:
    print(f"  {name:<18} {w[name]} {unit}".rstrip())
# One to three parameters, depending on the device: height and chord for an
# endplate; height, quarter-chord sweep and taper for a winglet; none at all
# when no device is fitted.
for i in (1, 2, 3):
    key = f"wingtip_param_{i}"
    if key in w:
        print(f"  {key:<18} {w[key]}")
# The section is there only where one was given: a wing handed in as a polar
# names no airfoil.
if "airfoil_x" in w:
    print(f"  airfoil            {len(w['airfoil_x'])} coordinate pairs, "
          f"first ({w['airfoil_x'][0]}, {w['airfoil_y'][0]})")

tail = geo["tail"]
print(f"\nGeometry: tail ({tail['tail_configuration']})")
dims = [("area", area), ("span", length), ("root_chord", length), ("tip_chord", length),
        ("MAC", length), ("x_ac_from_root_LE", length), ("root_z_from_cg", length),
        ("AR", ""), ("TR", ""), ("sweep_ref", ""), ("sweep", angle), ("arm", length),
        ("incidence", angle)]
for surface in ("horizontal", "vertical"):
    if surface not in tail:            # no vertical block on a v-tail or a-tail
        continue
    s = tail[surface]
    print(f"\nGeometry: {surface} tail")
    for name, unit in dims:
        if name in s:                  # incidence is the horizontal tail's alone
            print(f"  {name:<18} {s[name]} {unit}".rstrip())
    if "airfoil_x" in s:               # only where a section was given
        print(f"  airfoil            {len(s['airfoil_x'])} coordinate pairs, "
              f"first ({s['airfoil_x'][0]}, {s['airfoil_y'][0]})")
if "dihedral" in tail:                 # v-tail or a-tail only
    print(f"\n  dihedral           {tail['dihedral']} {angle}")

aero = data["aerodynamics"]["aircraft"]
print("\nStability")
print(f"  CMm_aoa  {aero['CMm_aoa']} {per}")
print(f"  CMn_beta {aero['CMn_beta']} {per}")
print(f"  CMl_beta {aero['CMl_beta']} {per}")
print(f"  SM       {aero['SM']}")
print(f"  NP       {aero['NP']} {length}")
print("\nPropwash")
print(f"  propwash_HT {aero['propwash_HT']}")
if "propwash_VT" in aero:              # not returned for a v-tail or a-tail
    print(f"  propwash_VT {aero['propwash_VT']}")

# Parallel arrays on one AOA grid, from zero lift up to the maximum trim AOA.
# The CD_ components sum to CD. CD_VT is null throughout on a v-tail or a-tail.
columns = ["CL", "CD", "CD_wing", "CD_fus", "CD_HT", "CD_VT",
           "CD_trim", "CD_nac", "CD_misc", "de_trim"]
print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>11}" for name in columns))
for i, alpha in enumerate(aero["aoas"]):
    cells = "".join(f"{'-':>11}" if aero[name][i] is None else f"{aero[name][i]:>11.6f}"
                    for name in columns)
    print(f"{alpha:>11g}" + cells)

# The wing the aircraft was built on, on its own AOA grid: it runs below the
# aircraft's, because the aircraft reaches zero lift beneath the wing's own.
wing_aero = data["aerodynamics"].get("wing")
if wing_aero:
    print("\nWing aerodynamics")
    for name, unit in [("CL_alpha", per), ("CY_beta", per), ("CMl_beta", per),
                       ("CMn_beta", per), ("CMm0", ""), ("interference_factor", ""),
                       ("root_le_to_ac", length)]:
        print(f"  {name:<20} {wing_aero[name]} {unit}".rstrip())
    # The parasite columns are there only when parasite drag was modelled; CD is
    # the plain sum of CDi and CD0, with the interference factor left to apply.
    wcols = [c for c in ("CL", "CD", "CDi", "CD0", "CD_friction", "CD_form")
             if c in wing_aero]
    print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>13}" for name in wcols))
    for i, alpha in enumerate(wing_aero["aoas"]):
        print(f"{alpha:>11g}" + "".join(f"{wing_aero[name][i]:>13.6f}" for name in wcols))

# Present only when the solve has something to flag.
warnings = data.get("warnings", [])
print(f"\nWarnings: {len(warnings)}")
for w in warnings:
    print(f"  {w}")

usage = data["usage"]
print(f"\nAPI quota used by this request : {usage['compute_seconds']} s")
print(f"API quota left this period     : {usage['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {usage['reserve_remaining_seconds']} s")

import os
import requests

API = "https://aerodule.com/api/v1/aircraft"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

units = {"system": "imperial", "angle": "deg", "derivative": "1/deg"}

payload = {
    "sim_params": {
        "input_units": units,
        "output_units": units,
        "airspeed": 65,
        "atmosphere": {"density": 0.0023769, "viscosity": 3.737e-07},
        "parasite_drag": True,
        "max_trim_aoa": 10,
        "grow_tail_to_trim": False,
    },
    "wing_params": {
        "span": 8.5,
        "root_chord": 1.2,
        "tip_chord": 0.8,
        "sweep": {"angle": 2, "reference": 0.25},
        "dihedral": 3,
        "twist": -1.5,
        "incidence": 1.5,
        "cg_to_ac": 0.15,
        "ac_z_from_cg": 0.1,
        "aerodynamics": "input",
        "polar": {
            "aoa": [-8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14],
            "CL": [-0.54, -0.36, -0.18, 0, 0.18, 0.36, 0.54, 0.72, 0.9, 1.08, 1.26, 1.44],
            "CD": [0.02615, 0.018567, 0.014017, 0.0125, 0.014017, 0.018567, 0.02615, 0.036766, 0.050416, 0.0671, 0.086816, 0.109566],
            "CDi": [0.01365, 0.006067, 0.001517, 0, 0.001517, 0.006067, 0.01365, 0.024266, 0.037916, 0.0546, 0.074316, 0.097066],
            "CD0": [0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125, 0.0125],
        },
        "root_le_to_ac": 0.26,
        "CMm0": -0.05,
        "CY_beta": -0.005,
        "CMl_beta": -0.0012,
        "interference_factor": 1.1,
    },
    "tail_params": {
        "configuration": "a_tail",
        "elevator": {"chord_ratio": 0.3, "max_deflection": 25},
        "spanwise_mac_location": 0.62,
        "horizontal": {
            "AR": 3.5,
            "TR": 0.55,
            "sweep": {"angle": 8, "reference": 0.25},
            "arm": 3.4,
            "sizing": {"method": "area", "value": 2.2},
            "incidence": -1,
            "root_z_from_cg": -0.2,
            "aerodynamics": "input",
            "polar": {
                "aoa": [-14, -12, -9, -6, -3, 0, 3, 6, 9, 12, 14],
                "CL": [-0.98, -0.84, -0.63, -0.42, -0.21, 0, 0.21, 0.42, 0.63, 0.84, 0.98],
                "CD": [0.093918, 0.071389, 0.044094, 0.024597, 0.012899, 0.009, 0.012899, 0.024597, 0.044094, 0.071389, 0.093918],
            },
            "CMm0": 0,
            "root_le_to_ac": 0.21,
            "interference_factor": 1.15,
        },
        "vertical": {
            "sizing": {"method": "dihedral", "value": 35},
        },
    },
}

# The wing is simulated first, then the aircraft: allow a generous timeout.
r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=300)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

u = data["units"]
length, area = ("ft", "ft^2") if u["system"] == "imperial" else ("m", "m^2")
angle, per = u["angle"], u["derivative"]

print(f"Model  : {data['model']['name']} {data['model']['version']}")
print(f"Units  : {u['system']}, angles in {angle}, derivatives in {per}")

# Geometry is grouped the way the exported workbooks are: the aircraft, the wing
# it was built on, then the tail.
geo = data["geometry"]
print("\nGeometry: aircraft")
for name, unit in [("Swet_fus", area), ("x_cg_to_wing_ac", length),
                   ("z_wing_ac_from_cg", length), ("wing_incidence", angle),
                   ("tail_configuration", "")]:
    print(f"  {name:<18} {geo['aircraft'][name]} {unit}".rstrip())

# The wing geometry always comes back: every figure in it follows from the
# planform that was sent, whether or not the wing was solved here.
w = geo["wing"]
print("\nGeometry: wing")
for name, unit in [("sref", area), ("AR", ""), ("TR", ""), ("MAC", length),
                   ("span", length), ("root_chord", length), ("tip_chord", length),
                   ("sweep_ref", ""), ("sweep", angle), ("dihedral", angle),
                   ("twist", angle), ("wingtip_type", "")]:
    print(f"  {name:<18} {w[name]} {unit}".rstrip())
# One to three parameters, depending on the device: height and chord for an
# endplate; height, quarter-chord sweep and taper for a winglet; none at all
# when no device is fitted.
for i in (1, 2, 3):
    key = f"wingtip_param_{i}"
    if key in w:
        print(f"  {key:<18} {w[key]}")
# The section is there only where one was given: a wing handed in as a polar
# names no airfoil.
if "airfoil_x" in w:
    print(f"  airfoil            {len(w['airfoil_x'])} coordinate pairs, "
          f"first ({w['airfoil_x'][0]}, {w['airfoil_y'][0]})")

tail = geo["tail"]
print(f"\nGeometry: tail ({tail['tail_configuration']})")
dims = [("area", area), ("span", length), ("root_chord", length), ("tip_chord", length),
        ("MAC", length), ("x_ac_from_root_LE", length), ("root_z_from_cg", length),
        ("AR", ""), ("TR", ""), ("sweep_ref", ""), ("sweep", angle), ("arm", length),
        ("incidence", angle)]
for surface in ("horizontal", "vertical"):
    if surface not in tail:            # no vertical block on a v-tail or a-tail
        continue
    s = tail[surface]
    print(f"\nGeometry: {surface} tail")
    for name, unit in dims:
        if name in s:                  # incidence is the horizontal tail's alone
            print(f"  {name:<18} {s[name]} {unit}".rstrip())
    if "airfoil_x" in s:               # only where a section was given
        print(f"  airfoil            {len(s['airfoil_x'])} coordinate pairs, "
              f"first ({s['airfoil_x'][0]}, {s['airfoil_y'][0]})")
if "dihedral" in tail:                 # v-tail or a-tail only
    print(f"\n  dihedral           {tail['dihedral']} {angle}")

aero = data["aerodynamics"]["aircraft"]
print("\nStability")
print(f"  CMm_aoa  {aero['CMm_aoa']} {per}")
print(f"  CMn_beta {aero['CMn_beta']} {per}")
print(f"  CMl_beta {aero['CMl_beta']} {per}")
print(f"  SM       {aero['SM']}")
print(f"  NP       {aero['NP']} {length}")
print("\nPropwash")
print(f"  propwash_HT {aero['propwash_HT']}")
if "propwash_VT" in aero:              # not returned for a v-tail or a-tail
    print(f"  propwash_VT {aero['propwash_VT']}")

# Parallel arrays on one AOA grid, from zero lift up to the maximum trim AOA.
# The CD_ components sum to CD. CD_VT is null throughout on a v-tail or a-tail.
columns = ["CL", "CD", "CD_wing", "CD_fus", "CD_HT", "CD_VT",
           "CD_trim", "CD_nac", "CD_misc", "de_trim"]
print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>11}" for name in columns))
for i, alpha in enumerate(aero["aoas"]):
    cells = "".join(f"{'-':>11}" if aero[name][i] is None else f"{aero[name][i]:>11.6f}"
                    for name in columns)
    print(f"{alpha:>11g}" + cells)

# The wing the aircraft was built on, on its own AOA grid: it runs below the
# aircraft's, because the aircraft reaches zero lift beneath the wing's own.
wing_aero = data["aerodynamics"].get("wing")
if wing_aero:
    print("\nWing aerodynamics")
    for name, unit in [("CL_alpha", per), ("CY_beta", per), ("CMl_beta", per),
                       ("CMn_beta", per), ("CMm0", ""), ("interference_factor", ""),
                       ("root_le_to_ac", length)]:
        print(f"  {name:<20} {wing_aero[name]} {unit}".rstrip())
    # The parasite columns are there only when parasite drag was modelled; CD is
    # the plain sum of CDi and CD0, with the interference factor left to apply.
    wcols = [c for c in ("CL", "CD", "CDi", "CD0", "CD_friction", "CD_form")
             if c in wing_aero]
    print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>13}" for name in wcols))
    for i, alpha in enumerate(wing_aero["aoas"]):
        print(f"{alpha:>11g}" + "".join(f"{wing_aero[name][i]:>13.6f}" for name in wcols))

# Present only when the solve has something to flag.
warnings = data.get("warnings", [])
print(f"\nWarnings: {len(warnings)}")
for w in warnings:
    print(f"  {w}")

usage = data["usage"]
print(f"\nAPI quota used by this request : {usage['compute_seconds']} s")
print(f"API quota left this period     : {usage['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {usage['reserve_remaining_seconds']} s")

import os
import requests

API = "https://aerodule.com/api/v1/aircraft"
KEY = os.environ["AERODULE_API_KEY"]   # export AERODULE_API_KEY=ak_...

units = {"system": "imperial", "angle": "deg", "derivative": "1/deg"}

payload = {
    "sim_params": {
        "input_units": units,
        "output_units": units,
        "airspeed": 75,
        "atmosphere": {"altitude": 1000},
        "parasite_drag": True,
        "max_trim_aoa": 12,
        "grow_tail_to_trim": False,
    },
    "wing_params": {
        "span": 9.5,
        "root_chord": 1.35,
        "tip_chord": 0.85,
        "sweep": {"angle": 0, "reference": 0.25},
        "dihedral": 2,
        "twist": -2,
        "incidence": 1.5,
        "cg_to_ac": 0.14,
        "ac_z_from_cg": 0.12,
        "aerodynamics": "simulate",
        "airfoil": {
            "points": [
                [1, 0.0013],
                [0.95, 0.0114],
                [0.9, 0.0208],
                [0.8, 0.0375],
                [0.7, 0.0518],
                [0.6, 0.0636],
                [0.5, 0.0724],
                [0.4, 0.078],
                [0.3, 0.0788],
                [0.25, 0.0767],
                [0.2, 0.0726],
                [0.15, 0.0661],
                [0.1, 0.0563],
                [0.075, 0.0496],
                [0.05, 0.0413],
                [0.025, 0.0299],
                [0.0125, 0.0215],
                [0, 0],
                [0.0125, -0.0165],
                [0.025, -0.0227],
                [0.05, -0.0301],
                [0.075, -0.0346],
                [0.1, -0.0375],
                [0.15, -0.041],
                [0.2, -0.0423],
                [0.25, -0.0422],
                [0.3, -0.0412],
                [0.4, -0.038],
                [0.5, -0.0334],
                [0.6, -0.0276],
                [0.7, -0.0214],
                [0.8, -0.015],
                [0.9, -0.0082],
                [0.95, -0.0048],
                [1, -0.0013],
            ],
        },
        "roughness": 1.67e-05,
        "crud_factor": 1.2,
        "interference_factor": 1.1,
    },
    "tail_params": {
        "configuration": "t_tail",
        "elevator": {"chord_ratio": 0.32, "max_deflection": 30},
        "spanwise_mac_location": 0.58,
        "horizontal": {
            "AR": 4.2,
            "TR": 0.55,
            "sweep": {"angle": 6, "reference": 0.25},
            "arm": 3.8,
            "sizing": {"method": "stability", "value": -0.03},
            "incidence": -1,
            "aerodynamics": "input",
            "polar": {
                "aoa": [-14, -12, -9, -6, -3, 0, 3, 6, 9, 12, 14],
                "CL": [-0.952, -0.816, -0.612, -0.408, -0.204, 0, 0.204, 0.408, 0.612, 0.816, 0.952],
                "CD": [0.089635, 0.068375, 0.042617, 0.024219, 0.01318, 0.0095, 0.01318, 0.024219, 0.042617, 0.068375, 0.089635],
            },
            "CMm0": 0,
            "root_le_to_ac": 0.19,
            "interference_factor": 1.15,
        },
        "vertical": {
            "AR": 1.4,
            "TR": 0.5,
            "sweep": {"angle": 20, "reference": 0.25},
            "arm": 3.7,
            "sizing": {"method": "volume_coefficient", "value": 0.045},
            "root_z_from_cg": 0.25,
            "aerodynamics": "input",
            "CY_beta": 0.028,
            "CD0": 0.011,
            "root_le_to_ac": 0.24,
            "interference_factor": 1.15,
        },
    },
    "propeller_params": {
        "diameter": 1.4,
        "count": 2,
        "blades": 3,
        "thrust": 8,
        "hub_to_cg": -1.9,
        "hub_z_from_cg": 0.05,
        "blanket_ratio": {"horizontal": 0, "vertical": 0.35},
    },
}

# The wing is simulated first, then the aircraft: allow a generous timeout.
r = requests.post(API, json=payload,
                  headers={"Authorization": f"Bearer {KEY}"}, timeout=300)
data = r.json()
if not r.ok:
    error = data["error"]
    raise SystemExit(f"{r.status_code} {error['code']}: {error['message']}")

u = data["units"]
length, area = ("ft", "ft^2") if u["system"] == "imperial" else ("m", "m^2")
angle, per = u["angle"], u["derivative"]

print(f"Model  : {data['model']['name']} {data['model']['version']}")
print(f"Units  : {u['system']}, angles in {angle}, derivatives in {per}")

# Geometry is grouped the way the exported workbooks are: the aircraft, the wing
# it was built on, then the tail.
geo = data["geometry"]
print("\nGeometry: aircraft")
for name, unit in [("Swet_fus", area), ("x_cg_to_wing_ac", length),
                   ("z_wing_ac_from_cg", length), ("wing_incidence", angle),
                   ("tail_configuration", "")]:
    print(f"  {name:<18} {geo['aircraft'][name]} {unit}".rstrip())

# The wing geometry always comes back: every figure in it follows from the
# planform that was sent, whether or not the wing was solved here.
w = geo["wing"]
print("\nGeometry: wing")
for name, unit in [("sref", area), ("AR", ""), ("TR", ""), ("MAC", length),
                   ("span", length), ("root_chord", length), ("tip_chord", length),
                   ("sweep_ref", ""), ("sweep", angle), ("dihedral", angle),
                   ("twist", angle), ("wingtip_type", "")]:
    print(f"  {name:<18} {w[name]} {unit}".rstrip())
# One to three parameters, depending on the device: height and chord for an
# endplate; height, quarter-chord sweep and taper for a winglet; none at all
# when no device is fitted.
for i in (1, 2, 3):
    key = f"wingtip_param_{i}"
    if key in w:
        print(f"  {key:<18} {w[key]}")
# The section is there only where one was given: a wing handed in as a polar
# names no airfoil.
if "airfoil_x" in w:
    print(f"  airfoil            {len(w['airfoil_x'])} coordinate pairs, "
          f"first ({w['airfoil_x'][0]}, {w['airfoil_y'][0]})")

tail = geo["tail"]
print(f"\nGeometry: tail ({tail['tail_configuration']})")
dims = [("area", area), ("span", length), ("root_chord", length), ("tip_chord", length),
        ("MAC", length), ("x_ac_from_root_LE", length), ("root_z_from_cg", length),
        ("AR", ""), ("TR", ""), ("sweep_ref", ""), ("sweep", angle), ("arm", length),
        ("incidence", angle)]
for surface in ("horizontal", "vertical"):
    if surface not in tail:            # no vertical block on a v-tail or a-tail
        continue
    s = tail[surface]
    print(f"\nGeometry: {surface} tail")
    for name, unit in dims:
        if name in s:                  # incidence is the horizontal tail's alone
            print(f"  {name:<18} {s[name]} {unit}".rstrip())
    if "airfoil_x" in s:               # only where a section was given
        print(f"  airfoil            {len(s['airfoil_x'])} coordinate pairs, "
              f"first ({s['airfoil_x'][0]}, {s['airfoil_y'][0]})")
if "dihedral" in tail:                 # v-tail or a-tail only
    print(f"\n  dihedral           {tail['dihedral']} {angle}")

aero = data["aerodynamics"]["aircraft"]
print("\nStability")
print(f"  CMm_aoa  {aero['CMm_aoa']} {per}")
print(f"  CMn_beta {aero['CMn_beta']} {per}")
print(f"  CMl_beta {aero['CMl_beta']} {per}")
print(f"  SM       {aero['SM']}")
print(f"  NP       {aero['NP']} {length}")
print("\nPropwash")
print(f"  propwash_HT {aero['propwash_HT']}")
if "propwash_VT" in aero:              # not returned for a v-tail or a-tail
    print(f"  propwash_VT {aero['propwash_VT']}")

# Parallel arrays on one AOA grid, from zero lift up to the maximum trim AOA.
# The CD_ components sum to CD. CD_VT is null throughout on a v-tail or a-tail.
columns = ["CL", "CD", "CD_wing", "CD_fus", "CD_HT", "CD_VT",
           "CD_trim", "CD_nac", "CD_misc", "de_trim"]
print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>11}" for name in columns))
for i, alpha in enumerate(aero["aoas"]):
    cells = "".join(f"{'-':>11}" if aero[name][i] is None else f"{aero[name][i]:>11.6f}"
                    for name in columns)
    print(f"{alpha:>11g}" + cells)

# The wing the aircraft was built on, on its own AOA grid: it runs below the
# aircraft's, because the aircraft reaches zero lift beneath the wing's own.
wing_aero = data["aerodynamics"].get("wing")
if wing_aero:
    print("\nWing aerodynamics")
    for name, unit in [("CL_alpha", per), ("CY_beta", per), ("CMl_beta", per),
                       ("CMn_beta", per), ("CMm0", ""), ("interference_factor", ""),
                       ("root_le_to_ac", length)]:
        print(f"  {name:<20} {wing_aero[name]} {unit}".rstrip())
    # The parasite columns are there only when parasite drag was modelled; CD is
    # the plain sum of CDi and CD0, with the interference factor left to apply.
    wcols = [c for c in ("CL", "CD", "CDi", "CD0", "CD_friction", "CD_form")
             if c in wing_aero]
    print(f"\n{'aoa (' + angle + ')':>11}" + "".join(f"{name:>13}" for name in wcols))
    for i, alpha in enumerate(wing_aero["aoas"]):
        print(f"{alpha:>11g}" + "".join(f"{wing_aero[name][i]:>13.6f}" for name in wcols))

# Present only when the solve has something to flag.
warnings = data.get("warnings", [])
print(f"\nWarnings: {len(warnings)}")
for w in warnings:
    print(f"  {w}")

usage = data["usage"]
print(f"\nAPI quota used by this request : {usage['compute_seconds']} s")
print(f"API quota left this period     : {usage['quota_remaining_seconds']} s")
print(f"Reserve API quota left         : {usage['reserve_remaining_seconds']} s")