Module 1: Insect Flight Mechanics

Insect flight evolved once, approximately 350 million years ago, predating vertebrate flight by over 100 million years. The diversity of flight mechanisms — from the four independent wings of dragonflies to the single functional pair of flies, from the clap-and-fling of tiny wasps to the elytra-enhanced flight of beetles — represents the most varied aerial locomotion system in biology. This module derives the physics of each mechanism.

1. Direct vs Indirect Flight Muscles

There are two fundamentally different mechanisms by which insects power their wings. The distinction lies in whether the flight muscles attach directly to the wing base or instead deform the thoracic box.

Direct Flight Muscles

Found in: Odonata (dragonflies, damselflies), Blattodea (cockroaches), Orthoptera (locusts).

Muscles attach directly to the wing base via pleural sclerites. Each wing operates independently with separate elevator and depressor muscles. This gives exquisite kinematic control but limits maximum wing beat frequency.

Synchronous: One neural impulse per muscle contraction. Typical frequency: 20-40 Hz. Maximum: ~100 Hz in some locusts.

Indirect Flight Muscles (IFM)

Found in: Diptera (flies), Hymenoptera (bees, wasps), Coleoptera (beetles), Lepidoptera (most).

Muscles do not attach to wings. Instead, dorsoventral (DVM) and dorsolongitudinal (DLM) muscles alternately deform the thoracic box. The wing pivots on the pleural wing process like a seesaw, converting thorax deformation into wing strokes.

Asynchronous (fibrillar): Multiple contractions per nerve impulse. Stretch-activated. Frequencies: 100-1000+ Hz.

1.1 Thoracic Resonance

The indirect flight muscle system exploits mechanical resonance of the thorax. The thorax + wing system behaves like a damped harmonic oscillator driven by alternating DVM/DLM contractions:

Equation of motion for thoracic oscillation:

\(m\ddot{x} + b\dot{x} + kx = F_0\cos(\omega t)\)

where \(m\) is the effective mass of wing + thorax, \(b\) is damping (aerodynamic + internal), \(k\) is the elastic stiffness of the thoracic cuticle and resilin hinges, and \(F_0\) is the muscle force amplitude.

Natural Frequency of Thoracic Resonance:

\(f_0 = \frac{1}{2\pi}\sqrt{\frac{k}{m}}\)

The insect “tunes” its wingbeat to this resonant frequency. At resonance, minimum muscular power is needed because elastic energy is stored and released each half-cycle. The quality factor \(Q = \sqrt{km}/b\) determines how sharply tuned the resonance is (typical \(Q \approx 3{-}8\) for insect thoraces).

Power input at resonance vs off-resonance:

\(P_{\text{resonance}} = \frac{F_0^2}{2b}, \quad P_{\text{off}} = \frac{F_0^2}{2b}\cdot\frac{1}{1 + Q^2\left(\frac{\omega}{\omega_0} - \frac{\omega_0}{\omega}\right)^2}\)

At resonance, the insect only needs to overcome damping losses. Off-resonance, it must additionally do work against (or waste energy stored in) the spring. A quality factor of 5 means operating 20% off-resonance doubles the power requirement.

1.2 Resilin: The Elastic Protein

The wing hinge contains resilin, one of the most efficient elastic materials in nature. Resilin has a coefficient of restitution of 97% (only 3% energy lost per cycle), compared to ~80% for synthetic rubbers. This is critical for the resonant flight system: without resilin, the quality factor would be too low and the metabolic cost of flight would be prohibitive.

Resilin properties:

Young's Modulus

~0.6 MPa

Extensibility

300%

Resilience

97%

Fatigue Life

> 10^9 cycles

2. Wing Coupling Mechanisms

Most four-winged insects couple their fore- and hindwings to function as a single aerodynamic surface. Different orders have evolved distinct coupling mechanisms:

Hamuli (Hymenoptera)

