name	nasa-earthdata
description	Access atmospheric properties and aerospace fluid data from NASA Earthdata
category	databases
domain	aerospace
complexity	intermediate
dependencies	[]

NASA Earthdata Database Skill

Access atmospheric properties, standard atmosphere models, and aerospace environmental data from NASA's Earthdata platform for aerospace pump design, high-altitude systems, and atmospheric flight analysis.

Overview

NASA Earthdata provides free access to Earth science data from multiple NASA missions and instruments. For aerospace engineering applications, it offers:

Atmospheric Properties: Temperature, pressure, density profiles vs altitude
Standard Atmosphere Models: US Standard Atmosphere (1976), MSIS, NRLMSISE-00
Wind Data: Global wind profiles, jet streams, seasonal variations
Temperature Profiles: Troposphere through thermosphere
Pressure Profiles: Sea level to exosphere
Geopotential Height: Standard atmosphere reference
Composition Data: Atmospheric gas composition by altitude
Environmental Conditions: Humidity, precipitation, cloud cover

Key Applications:

High-altitude pump and compressor design
Aircraft and rocket environmental conditions
Aerospace fluid system analysis
Thermal control system design
Aerodynamic heating calculations
Launch window planning

Free Registration Required

NASA Earthdata is free but requires user registration.

Registration Process

Create Earthdata Account
- URL: https://urs.earthdata.nasa.gov/users/new
- Required information: Name, email, organization
- Free for all users (academic, commercial, personal)
- Instant approval
Approve Applications
- Some datasets require application approval
- Navigate to: https://urs.earthdata.nasa.gov/home
- Click "My Applications" → "Approve More Applications"
- Approve required data services (e.g., GES DISC, ASDC)
Save Credentials
- Username: Your email or chosen username
- Password: Your account password
- Store securely (needed for API access)

Authentication Setup

Method 1: Username/Password Authentication

import requests
from requests.auth import HTTPBasicAuth

# Your Earthdata credentials
username = "your_earthdata_username"
password = "your_earthdata_password"

# Example: Access data with authentication
url = "https://goldsmr4.gesdisc.eosdis.nasa.gov/data/MERRA2/..."
response = requests.get(url, auth=HTTPBasicAuth(username, password))

Method 2: .netrc File (Recommended)

Create a .netrc file for automatic authentication:

Linux/Mac (~/.netrc):

machine urs.earthdata.nasa.gov
    login your_username
    password your_password

Set permissions:

chmod 600 ~/.netrc

Windows (C:\Users\YourName\_netrc):

machine urs.earthdata.nasa.gov
    login your_username
    password your_password

Python with .netrc:

import requests

# Authentication automatically used from .netrc
url = "https://goldsmr4.gesdisc.eosdis.nasa.gov/data/..."
response = requests.get(url)

Method 3: Token-Based Authentication

Generate a token for programmatic access:

Log in to Earthdata: https://urs.earthdata.nasa.gov/
Navigate to "My Profile" → "Generate Token"
Copy the token

Using token in Python:

import requests

token = "your_generated_token"
headers = {"Authorization": f"Bearer {token}"}

url = "https://api.earthdata.nasa.gov/..."
response = requests.get(url, headers=headers)

Available Datasets for Aerospace Applications

1. Standard Atmosphere Models

MSIS (Mass Spectrometer Incoherent Scatter)

Description: Empirical atmospheric model
Altitude Range: 0 km to 1000 km
Parameters: Temperature, density, composition
Temporal: Time-dependent (solar activity, season)
Use Case: High-altitude aircraft, rockets, satellites

NRLMSISE-00 (Naval Research Laboratory MSIS Extended)

Description: Extended atmospheric model to thermosphere
Altitude Range: 0 km to 2000 km
Parameters: T, P, ρ, composition (N₂, O₂, O, He, H, Ar, N)
Inputs: Altitude, latitude, longitude, date, time, solar activity
Use Case: Spacecraft drag, upper atmosphere analysis

US Standard Atmosphere (1976)

Description: Static atmospheric model
Altitude Range: 0 km to 1000 km
Layers: Troposphere, stratosphere, mesosphere, thermosphere
Parameters: T, P, ρ, speed of sound
Use Case: Baseline design, standardized testing

