Propulsion, control and navigation

Example 1 Endurance and area per flight with the same battery

A 6S 10 Ah battery (22.2 V) with 80% of its energy usable. The multirotor weighs 3.0 kg with 15-inch propellers; the fixed-wing weighs 3.0 kg with $L/D$ 10; the VTOL weighs 3.6 kg with $L/D$ 8, 13-inch lift rotors and 2 minutes of hover in total. Mapping uses a 150 m image swath with 70% side overlap and a 20% energy reserve (hypothetical values).

import math

G, RHO = 9.81, 1.225
E_USABLE = 22.2 * 10 * 0.8                    # Wh
RESERVE, SWATH, SIDELAP = 0.20, 150, 0.70

def hover_power(m, d_prop, n=4, fm=0.6, eta=0.8):
    thrust = m * G
    area = n * math.pi * (d_prop / 2) ** 2
    return thrust ** 1.5 / math.sqrt(2 * RHO * area) / fm / eta

def cruise_power(m, v, ld, eta=0.6 * 0.85):   # propeller × electrical efficiency
    return m * G * v / ld / eta

def area_km2(cruise_min, v):
    return cruise_min * (1 - RESERVE) * 60 * v * SWATH * (1 - SIDELAP) / 1e6

p_mr = hover_power(3.0, 0.381)
p_fw = cruise_power(3.0, 16, 10)
p_hv, p_cr = hover_power(3.6, 0.33), cruise_power(3.6, 16, 8)
t_mr, t_fw = E_USABLE / p_mr * 60, E_USABLE / p_fw * 60
t_vcruise = (E_USABLE - p_hv * 2 / 60) / p_cr * 60
print(f"multirotor  {p_mr:5.1f} W  {t_mr:5.1f} min  {area_km2(t_mr, 10):.2f} km2 per flight")
print(f"fixed-wing  {p_fw:5.1f} W  {t_fw:5.1f} min  {area_km2(t_fw, 16):.2f} km2 per flight")
print(f"VTOL hover {p_hv:.0f} W, cruise {p_cr:.1f} W  {t_vcruise + 2:5.1f} min  {area_km2(t_vcruise, 16):.2f} km2 per flight")

multirotor  314.7 W   33.9 min  0.73 km2 per flight
fixed-wing   92.3 W  115.4 min  3.99 km2 per flight
VTOL hover 478 W, cruise 138.5 W   72.0 min  2.42 km2 per flight

The fixed-wing flies more than three times as long as the multirotor because it needs far less power. The VTOL uses very high power while hovering but only briefly, so its endurance falls between the two. These are first estimates: a real multirotor in forward flight uses different power from hover, and strong wind shortens endurance for every type.

Example 2 DOP in the open and between buildings

DOP is computed from the satellite geometry matrix $G$. Each row is the unit vector from the user to a satellite (east, north, up) followed by 1 for the receiver clock, and $Q=(G^{\mathsf{T}}G{)}^{-1}$.

import math
import numpy as np

def dop(sats):                                # (azimuth, elevation) degrees
    rows = []
    for az, el in sats:
        a, e = math.radians(az), math.radians(el)
        rows.append([math.cos(e) * math.sin(a), math.cos(e) * math.cos(a), math.sin(e), 1.0])
    g = np.array(rows)
    q = np.linalg.inv(g.T @ g)
    return math.sqrt(q[0, 0] + q[1, 1]), math.sqrt(q[2, 2])

open_sky = [(0, 60), (70, 35), (140, 25), (200, 50), (260, 30), (320, 20), (100, 75), (230, 15)]
urban = [(40, 70), (100, 55), (160, 60), (210, 65), (80, 80)]
UERE = 3.0                                    # m (1 sigma), assumed for a typical receiver
for name, sats in (("open sky", open_sky), ("urban canyon", urban)):
    h, v = dop(sats)
    print(f"{name:<12} {len(sats)} sats  HDOP {h:.2f}  VDOP {v:.2f}  horizontal ~ {h * UERE:.1f} m (1 sigma)")

open sky     8 sats  HDOP 0.98  VDOP 1.63  horizontal ~ 2.9 m (1 sigma)
urban canyon 5 sats  HDOP 4.36  VDOP 14.44  horizontal ~ 13.1 m (1 sigma)

Between tall buildings, the visible satellites are all at high elevation and on one side, so the horizontal error grows several times and the vertical error is worse still. For centimetre-level work, such as mapping without ground control points, use RTK or PPK, which use a base station to remove common errors.