Tiny hooks on the leading edge of the hindwing engage a fold on the trailing edge of the forewing. Bees typically have 12-29 hamuli per wing. This creates a mechanically rigid coupling — the two wings beat as one.

Frenulum (Lepidoptera)

A spine or group of bristles on the hindwing that hooks into a retinaculum on the forewing. Provides flexible coupling allowing some relative motion. Moths use frenulum; butterflies use humeral lobe overlap instead.

Elytra (Coleoptera)

Forewings modified into hardened covers. At rest, protect the hindwings. In flight, held at a fixed angle while hindwings beat. In some species, elytra contribute lift and create beneficial vortex interactions.

2.1 Clap-and-Fling Mechanism (Weis-Fogh 1973)

Torkel Weis-Fogh discovered that the tiny chalcid wasp Encarsia formosa generates lift using a novel mechanism absent from conventional aerodynamics. At the top of the upstroke, the wings “clap” together dorsally. They then “fling” apart, each wing rotating about its trailing edge. This creates bound circulation without the usual Wagner delay:

Conventional lift coefficient (steady-state):

\(C_L = 2\pi\alpha \quad \text{(thin airfoil theory, } C_{L,\max} \approx 1.5\text{)}\)

But many insects require \(C_L > 3\) for hovering, which is impossible in steady flow. The clap-and-fling provides the extra circulation:

Clap-and-Fling Lift Enhancement:

\(C_L^{\text{fling}} \approx \frac{4\pi \dot{\alpha} c}{U} + C_L^{\text{steady}}\)

where \(\dot{\alpha}\) is the angular velocity of wing rotation during the fling,\(c\) is the chord length, and \(U\) is the wing tip velocity. The fling instantaneously establishes circulation without the Wagner effect (gradual build-up), effectively doubling initial lift.

Lift force in hover:

\(L = \frac{1}{2}\rho \bar{U}^2 S C_L = Mg\)

where \(\bar{U} = 2\pi f R \hat{\phi}\) is the mean wing tip speed,\(S\) is wing area, \(f\) is wingbeat frequency,\(R\) is wing length, and \(\hat{\phi}\) is the stroke amplitude (in radians). For a honeybee: \(f \approx 230\) Hz,\(R \approx 10\) mm, \(\hat{\phi} \approx 1.6\) rad.

3. Dragonfly Four-Wing Aerodynamics

Dragonflies (Order Odonata) are unique among insects: they retain direct flight muscles and four independently controllable wings. This gives them extraordinary maneuverability — they can hover, fly backwards, and achieve prey capture success rates exceeding 95%.

3.1 Phase Offset and Flight Mode

The key variable is the phase offset \(\phi\) between forewing and hindwing beat cycles:

\(\phi = 0°\) (In-phase)

Maximum instantaneous force. Used for acceleration and fast forward flight. Both wing pairs reinforce each other but produce large force oscillations.

\(\phi = 180°\) (Anti-phase)

Minimizes force fluctuation. Used for hovering. Forewings and hindwings alternate, producing nearly constant total force. Reduces body oscillation.

\(\phi = 90°\) (Quadrature)

Intermediate: moderate force with reduced oscillation. Used during cruising flight. Optimizes power efficiency at moderate speeds.

Total vertical force with phase offset:

\(F_{\text{total}}(t) = F_{\text{fore}}\cos(\omega t) + F_{\text{hind}}\cos(\omega t + \phi)\)

\(= \sqrt{F_f^2 + F_h^2 + 2F_f F_h \cos\phi}\;\cos\left(\omega t + \arctan\frac{F_h\sin\phi}{F_f + F_h\cos\phi}\right)\)

3.2 Stroke Plane Angle Optimization

The stroke plane angle \(\beta\) (angle between the wing stroke plane and the horizontal) determines the partition between lift and thrust:

Force decomposition:

\(L = F_{\text{aero}}\cos\beta, \quad T = F_{\text{aero}}\sin\beta\)