2. MERRA-2 (Modern-Era Retrospective analysis)

Real atmospheric data from NASA reanalysis:

Spatial Resolution: 0.5° × 0.625° (lat × lon)
Temporal Resolution: Hourly, 3-hourly, daily, monthly
Altitude Levels: Surface to 0.01 hPa (~80 km)
Time Period: 1980 to present (updated ongoing)

Available Parameters:

Temperature (T) [K]
Pressure (P) [Pa]
Density (ρ) [kg/m³]
Wind components (U, V, W) [m/s]
Geopotential height [m]
Relative humidity [%]
Specific humidity [kg/kg]

Aerospace Applications:

Flight envelope analysis
Wind shear assessment
Thermal environment modeling
Launch trajectory planning

3. AIRS (Atmospheric Infrared Sounder)

High-resolution atmospheric profiles:

Spatial Resolution: 50 km
Vertical Resolution: 28 pressure levels
Parameters: T, P, H₂O, O₃, CO₂
Coverage: Global, twice daily
Accuracy: ±1 K (temperature), ±15% (humidity)

Use Cases:

Precise atmospheric property data
Regional atmospheric analysis
Flight planning

4. GEOS (Goddard Earth Observing System)

Forward-looking atmospheric data:

Type: Forecast model (7-day ahead)
Resolution: 0.25° × 0.3125°
Temporal: 3-hourly
Parameters: T, P, winds, humidity, composition

Use Cases:

Mission planning
Launch forecasting
Flight operations

API Access Methods

Method 1: OPeNDAP (Open-source Project for Network Data Access Protocol)

Direct data subsetting and download:

from pydap.client import open_url

# Open MERRA-2 dataset via OPeNDAP
url = "https://goldsmr4.gesdisc.eosdis.nasa.gov/opendap/MERRA2/M2I3NPASM.5.12.4/2023/01/MERRA2_400.inst3_3d_asm_Np.20230101.nc4"

dataset = open_url(url, username="your_username", password="your_password")

# Access variables
temperature = dataset['T']  # Temperature [K]
pressure = dataset['PL']    # Pressure levels [Pa]
density = dataset['RHO']    # Density [kg/m³]

# Subset data (e.g., specific altitude and location)
T_subset = temperature[0, :, 100, 200]  # time, level, lat, lon

Method 2: NASA CMR (Common Metadata Repository)

Search and discover datasets:

import requests

# Search for atmospheric data
cmr_url = "https://cmr.earthdata.nasa.gov/search/granules.json"
params = {
    'short_name': 'M2I3NPASM',  # MERRA-2 3D atmospheric data
    'temporal': '2023-01-01T00:00:00Z,2023-01-31T23:59:59Z',
    'bounding_box': '-180,-90,180,90'  # Global
}

response = requests.get(cmr_url, params=params)
granules = response.json()['feed']['entry']

# Download URLs
for granule in granules:
    print(granule['title'])
    print(granule['links'][0]['href'])  # Data URL

Method 3: Direct HTTP Download

Download files directly:

import requests
from requests.auth import HTTPBasicAuth

username = "your_username"
password = "your_password"

# MERRA-2 file URL
url = "https://goldsmr4.gesdisc.eosdis.nasa.gov/data/MERRA2/M2I3NPASM.5.12.4/2023/01/MERRA2_400.inst3_3d_asm_Np.20230101.nc4"

# Download with authentication
response = requests.get(url, auth=HTTPBasicAuth(username, password), stream=True)

