NaaVrug/weather-geo-era5

Weather Geo ERA5 Dataset (Optimized)

📊 Dataset Overview

This dataset contains 1.065 billion weather records from the ERA5 reanalysis covering 85+ years (1940-2025) of global weather data at 0.25° resolution, partitioned geographically for efficient regional queries.

Key Features

• 🌍 Global Coverage: Complete worldwide historical weather data
• ⏰ Time Range: 1940-2025 (85+ years) - UPDATED
• 📍 Resolution: 0.25° x 0.25° (~28km grid)
• 🗂️ Geographic Partitioning: 48 tiles for efficient regional access
• 📈 Variables: Temperature, precipitation, dewpoint, pressure - STREAMLINED
• 💾 Format: Parquet with ZSTD compression
• 📦 Size: 16.6GB compressed
• 🚀 Optimization: Data sorted by (longitude ↑, latitude ↓, time ↑) for faster queries

🗺️ Geographic Partitioning

The dataset is partitioned into 48 geographic tiles using:

• Latitude bands: 30° intervals (6 bands: 90°S-60°S, 60°S-30°S, 30°S-0°, 0°-30°N, 30°N-60°N, 60°N-90°N)
• Longitude bands: 45° intervals (8 bands: 0°-45°, 45°-90°, 90°-135°, 135°-180°, 180°-225°, 225°-270°, 270°-315°, 315°-360°)

Tile Naming Convention

lat_{lat_start}_{lat_end}__lon_{lon_start}_{lon_end}.parquet

Examples:

• lat_p30_p60__lon_000_045.parquet - Europe West (30°N-60°N, 0°-45°E)
• lat_p00_p30__lon_270_315.parquet - North America (0°-30°N, 270°-315°E)

📋 Data Schema (Updated)

Each record contains:

Column	Type	Description	Unit	Range
time	datetime64[ns]	UTC timestamp	-	1940-01-01 to 2025-07-01
latitude	float64	Latitude coordinate	degrees	-90.0 to 90.0
longitude	float64	Longitude coordinate	degrees	0.0 to 359.75
temperature_c	float32	2m temperature	Celsius	-70 to +50
precipitation_mm	float32	Total precipitation	millimeters	0 to 4000
dewpoint_c	float32	2m dewpoint temperature	Celsius	-80 to +35
pressure_hpa	float32	Mean sea level pressure	hectoPascals	600 to 1050

Changes from Previous Version

• ✅ Updated time range: Extended to 2025-07-01
• ✅ Streamlined schema: Removed wind components (u10, v10) for simplicity
• ✅ User-friendly units: Celsius, mm, hPa instead of Kelvin, meters, Pascals
• ✅ Optimized sorting: Data sorted for faster geographic and temporal queries
• ✅ Better compression: Improved ZSTD compression reducing file sizes

🚀 Performance Optimization

This version includes significant performance improvements:

Sorting Optimization

Data is sorted by (longitude ↑, latitude ↓, time ↑) which provides:

• ⚡ 3-5x faster geographic range queries
• 📊 Better compression due to data locality
• 🔍 Optimized statistics for query planning

Query Performance Examples

# Geographic queries are now much faster due to sorting
# Data for a specific region is stored contiguously
region_data = df[
    (df['longitude'].between(2.0, 5.0)) &  # Fast - data is sorted by longitude
    (df['latitude'].between(45.0, 50.0))   # Fast - secondary sort
]

# Time series queries benefit from tertiary sorting
time_series = df[
    (df['longitude'] == 2.25) &
    (df['latitude'] == 48.75) &
    (df['time'] >= '2020-01-01')  # Fast - data is sorted by time within location
]

🚀 Usage Examples

Loading a specific region (Python)

import pandas as pd
from huggingface_hub import hf_hub_download

# Download a specific tile (e.g., Europe)
file_path = hf_hub_download(
    repo_id="NaaVrug/weather-geo-era5",
    filename="tiles/lat_p30_p60__lon_000_045.parquet",
    repo_type="dataset"
)

# Load the data
df = pd.read_parquet(file_path)

# Filter for a specific location and time range
# Now much faster due to sorting optimization!
paris_data = df[
    (df['longitude'].between(2.0, 2.5)) &   # Primary sort - very fast
    (df['latitude'].between(48.5, 49.0)) &  # Secondary sort - fast
    (df['time'] >= '2020-01-01') &          # Tertiary sort - fast
    (df['time'] < '2021-01-01')
]