In hover: \(\beta \approx 0°\) (horizontal stroke plane), all force is vertical lift. In fast forward flight: \(\beta \approx 60{-}70°\), tilted forward to generate thrust. Dragonflies can independently tilt fore- and hindwing stroke planes.

Optimal Stroke Plane for Forward Flight:

\(\beta_{\text{opt}} = \arctan\left(\frac{D}{W}\right) = \arctan\left(\frac{C_D S \rho v^2 / 2}{Mg}\right)\)

where \(D\) is the body drag and \(W = Mg\) is the weight. As speed increases, the required thrust increases with \(v^2\), so the optimal stroke plane tilts further forward.

4. Beetle Elytra: Protection and Aerodynamics

Coleoptera (beetles) comprise ~25% of all known insect species. Their forewings are modified into hardened elytra that protect the membranous hindwings at rest. The elytra were long thought to be purely protective, but recent research reveals significant aerodynamic functions.

Elytra Aerodynamic Functions

Vortex generation: The fixed, raised elytra create a leading-edge vortex (LEV) that interacts with the beating hindwings, increasing their effective angle of attack and lift by 10-15%.
Stability: The elytra act as fixed lifting surfaces providing passive pitch stability, similar to a canard configuration in aircraft.
Flow management: In rhinoceros beetles, elytra channel airflow over the dorsal body surface, reducing pressure drag by up to 20%.

Elytra lift contribution (quasi-steady):

\(L_{\text{elytra}} = \frac{1}{2}\rho v^2 S_e C_{L,e}(\alpha_e)\)

where \(S_e\) is elytra planform area, \(\alpha_e \approx 15{-}25°\)is the elytra opening angle. \(C_{L,e} \approx 0.3{-}0.8\) depending on species and angle. For a cockchafer, elytra contribute ~30% of total lift.

Hindwing lift enhancement from elytra-induced vortex:

\(\Delta C_L^{\text{hind}} \approx \frac{\Gamma_{\text{elytra}}}{U_\infty \cdot c_h}\)

where \(\Gamma_{\text{elytra}}\) is the circulation shed by the elytra trailing edge and \(c_h\) is the hindwing chord. This interaction is most beneficial in the hindwing's downstroke when it passes through the elytra wake.

Comparison of Four Insect Flight Styles

Four major flight configurations found across insect orders, showing wing morphology, muscle type, and kinematic strategy.

Interactive Simulations

Simulation 1: Wing Kinematics and Power Curves

Compares wing kinematics, aerodynamic forces, and mechanical power requirements across the four flight styles. Includes thoracic resonance effects for indirect flight muscles.

Wing Kinematics Comparison Across Flight Styles

Python

script.py152 lines

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('Agg')

# Time array (one wingbeat cycle normalized)
t = np.linspace(0, 1, 500)

fig, axes = plt.subplots(2, 2, figsize=(14, 11))

# ---- Panel 1: Wing position vs time for 4 insects ----
ax = axes[0, 0]

# Dragonfly: fore and hind wings with phase offset
phi_offset = np.pi  # 180 deg = hovering
fore_pos = 60 * np.sin(2 * np.pi * t)
hind_pos = 60 * np.sin(2 * np.pi * t + phi_offset)
ax.plot(t, fore_pos, color='#4ade80', linewidth=2, label='Dragonfly FW')
ax.plot(t, hind_pos, color='#22d3ee', linewidth=2, linestyle='--', label='Dragonfly HW (180 phase)')

# Fly: single pair, higher frequency represented by 2 cycles in same time
fly_pos = 70 * np.sin(2 * np.pi * t * 2)
ax.plot(t, fly_pos, color='#f97316', linewidth=2, label='Fly (2x freq shown)')

# Butterfly: low freq, asymmetric (slow upstroke)
butter_down = np.where(np.sin(2*np.pi*t) > 0,
                        80 * np.sin(2*np.pi*t)**0.7,
                        80 * np.sin(2*np.pi*t))
ax.plot(t, butter_down, color='#e879f9', linewidth=2, label='Butterfly (asymmetric)')

