Apparent wind

Apparent wind is the wind experienced by a moving object.

V = boat speed, H = head wind, W = true wind, A = apparent wind, α = pointing angle, β = angle of apparent wind

Definition of apparent wind

The apparent wind is the wind experienced by an observer in motion and is the relative velocity of the wind in relation to the observer.^{[citation needed]}

The velocity of the apparent wind is the vector sum of the velocity of the headwind (which is the velocity a moving object would experience in still air) plus the velocity of the true wind. The headwind is the additive inverse of the object's velocity; therefore, the velocity of the apparent wind can also be defined as a vector sum of the velocity of the true wind minus the velocity of the object.^{[citation needed]}

Apparent wind in sailing

In sailing, apparent wind is the speed and direction of wind indicated by a wind instrument (anemometer) on a moving craft (on water, land or ice) in undisturbed air. It is composed of the combined speeds and directions of the craft and wind observed by a stationary wind instrument—the true wind. A true wind coming from the bow increases the apparent wind induced by the speed of the craft, coming from the stern it decreases apparent wind, and coming from the side the apparent wind angle and speed change according to the combined speed and direction of each the craft and the true wind. Apparent wind is important to sailors in order to set sail angle with respect to the wind and to anticipate how much power the wind will generate on a point of sail. Apparent wind differs in speed and direction from the true wind that is experienced by a stationary observer and composed of the true wind speed (TWS) and true wind direction (TWD) or the TWS and true wind angle (TWA) relative to the boat if it were stationary.^[1] In nautical terminology, apparent wind is measured in knots and degrees.

Note that a number of additional factors come into play when converting the measurements from the masthead anemometer into the true wind if a high degree of accuracy is required, including the following:^[2][3][4]

• Leeway (or drift on power vessels) - Factors like water currents or slipping sideways due to wind (leeway) mean that the direction a craft is pointing often does not exactly match its actual direction of travel. This must be corrected for when converting apparent wind angle to true wind direction. The same effect is found when the craft is altering course.
• Mast twist - the rigging loads often put a significant amount of torsion on the mast, especially if the rig has runners, so it is twisted along its length
• Mast rotation - many racing multihulls have a mast that can be rotated, so the anemometer reading needs to be corrected by the angle of rotation of the mast
• Heel angle - this is a simple trigonometric correction
• Upwash from the sails - the airflow around the top of the mast is distorted by the presence of the sails. This effect varies with the sails set at the time, the wind speed and the point of sail, but is noticed by the true wind angle changing from port to starboard tack, and the true wind speed changing from when beating to running
• Boat motions - as the masthead is so distant from the centre of motion of the craft, inertial effect on both the wind vane and the anemometer cups can be significant when the craft is moving, especially when pitching and rolling
• Wind shear - there can be a significant change in both wind speed and direction between the water's surface and the top of the mast, especially in conditions of unstable, light airs. The wind instruments are just measuring conditions at the masthead, and these are not necessarily the same at all heights

In the presence of a current, the true wind is considered to be that measured on the craft drifting with the water over the bottom, and wind with respect to the sea bed as the ground or geographical wind.^{[citation needed]}

Instruments

The apparent wind on board (a boat) is often quoted as a speed measured by a masthead transducer containing an anemometer and wind vane that measures wind speed in knots and wind direction in degrees relative to the heading of the boat. Modern instrumentation can calculate the true wind velocity when the apparent wind and boat speed and direction are input.^{[citation needed]}

Implications on sailing speeds

In sailboat racing, and especially in speed sailing, apparent wind is a vital factor, when determining the points of sail a sailboat can effectively travel in. A vessel traveling at increasing speed relative to the prevailing wind will encounter the wind driving the sail at a decreasing angle and increasing velocity. Eventually, the increased drag and diminished degree of efficiency of a sail at extremely low angles will cause a loss of accelerating force. This constitutes the main limitation to the speed of wind-driven vessels and vehicles.^{[citation needed]}

Windsurfers and certain types of boats are able to sail faster than the true wind. These include fast multihulls and some planing monohulls. Ice-sailors and land-sailors also usually fall into this category, because of their relatively low amount of drag or friction.^{[citation needed]}

The AC72 foiling catamarans used in the America's Cup are an example of this phenomenon, as the boats sail through the water at up to double the environmental wind speed. The effect of this is to radically change the apparent wind direction when sailing "downwind". In these boats the forward speed is so great that the apparent wind is always forward—at an angle that varies between 2 and 4 degrees to the wing sail. This means that AC72's are effectively tacking downwind, although at a greater angle than the normal 45-degree upwind angle, usually between 50 and 70 degrees.^[5]