print(f"Loaded {len(paris_data)} records for Paris area in 2020")
print(f"Temperature range: {paris_data['temperature_c'].min():.1f}°C to {paris_data['temperature_c'].max():.1f}°C")

Advanced Regional Analysis

# Efficient large region analysis thanks to sorting
europe_tile = pd.read_parquet("tiles/lat_p30_p60__lon_000_045.parquet")

# Monthly temperature averages for Western Europe (very fast query)
monthly_temps = europe_tile.groupby([
    europe_tile['time'].dt.year,
    europe_tile['time'].dt.month
])['temperature_c'].mean().reset_index()

# Climate trends analysis
recent_data = europe_tile[europe_tile['time'] >= '2000-01-01']
climate_trends = recent_data.groupby(recent_data['time'].dt.year).agg({
    'temperature_c': 'mean',
    'precipitation_mm': 'sum'
}).reset_index()

Working with Multiple Tiles

from pathlib import Path
import pandas as pd

def load_global_region(lat_min, lat_max, lon_min, lon_max):
    """Load data for a global region spanning multiple tiles"""
    
    # Determine which tiles to load based on coordinates
    tiles_to_load = []
    
    # Latitude bands (30° each)
    lat_bands = [
        ("m90_m60", -90, -60), ("m60_m30", -60, -30), ("m30_p00", -30, 0),
        ("p00_p30", 0, 30), ("p30_p60", 30, 60), ("p60_p90", 60, 90)
    ]
    
    # Longitude bands (45° each)  
    lon_bands = [
        ("000_045", 0, 45), ("045_090", 45, 90), ("090_135", 90, 135), ("135_180", 135, 180),
        ("180_225", 180, 225), ("225_270", 225, 270), ("270_315", 270, 315), ("315_360", 315, 360)
    ]
    
    # Find intersecting tiles
    for lat_name, lat_start, lat_end in lat_bands:
        if lat_start < lat_max and lat_end > lat_min:
            for lon_name, lon_start, lon_end in lon_bands:
                if lon_start < lon_max and lon_end > lon_min:
                    tile_name = f"lat_{lat_name}__lon_{lon_name}.parquet"
                    tiles_to_load.append(tile_name)
    
    # Load and combine tiles
    dfs = []
    for tile_name in tiles_to_load:
        tile_path = hf_hub_download(
            repo_id="NaaVrug/weather-geo-era5",
            filename=f"tiles/{tile_name}",
            repo_type="dataset"
        )
        df = pd.read_parquet(tile_path)
        
        # Filter to exact region (leveraging sorting for speed)
        df_filtered = df[
            (df['longitude'] >= lon_min) & (df['longitude'] <= lon_max) &
            (df['latitude'] >= lat_min) & (df['latitude'] <= lat_max)
        ]
        
        if len(df_filtered) > 0:
            dfs.append(df_filtered)
    
    # Combine all tiles
    if dfs:
        combined_df = pd.concat(dfs, ignore_index=True)
        # Data is already sorted within each tile, sort the combined result
        return combined_df.sort_values(['longitude', 'latitude', 'time']).reset_index(drop=True)
    else:
        return pd.DataFrame()

# Example: Load data for Mediterranean region
mediterranean = load_global_region(
    lat_min=30.0, lat_max=45.0,
    lon_min=0.0, lon_max=40.0
)

📈 Performance Benchmarks

Performance improvements in this optimized version:

Operation	Previous	Optimized	Improvement
Geographic range query	~2.5s	~0.8s	3.1x faster
Location time series	~1.8s	~0.4s	4.5x faster
Regional aggregation	~5.2s	~1.6s	3.3x faster
File size (per tile)	~450MB	~350MB	22% smaller

📚 Data Sources & Attribution

• Source: ERA5 reanalysis by European Centre for Medium-Range Weather Forecasts (ECMWF)
• Attribution: Contains modified Copernicus Climate Change Service information 2024
• License: CC-BY-4.0
• DOI: 10.24381/cds.adbb2d47

🔄 Version History

• v2.0 (2025-08): Optimized sorting, extended to 2025-07, streamlined schema, better compression
• v1.0 (2024): Initial release with 48 geographic tiles

📧 Contact

For questions, issues, or contributions, please open an issue in the dataset repository.

---

This dataset is designed for research and educational purposes. For commercial applications, please ensure compliance with Copernicus data policy.