ax.set_xlabel('Normalized Time (1 cycle)', color='white')
ax.set_ylabel('Wing Angular Position (deg)', color='white')
ax.set_title('Wing Kinematics', color='#a3e635', fontweight='bold', fontsize=13)
ax.legend(fontsize=9, facecolor='#111', edgecolor='#333', labelcolor='white')
ax.set_facecolor('#111')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.15)
for spine in ax.spines.values():
    spine.set_color('#333')

# ---- Panel 2: Thoracic resonance (power vs frequency ratio) ----
ax = axes[0, 1]
omega_ratio = np.linspace(0.3, 3.0, 500)

Q_values = [3, 5, 8]
colors = ['#f97316', '#a3e635', '#22d3ee']
for Q, color in zip(Q_values, colors):
    # Amplitude response of driven damped oscillator
    A = 1.0 / np.sqrt((1 - omega_ratio**2)**2 + (omega_ratio/Q)**2)
    # Power ~ amplitude^2 * omega^2 / Q (dissipated power)
    P_norm = A**2 * omega_ratio**2 / Q
    P_norm = P_norm / P_norm.max()
    ax.plot(omega_ratio, P_norm, color=color, linewidth=2, label=f'Q = {Q}')

ax.axvline(1.0, color='white', linestyle='--', alpha=0.4, linewidth=1)
ax.text(1.02, 0.95, 'Resonance', color='white', fontsize=10)

ax.set_xlabel('Frequency Ratio (omega/omega_0)', color='white')
ax.set_ylabel('Normalized Power Efficiency', color='white')
ax.set_title('Thoracic Resonance (IFM)', color='#a3e635', fontweight='bold', fontsize=13)
ax.legend(fontsize=10, facecolor='#111', edgecolor='#333', labelcolor='white')
ax.set_facecolor('#111')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.15)
for spine in ax.spines.values():
    spine.set_color('#333')

# ---- Panel 3: Dragonfly phase offset effect ----
ax = axes[1, 0]
phases = np.linspace(0, 360, 200)
F_f, F_h = 1.0, 0.85  # fore and hind wing force amplitudes

# Peak total force
F_peak = np.sqrt(F_f**2 + F_h**2 + 2*F_f*F_h*np.cos(np.radians(phases)))
# Force fluctuation (peak - trough) / mean
F_mean = (F_f + F_h) / np.pi  # time-averaged rectified sine
F_fluct = F_peak / (F_f + F_h)

ax.plot(phases, F_peak, color='#a3e635', linewidth=2.5, label='Peak total force')
ax.plot(phases, F_fluct, color='#22d3ee', linewidth=2, linestyle='--', label='Force ratio (peak/sum)')

# Mark key phases
for ph, label, c in [(0, 'In-phase\n(accel)', '#f97316'),
                      (90, 'Quad\n(cruise)', '#fbbf24'),
                      (180, 'Anti\n(hover)', '#4ade80')]:
    idx = int(ph / 360 * len(phases))
    ax.axvline(ph, color=c, linestyle=':', alpha=0.5)
    ax.annotate(label, (ph, F_peak[min(idx, len(F_peak)-1)]),
                textcoords="offset points", xytext=(8, 10), fontsize=9, color=c)

ax.set_xlabel('Phase Offset (degrees)', color='white')
ax.set_ylabel('Force (normalized)', color='white')
ax.set_title('Dragonfly: Phase Offset Effect', color='#a3e635', fontweight='bold', fontsize=13)
ax.legend(fontsize=10, facecolor='#111', edgecolor='#333', labelcolor='white')
ax.set_facecolor('#111')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.15)
for spine in ax.spines.values():
    spine.set_color('#333')

# ---- Panel 4: Power curves for different flight styles ----
ax = axes[1, 1]
v = np.linspace(0, 12, 200)  # flight speed (m/s)