Other areas of relevance

In fixed-wing aircraft, apparent wind is what is experienced on board, and it determines the necessary speeds for take-off and landing. Aircraft carriers generally steam directly upwind at maximum speed, in order to increase apparent wind and reduce the necessary take-off velocity. Land-based airport traffic, as well as most mid-sized and large birds generally take off and land facing upwind for the same reason.^{[citation needed]}

Calculating apparent velocity and angle

$${\displaystyle A={\sqrt {W^{2}+V^{2}+2WV\cos {\alpha }}}}$$

Where:

• ${\displaystyle V}$ = velocity (boat speed over ground, always ≥ 0)
• ${\displaystyle W}$ = true wind velocity (always ≥ 0)
• ${\displaystyle \alpha }$ = true pointing angle in degrees (0 = upwind, 180 = downwind)
• ${\displaystyle A}$ = apparent wind velocity (always ≥ 0)

The above formula is derived from the Law of cosines and using ${\displaystyle \cos(\alpha ')=\cos(180^{\circ }-\alpha )=-\cos(\alpha )}$.

The angle of apparent wind (${\displaystyle \beta }$) can be calculated from the measured velocity of the boat and wind using the inverse cosine in degrees (${\displaystyle \arccos }$)

$${\displaystyle \beta =\arccos \left({\frac {W\cos \alpha +V}{A}}\right)=\arccos \left({\frac {W\cos \alpha +V}{\sqrt {W^{2}+V^{2}+2WV\cos {\alpha }}}}\right)}$$

If the velocity of the boat and the velocity and the angle of the apparent wind are known, for instance from a measurement, the true wind velocity and direction can be calculated with:

$${\displaystyle W={\sqrt {A^{2}+V^{2}-2AV\cos {\beta }}}}$$

and

$${\displaystyle \alpha =\arccos \left({\frac {A\cos \beta -V}{W}}\right)=\arccos \left({\frac {A\cos \beta -V}{\sqrt {A^{2}+V^{2}-2AV\cos {\beta }}}}\right)}$$

Note: Due to quadrant ambiguity, this equation for ${\displaystyle \alpha }$ is only valid when the apparent winds are coming from the starboard direction (0° < β < 180°). For port apparent winds (180° < β < 360° or 0° > β > -180°), the true pointing angle (α) has the opposite sign:

$${\displaystyle \alpha =-\arccos \left({\frac {A\cos \beta -V}{W}}\right)=-\arccos \left({\frac {A\cos \beta -V}{\sqrt {A^{2}+V^{2}-2AV\cos {\beta }}}}\right)}$$

Calculation example using python, including simple plot of vectors:

import numpy as np
import matplotlib.pyplot as plt
import math

def calculate_apparent_wind(V, W, alpha_deg):
    """
    Calculate apparent wind velocity and direction
    
    Parameters:
    V: boat speed (m/s)
    W: true wind speed (m/s) 
    alpha_deg: true wind angle in degrees (0 = upwind, 180 = downwind)
    
    Returns:
    A: apparent wind speed (m/s)
    beta_deg: apparent wind angle in degrees
    """
    alpha_rad = math.radians(alpha_deg)
    
    # Calculate apparent wind speed
    A = math.sqrt(W**2 + V**2 + 2*W*V*math.cos(alpha_rad))
    
    # Handle zero apparent wind case (should only happen with equal opposite vectors)
    if A == 0:
        return 0, 0  # No apparent wind, direction undefined
    
    # Calculate apparent wind angle
    cos_beta = (W * math.cos(alpha_rad) + V) / A
    # Clamp to valid range for arccos
    cos_beta = max(-1, min(1, cos_beta))
    
    # Calculate sin_beta to determine the correct quadrant
    sin_beta = (W * math.sin(alpha_rad)) / A
    
    # Use atan2 to get the correct angle in full 360° range
    beta_rad = math.atan2(sin_beta, cos_beta)
    
    # Convert to degrees and ensure positive angle (0-360°)
    beta_deg = math.degrees(beta_rad)
    if beta_deg < 0:
        beta_deg += 360
    
    return A, beta_deg

def plot_wind_vectors(V, W, alpha_deg, A, beta_deg, title):
    """Plot wind vectors showing true wind, boat velocity, and apparent wind"""
    fig, ax = plt.subplots(1, 1, figsize=(8, 6))
    
    # Convert angles to radians for plotting
    # Note: angles are measured clockwise from V direction (upward)
    # V points upward (positive y), so 0° = upward, 90° = rightward, etc.
    alpha_rad = math.radians(alpha_deg)
    beta_rad = math.radians(beta_deg)
    
    # Vector components (V points upward, angles measured clockwise from V)
    # True wind vector (W) - α is direction wind is COMING FROM (clockwise from V direction)
    # So wind vector points opposite to where it's coming from
    Wx = -W * math.sin(alpha_rad)   # Negative because wind vector points where wind is going
    Wy = -W * math.cos(alpha_rad)   # Negative because wind vector points where wind is going
    
    # Boat velocity vector (V) - direction boat is GOING TO (upward)
    Vx = 0
    Vy = V
    
    # H vector = -V (negative boat velocity)
    Hx = -Vx
    Hy = -Vy
    
    # Apparent wind vector (A) = W + H = W + (-V)
    # β is direction apparent wind is COMING FROM, so vector points opposite
    # Using calculated values to show the vector sum
    Ax_calculated = Wx + Hx  
    Ay_calculated = Wy + Hy
    
    # For verification: apparent wind vector from β angle (coming from direction)
    Ax_from_beta = -A * math.sin(beta_rad)  # Negative because coming FROM β direction
    Ay_from_beta = -A * math.cos(beta_rad)  # Negative because coming FROM β direction
    
    # Plot vectors with specified start/end points
    # V starts at (0,0)
    ax.quiver(0, 0, Vx, Vy, angles='xy', scale_units='xy', scale=1, 
              color='red', width=0.005, label=f'Boat Velocity V={V:.1f} m/s (to course)')
    
    # H ends at (0,0), so starts at (-Hx, -Hy)
    ax.quiver(-Hx, -Hy, Hx, Hy, angles='xy', scale_units='xy', scale=1, 
              color='orange', width=0.005, label=f'H = -V (negative boat velocity)')
    
    # A ends at (0,0), so starts at (-Ax_calculated, -Ay_calculated)
    ax.quiver(-Ax_calculated, -Ay_calculated, Ax_calculated, Ay_calculated, angles='xy', scale_units='xy', scale=1, 
              color='green', width=0.005, label=f'Apparent Wind A={A:.1f} m/s (from β={beta_deg:.1f}°)')
    
    # W starts at start of A and ends at end of V
    # Start of A: (-Ax_calculated, -Ay_calculated)
    # End of V: (Vx, Vy)
    # So W vector components: from start of A to end of V
    W_start_x = -Ax_calculated
    W_start_y = -Ay_calculated
    W_vector_x = Vx - W_start_x
    W_vector_y = Vy - W_start_y
    ax.quiver(W_start_x, W_start_y, W_vector_x, W_vector_y, angles='xy', scale_units='xy', scale=1, 
              color='blue', width=0.005, label=f'True Wind W={W:.1f} m/s (from α={alpha_deg}°)')
    
    # Set equal aspect ratio and grid with dynamic zoom
    # Calculate actual bounds of all vector points
    all_x_coords = [0, Vx, -Hx, 0, -Ax_calculated, 0, W_start_x, W_start_x + W_vector_x]
    all_y_coords = [0, Vy, -Hy, 0, -Ay_calculated, 0, W_start_y, W_start_y + W_vector_y]
    
    # Find the actual range needed
    x_min, x_max = min(all_x_coords), max(all_x_coords)
    y_min, y_max = min(all_y_coords), max(all_y_coords)
    
    # Add 15% padding around the actual range
    x_range = max(x_max - x_min, 1)  # Ensure minimum range of 1
    y_range = max(y_max - y_min, 1)  # Ensure minimum range of 1
    x_padding = x_range * 0.15
    y_padding = y_range * 0.15
    
    ax.set_xlim(x_min - x_padding, x_max + x_padding)
    ax.set_ylim(y_min - y_padding, y_max + y_padding)
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3)
    ax.legend()
    ax.set_xlabel('X (m/s)')
    ax.set_ylabel('Y (m/s) - V direction')
    ax.set_title(title)
    
    # Add angle annotations at vector midpoints
    ax.annotate(f'α={alpha_deg}°', xy=(W_start_x + W_vector_x/2, W_start_y + W_vector_y/2), xytext=(10, 10), 
                textcoords='offset points', fontsize=10, color='blue')
    ax.annotate(f'β={beta_deg:.1f}°', xy=(-Ax_calculated/2, -Ay_calculated/2), xytext=(10, -20), 
                textcoords='offset points', fontsize=10, color='green')
    
    return fig

def run_test_cases():
    """Run test cases that can be verified by hand"""
    
    test_cases = [
        # (V, W, alpha, description)
        (0, 10, 90, "Stationary boat, wind from side"),
        (10, 0, 0, "No wind, boat moving"),
        (5, 5, 0, "Headwind: boat and wind same speed"),
        (5, 5, 180, "Tailwind: boat and wind same speed"), 
        (10, 10, 90, "Beam wind: boat and wind same speed"),
        (5, 10, 45, "Wind from 45° angle"),
        (8, 12, 120, "Wind from 120° angle"),
        (10, 10, 120, "Wind from 120° angle, same speeds"),
        (10, 10, 270, "Wind from 270° angle, same speeds"),
        (10, 10, 300, "Wind from 300° angle, same speeds"),
    ]
    
    print("Apparent Wind Calculations")
    print("=" * 70)
    print(f"{'Case':<4} {'V (m/s)':<8} {'W (m/s)':<8} {'α (deg)':<8} {'A (m/s)':<10} {'β (deg)':<10} {'Description'}")
    print("-" * 70)
    
    figures = []
    
    for i, (V, W, alpha, description) in enumerate(test_cases, 1):
        A, beta = calculate_apparent_wind(V, W, alpha)
        print(f"{i:<4} {V:<8} {W:<8} {alpha:<8} {A:<10.2f} {beta:<10.1f} {description}")
        
        # Create plot for this case
        title = f"Case {i}: {description}\nV={V} m/s, W={W} m/s, α={alpha}° → A={A:.2f} m/s, β={beta:.1f}°"
        fig = plot_wind_vectors(V, W, alpha, A, beta, title)
        figures.append(fig)
    
    # Hand verification examples
    print("\n" + "=" * 60)
    print("Hand Verification:")
    print("=" * 60)
    
    # Case 1: Stationary boat (V=0)
    print("1. Stationary boat (V=0): A should equal W, β should equal α")
    V, W, alpha = 0, 10, 90
    A, beta = calculate_apparent_wind(V, W, alpha)
    print(f"   Input: V={V}, W={W}, α={alpha}° → Output: A={A:.2f}, β={beta:.1f}°")
    print(f"   Expected: A={W}, β={alpha}° OK" if abs(A-W) < 0.01 and abs(beta-alpha) < 0.1 else "   NOT OK")
    
    # Case 2: No wind (W=0)  
    print("\n2. No wind (W=0): A should equal V, β should be 0°")
    V, W, alpha = 10, 0, 0
    A, beta = calculate_apparent_wind(V, W, alpha)
    print(f"   Input: V={V}, W={W}, α={alpha}° → Output: A={A:.2f}, β={beta:.1f}°")
    print(f"   Expected: A={V}, β=0° OK" if abs(A-V) < 0.01 and abs(beta-0) < 0.1 else "   NOT OK")
    
    # Case 3: Headwind, equal speeds
    print("\n3. Headwind equal speeds: A should be V+W")
    V, W, alpha = 5, 5, 0
    A, beta = calculate_apparent_wind(V, W, alpha)
    print(f"   Input: V={V}, W={W}, α={alpha}° → Output: A={A:.2f}, β={beta:.1f}°")
    print(f"   Expected: A={V+W}=10, β=0° OK" if abs(A-10) < 0.01 and abs(beta-0) < 0.1 else "   NOT OK")
    
    # Case 4: Tailwind, equal speeds  
    print("\n4. Tailwind equal speeds: A should be |W-V|")
    V, W, alpha = 5, 5, 180
    A, beta = calculate_apparent_wind(V, W, alpha)
    print(f"   Input: V={V}, W={W}, α={alpha}° → Output: A={A:.2f}, β={beta:.1f}°")
    print(f"   Expected: A={abs(W-V)}=0, β undefined OK" if abs(A-0) < 0.01 else "   NOT OK")
    
    return figures

if __name__ == "__main__":
    # Run test cases
    figures = run_test_cases()
    
    # Show plots
    plt.show()
    
    print(f"\nGenerated {len(figures)} plots showing vector relationships.")
    print("\nFormulas used:")
    print("A = √(W² + V² + 2WV·cos(α))")
    print("β = arccos((W·cos(α) + V) / A)")
    print("\nWhere:")
    print("V = boat speed (m/s)")
    print("W = true wind speed (m/s)") 
    print("α = true wind angle (0° = headwind, 180° = tailwind)")
    print("A = apparent wind speed (m/s)")
    print("β = apparent wind angle (degrees)")