with open("merra2_data.nc4", "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

print("Download complete")

Method 4: Python earthaccess Library

Simplified access to NASA Earthdata:

pip install earthaccess

import earthaccess

# Login (uses .netrc or prompts for credentials)
earthaccess.login()

# Search for MERRA-2 data
results = earthaccess.search_data(
    short_name='M2I3NPASM',
    cloud_hosted=True,
    temporal=('2023-01-01', '2023-01-31')
)

# Download data
files = earthaccess.download(results[0:5], "./data")

Standard Atmosphere Calculation Example

import numpy as np

def us_standard_atmosphere_1976(altitude_m):
    """
    Calculate atmospheric properties using US Standard Atmosphere (1976)

    Parameters:
    -----------
    altitude_m : float
        Geometric altitude [m] (0 to 86000 m)

    Returns:
    --------
    dict: {'T': temperature [K],
           'P': pressure [Pa],
           'rho': density [kg/m³],
           'a': speed of sound [m/s]}
    """
    # Constants
    g0 = 9.80665  # Standard gravity [m/s²]
    R = 287.05    # Gas constant for air [J/kg/K]
    gamma = 1.4   # Specific heat ratio

    # Layer definitions [altitude_base, T_base, lapse_rate]
    layers = [
        (0,     288.15, -0.0065),  # Troposphere
        (11000, 216.65,  0.0),     # Tropopause
        (20000, 216.65,  0.001),   # Stratosphere 1
        (32000, 228.65,  0.0028),  # Stratosphere 2
        (47000, 270.65,  0.0),     # Stratopause
        (51000, 270.65, -0.0028),  # Mesosphere 1
        (71000, 214.65, -0.002),   # Mesosphere 2
    ]

    # Find appropriate layer
    h = altitude_m
    for i, (h_base, T_base, L) in enumerate(layers):
        if i + 1 < len(layers):
            h_next = layers[i + 1][0]
            if h >= h_base and h < h_next:
                break
        else:
            if h >= h_base:
                break

    # Base pressure (sea level)
    P_base = 101325  # Pa

    # Calculate pressure at each layer base
    for j, (hb, Tb, Lb) in enumerate(layers[:i+1]):
        if j == 0:
            P_base = 101325
        else:
            h_prev, T_prev, L_prev = layers[j-1]
            if abs(L_prev) < 1e-10:  # Isothermal
                P_base = P_base * np.exp(-g0 * (hb - h_prev) / (R * T_prev))
            else:  # Gradient
                P_base = P_base * (T_prev / (T_prev + L_prev * (hb - h_prev))) ** (g0 / (R * L_prev))

    # Calculate temperature at altitude
    T = T_base + L * (h - h_base)

    # Calculate pressure at altitude
    if abs(L) < 1e-10:  # Isothermal layer
        P = P_base * np.exp(-g0 * (h - h_base) / (R * T_base))
    else:  # Gradient layer
        P = P_base * (T_base / T) ** (g0 / (R * L))

    # Calculate density
    rho = P / (R * T)

    # Speed of sound
    a = np.sqrt(gamma * R * T)

    return {
        'T': T,
        'P': P,
        'rho': rho,
        'a': a
    }

# Example usage
altitudes = [0, 5000, 10000, 15000, 20000, 30000, 40000]  # meters

print("Altitude [m] | T [K] | P [Pa] | ρ [kg/m³] | a [m/s]")
print("-" * 65)
for h in altitudes:
    props = us_standard_atmosphere_1976(h)
    print(f"{h:12.0f} | {props['T']:5.2f} | {props['P']:8.1f} | {props['rho']:9.6f} | {props['a']:6.2f}")

Applications to Aerospace Pumps and High-Altitude Systems

1. Pump Inlet Conditions

Altitude effect on pump performance:

# Calculate NPSH available at different altitudes
def npsh_available(altitude_m, fluid='water', T_fluid=293.15):
    """
    Calculate Net Positive Suction Head Available at altitude

    NPSH_a = (P_atm - P_vapor) / (ρ * g) + elevation_head - friction_losses
    """
    atm = us_standard_atmosphere_1976(altitude_m)
    P_atm = atm['P']  # Atmospheric pressure at altitude

    # Water vapor pressure (Antoine equation, simplified)
    P_vapor = 611.2 * np.exp(17.67 * (T_fluid - 273.15) / (T_fluid - 29.65))

    # Water density (approximate)
    rho_water = 1000  # kg/m³
    g = 9.81  # m/s²

    NPSH_a = (P_atm - P_vapor) / (rho_water * g)

    return NPSH_a, P_atm

# Example: NPSH at various altitudes
print("Altitude [m] | P_atm [kPa] | NPSH_a [m]")
print("-" * 45)
for h in [0, 1000, 2000, 3000, 5000]:
    npsh, p_atm = npsh_available(h)
    print(f"{h:12.0f} | {p_atm/1000:11.2f} | {npsh:10.2f}")

Output:

Altitude [m] | P_atm [kPa] | NPSH_a [m]
---------------------------------------------
           0 |      101.33 |      10.12
        1000 |       89.88 |       8.96
        2000 |       79.50 |       7.88
        3000 |       70.12 |       6.88
        5000 |       54.05 |       5.12

2. High-Altitude Compressor Design

Density variation impacts:

# Compressor power requirement vs altitude
def compressor_power(mass_flow_kg_s, pressure_ratio, altitude_m, eta_c=0.85):
    """
    Calculate compressor power at different altitudes
    """
    atm = us_standard_atmosphere_1976(altitude_m)
    T_in = atm['T']
    P_in = atm['P']
    rho_in = atm['rho']

    gamma = 1.4
    R = 287.05  # J/kg/K

    # Isentropic temperature ratio
    T_ratio = pressure_ratio ** ((gamma - 1) / gamma)

    # Actual temperature rise
    T_out = T_in * (1 + (T_ratio - 1) / eta_c)

    # Specific work
    w_c = R * (T_out - T_in) / (gamma - 1)

    # Power
    Power = mass_flow_kg_s * w_c / 1000  # kW

    return Power, rho_in, T_in

# Example: Compressor at sea level vs high altitude
m_dot = 1.0  # kg/s
PR = 3.0     # Pressure ratio

print(f"Compressor Performance (m_dot = {m_dot} kg/s, PR = {PR})")
print("Altitude [m] | ρ [kg/m³] | T_in [K] | Power [kW]")
print("-" * 60)
for h in [0, 5000, 10000, 15000]:
    P, rho, T = compressor_power(m_dot, PR, h)
    print(f"{h:12.0f} | {rho:9.4f} | {T:8.2f} | {P:10.2f}")

3. Thermal Control Systems

Ambient temperature for radiator/heat exchanger design:

# Heat rejection at altitude
def heat_rejection_altitude(Q_reject_W, altitude_m):
    """
    Calculate required radiator area for heat rejection at altitude
    Assuming natural convection to ambient air
    """
    atm = us_standard_atmosphere_1976(altitude_m)
    T_amb = atm['T']
    rho_amb = atm['rho']

    # Simplified convection coefficient (natural convection)
    # h ~ ρ^0.5 (density effect)
    h_sea_level = 10  # W/m²/K (typical natural convection)
    h = h_sea_level * (rho_amb / 1.225) ** 0.5

    # Assume radiator surface temperature
    T_surface = 350  # K (example: electronics cooling)

    # Required area: Q = h * A * ΔT
    delta_T = T_surface - T_amb
    A_required = Q_reject_W / (h * delta_T)

    return A_required, h, T_amb

# Example
Q = 1000  # W heat rejection
print(f"Radiator Area Required for {Q} W Heat Rejection")
print("Altitude [m] | T_amb [K] | h [W/m²K] | Area [m²]")
print("-" * 60)
for h in [0, 5000, 10000, 15000]:
    A, h_conv, T_amb = heat_rejection_altitude(Q, h)
    print(f"{h:12.0f} | {T_amb:9.2f} | {h_conv:9.2f} | {A:9.4f}")

4. Fluid Properties at Altitude

Cavitation and boiling point considerations:

def boiling_point_altitude(fluid='water'):
    """
    Calculate boiling point of water at different altitudes
    """
    print("Boiling Point vs Altitude (Water)")
    print("Altitude [m] | P_atm [kPa] | T_boil [°C]")
    print("-" * 50)

    for h in [0, 1000, 2000, 3000, 4000, 5000]:
        atm = us_standard_atmosphere_1976(h)
        P_atm = atm['P'] / 1000  # kPa

        # Approximate boiling point from pressure (Antoine equation)
        # log10(P) = A - B / (C + T)
        # Rearranged: T = B / (A - log10(P)) - C
        A, B, C = 8.07131, 1730.63, 233.426  # Antoine constants (water, T in °C, P in mmHg)
        P_mmHg = P_atm * 7.50062  # Convert kPa to mmHg
        T_boil = B / (A - np.log10(P_mmHg)) - C

        print(f"{h:12.0f} | {P_atm:11.2f} | {T_boil:11.2f}")

boiling_point_altitude()

Data Processing Workflow

Complete Example: Extract Atmospheric Profile

import netCDF4 as nc
import numpy as np
import matplotlib.pyplot as plt

# Read MERRA-2 NetCDF file
filename = "MERRA2_400.inst3_3d_asm_Np.20230101.nc4"
dataset = nc.Dataset(filename)

# Extract variables
lat = dataset.variables['lat'][:]  # Latitude
lon = dataset.variables['lon'][:]  # Longitude
lev = dataset.variables['lev'][:]  # Pressure levels [Pa]
T = dataset.variables['T'][:]      # Temperature [K]
H = dataset.variables['H'][:]      # Geopotential height [m]

# Select location (e.g., lat=40°N, lon=105°W - Colorado)
lat_idx = np.argmin(np.abs(lat - 40))
lon_idx = np.argmin(np.abs(lon - 255))  # -105° = 255° East

# Extract vertical profile at location
T_profile = T[0, :, lat_idx, lon_idx]  # time=0, all levels
H_profile = H[0, :, lat_idx, lon_idx]

# Convert to altitude (geopotential to geometric)
altitude_km = H_profile / 1000

# Plot temperature profile
plt.figure(figsize=(8, 10))
plt.plot(T_profile - 273.15, altitude_km)
plt.xlabel('Temperature [°C]')
plt.ylabel('Altitude [km]')
plt.title('Atmospheric Temperature Profile\n(40°N, 105°W)')
plt.grid(True)
plt.show()

dataset.close()

Best Practices

Cache Downloaded Data: NASA datasets are large; download once and process locally
Use OPeNDAP for Subsetting: Only download needed spatial/temporal regions
Check Data Version: MERRA-2 has multiple collections; use latest (M2I3NPASM.5.12.4)
Respect Download Limits: NASA may throttle excessive requests
Use Standard Atmosphere for Design: Real data for analysis; standard atmosphere for conservative design
Validate Results: Cross-check with published data (ICAO, ISO 2533)
Units Awareness: NASA data uses SI units (K, Pa, kg/m³); convert as needed
Time Zones: NASA data in UTC; adjust for local analysis

References

Official NASA Resources

NASA Earthdata Portal
- URL: https://www.earthdata.nasa.gov/
- Main portal for all Earth science data
Earthdata Search
- URL: https://search.earthdata.nasa.gov/
- Visual search and discovery tool
GES DISC (Goddard Earth Sciences Data and Information Services Center)
- URL: https://disc.gsfc.nasa.gov/
- Primary source for atmospheric data
MERRA-2 Documentation
- URL: https://gmao.gsfc.nasa.gov/reanalysis/MERRA-2/
- Details on reanalysis methodology

API and Tools

earthaccess Python Library
- GitHub: https://github.com/nsidc/earthaccess
- PyPI: pip install earthaccess
OPeNDAP Protocol
- URL: https://www.opendap.org/
- Data access protocol documentation
CMR (Common Metadata Repository)
- URL: https://cmr.earthdata.nasa.gov/search/
- Programmatic data search

Atmospheric Models

US Standard Atmosphere (1976)
- NOAA-S/T-76-1562
- Free download from NOAA
NRLMSISE-00
- URL: https://ccmc.gsfc.nasa.gov/modelweb/models/nrlmsise00.php
- Model code and documentation
ISO 2533:1975
- Standard Atmosphere reference
- Available from ISO

Aerospace Applications

AIAA Standards
- Atmospheric models for aerospace design
- Available from AIAA
ICAO Standard Atmosphere
- International Civil Aviation Organization
- Doc 7488/3

NASA Earthdata provides free, comprehensive atmospheric data essential for aerospace engineering analysis. Combined with standard atmosphere models, it enables accurate design and analysis of high-altitude pumps, compressors, thermal systems, and aerospace fluid applications.