# Power = induced + profile + parasite
# P_induced ~ W^2/(2*rho*A_disk*v) for forward flight
# P_profile ~ rho * S * Cd * (f*R)^3
# P_parasite ~ 0.5 * rho * Cd_body * A_body * v^3

insects_flight = {
    'Dragonfly': {'W': 0.008, 'Ad': 0.003, 'S': 0.002, 'f': 30, 'R': 0.04, 'Ab': 3e-5, 'Cdb': 0.5},
    'Honeybee': {'W': 0.001, 'Ad': 0.001, 'S': 0.0004, 'f': 230, 'R': 0.01, 'Ab': 1e-5, 'Cdb': 0.4},
    'Beetle': {'W': 0.02, 'Ad': 0.004, 'S': 0.003, 'f': 80, 'R': 0.03, 'Ab': 8e-5, 'Cdb': 0.8},
    'Butterfly': {'W': 0.005, 'Ad': 0.006, 'S': 0.004, 'f': 12, 'R': 0.04, 'Ab': 2e-5, 'Cdb': 0.6},
}
flight_colors = ['#4ade80', '#fbbf24', '#f97316', '#e879f9']
rho = 1.2

for (name, p), color in zip(insects_flight.items(), flight_colors):
    v_safe = np.maximum(v, 0.5)  # avoid division by zero
    P_induced = p['W']**2 / (2 * rho * p['Ad'] * v_safe)
    P_profile = rho * p['S'] * 0.02 * (2*np.pi*p['f']*p['R'])**3 * np.ones_like(v) * 0.001
    P_parasite = 0.5 * rho * p['Cdb'] * p['Ab'] * v**3
    P_total = P_induced + P_profile + P_parasite

ax.plot(v, P_total * 1000, color=color, linewidth=2, label=name)

ax.set_xlabel('Forward Speed (m/s)', color='white')
ax.set_ylabel('Mechanical Power (mW)', color='white')
ax.set_title('Power Curves (U-shaped)', color='#a3e635', fontweight='bold', fontsize=13)
ax.legend(fontsize=10, facecolor='#111', edgecolor='#333', labelcolor='white')
ax.set_facecolor('#111')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.15)
ax.set_ylim(0, 100)
for spine in ax.spines.values():
    spine.set_color('#333')

fig.patch.set_facecolor('#0a0a0a')
plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a0a')
plt.close()

print("Insect Flight Mechanics - Comparative Analysis")
print("=" * 55)
print(f"\n{'Insect':<14} {'Muscle':<12} {'Wings':<16} {'Freq (Hz)':<12} {'Style'}")
print("-" * 65)
print(f"{'Dragonfly':<14} {'Direct':<12} {'4 independent':<16} {'25-40':<12} {'Variable phase'}")
print(f"{'Fly':<14} {'IFM async':<12} {'2 + halteres':<16} {'100-300':<12} {'Resonant'}")
print(f"{'Beetle':<14} {'IFM async':<12} {'Elytra + 2':<16} {'50-200':<12} {'Elytra-assist'}")
print(f"{'Butterfly':<14} {'IFM sync':<12} {'4 coupled':<16} {'8-20':<12} {'Clap-and-fling'}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Simulation 2: Clap-and-Fling Lift Enhancement

Models the lift coefficient enhancement from the Weis-Fogh clap-and-fling mechanism, showing how small insects can achieve lift coefficients far beyond steady-state limits.

Clap-and-Fling Lift Enhancement Model

Python

script.py126 lines

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('Agg')

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))

# ---- Panel 1: Lift coefficient during clap-and-fling sequence ----
# Model the wing rotation during fling phase
t = np.linspace(0, 1, 1000)  # normalized wingbeat cycle

# Conventional wing: gradual circulation build-up (Wagner effect)
# Wagner function approx: phi(s) = 1 - 0.165*exp(-0.0455*s) - 0.335*exp(-0.3*s)
# where s = semi-chords traveled
s = t * 20  # semi-chords traveled in one stroke
wagner = 1 - 0.165 * np.exp(-0.0455 * s) - 0.335 * np.exp(-0.3 * s)
CL_conventional = 1.5 * wagner * np.sin(2 * np.pi * t)

# Clap-and-fling: instantaneous circulation at start
# During fling (t ~ 0-0.1): rapid rotation generates large CL
fling_phase = np.where(t < 0.1, 1.0, 0.0)
rotation_CL = 3.0 * np.exp(-t/0.05) * fling_phase

# Total CL with clap-and-fling
CL_fling = 1.5 * np.sin(2 * np.pi * t) + rotation_CL
# Add translation phase
CL_fling = np.where(t < 0.1, rotation_CL + 1.5 * np.sin(2*np.pi*t),
                     1.5 * np.sin(2*np.pi*t) * 1.2)  # 20% LEV enhancement

ax1.plot(t, CL_conventional, color='#888', linewidth=2, label='Conventional (with Wagner delay)')
ax1.plot(t, CL_fling, color='#a3e635', linewidth=2.5, label='Clap-and-fling')
ax1.axhline(1.5, color='#f97316', linestyle=':', alpha=0.6, linewidth=1)
ax1.text(0.6, 1.55, 'Steady-state CL_max', color='#f97316', fontsize=10)
ax1.fill_between(t, CL_conventional, CL_fling,
                 where=CL_fling > CL_conventional,
                 alpha=0.15, color='#a3e635')

ax1.set_xlabel('Normalized Time (1 wingbeat)', color='white', fontsize=12)
ax1.set_ylabel('Lift Coefficient CL', color='white', fontsize=12)
ax1.set_title('Lift Enhancement: Clap-and-Fling', color='#a3e635', fontweight='bold', fontsize=13)
ax1.legend(fontsize=10, facecolor='#111', edgecolor='#333', labelcolor='white')
ax1.set_facecolor('#111')
ax1.tick_params(colors='white')
ax1.grid(True, alpha=0.15)
for spine in ax1.spines.values():
    spine.set_color('#333')

# ---- Panel 2: Required CL vs body mass (why small insects need clap-fling) ----
M = np.logspace(-7, -2, 200)  # mass in kg (0.1 mg to 10 g)
g = 9.81
rho = 1.2

# Wing area scales as M^0.67
A0 = 1e-4  # wing area at 1g (m^2)
M_ref = 1e-3  # 1g
A_wing = A0 * (M / M_ref)**0.67

# Wing tip velocity scales with frequency and wing length
# f ~ M^(-0.25), R ~ M^(1/3)
f0 = 50  # Hz at 1g
R0 = 0.01  # wing length at 1g (m)
f = f0 * (M / M_ref)**(-0.25)
R = R0 * (M / M_ref)**(1/3)
phi_amp = 2.0  # stroke amplitude (rad)
U_tip = 2 * np.pi * f * R * phi_amp

# Required CL for hover: L = W -> CL = 2Mg/(rho * U_tip^2 * A_wing)
CL_required = 2 * M * g / (rho * U_tip**2 * A_wing)

ax2.loglog(M * 1e6, CL_required, color='#a3e635', linewidth=2.5, label='Required CL for hover')
ax2.axhline(1.5, color='#f97316', linestyle='--', linewidth=1.5, label='Steady CL_max ~ 1.5')
ax2.axhline(3.5, color='#22d3ee', linestyle='--', linewidth=1.5, label='Clap-fling CL_max ~ 3.5')

# Shade regions
ax2.fill_between(M * 1e6, 1.5, 3.5, alpha=0.1, color='#22d3ee')
ax2.fill_between(M * 1e6, 3.5, 10, alpha=0.1, color='#ef4444')

ax2.text(0.5, 2.0, 'Needs unsteady\naerodynamics', fontsize=10, color='#22d3ee')
ax2.text(0.3, 5.0, 'Cannot hover\n(too heavy for size)', fontsize=10, color='#ef4444')
ax2.text(100, 0.6, 'Steady-state\naerodynamics\nsufficient', fontsize=10, color='#4ade80')

# Mark specific insects
insects_cl = {
    'Fruit fly': (1, 2.8), 'Chalcid wasp': (0.1, 4.2),
    'Honeybee': (100, 1.2), 'Hawkmoth': (2000, 0.8),
    'Dragonfly': (800, 0.6),
}
for name, (mass_mg, cl) in insects_cl.items():
    ax2.plot(mass_mg, cl, 'o', color='#fbbf24', markersize=7)
    ax2.annotate(name, (mass_mg, cl), textcoords="offset points",
                xytext=(8, 5), fontsize=9, color='white')

ax2.set_xlabel('Body Mass (mg)', color='white', fontsize=12)
ax2.set_ylabel('Required CL', color='white', fontsize=12)
ax2.set_title('Why Small Insects Need Clap-and-Fling', color='#a3e635', fontweight='bold', fontsize=13)
ax2.legend(fontsize=9, facecolor='#111', edgecolor='#333', labelcolor='white', loc='upper right')
ax2.set_facecolor('#111')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.15)
ax2.set_ylim(0.1, 10)
ax2.set_xlim(0.05, 1e4)
for spine in ax2.spines.values():
    spine.set_color('#333')

fig.patch.set_facecolor('#0a0a0a')
plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a0a')
plt.close()

print("Clap-and-Fling Analysis")
print("=" * 50)
print("\nWeis-Fogh (1973) mechanism:")
print("  1. CLAP: Wings meet dorsally at top of upstroke")
print("  2. FLING: Wings rotate apart about trailing edges")
print("  3. Bound vortex pair created instantly (no Wagner delay)")
print("  4. Each wing starts downstroke with full circulation")
print()
print("Lift enhancement factor vs body size:")
for name, (mass_mg, cl) in sorted(insects_cl.items(), key=lambda x: x[1][0]):
    mechanism = "clap-fling essential" if cl > 1.5 else "steady-state OK"
    print(f"  {name:<16} ({mass_mg:>6.1f} mg): CL = {cl:.1f}  [{mechanism}]")
print()
print("Key insight: Below ~10 mg, insects MUST use unsteady")
print("aerodynamic mechanisms (clap-fling, LEV, wake capture)")
print("to generate sufficient lift for hovering flight.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

References

Weis-Fogh, T. (1973). Quick estimates of flight fitness in hovering animals, including novel mechanisms for lift production. Journal of Experimental Biology, 59(1), 169-230.
Dickinson, M.H., Lehmann, F.O. and Sane, S.P. (1999). Wing rotation and the aerodynamic basis of insect flight. Science, 284(5422), 1954-1960.
Ellington, C.P. (1984). The aerodynamics of hovering insect flight. I-VI. Philosophical Transactions of the Royal Society B, 305(1122), 1-181.
Alexander, D.E. (1984). Unusual phase relationships between the forewings and hindwings in flying dragonflies. Journal of Experimental Biology, 109(1), 379-383.
Josephson, R.K., Malamud, J.G. and Stokes, D.R. (2000). Asynchronous muscle: a primer. Journal of Experimental Biology, 203(18), 2713-2722.
Le, T.Q., Truong, T.V., Park, S.H., Quoc Truong, T., Ko, J.H., Park, H.C. and Byun, D. (2013). Improvement of the aerodynamic performance by wing flexibility and elytra-hind wing interaction of a beetle during forward flight. Journal of the Royal Society Interface, 10(85), 20130312.
Sane, S.P. (2003). The aerodynamics of insect flight. Journal of Experimental Biology, 206(23), 4191-4208.
Dudley, R. (2000). The Biomechanics of Insect Flight: Form, Function, Evolution. Princeton University Press.
Pringle, J.W.S. (1957). Insect Flight. Cambridge University Press.

<- Module 0: Physical Foundations Module 2: Metamorphosis ->