メニュー
Download and analyze ERA5 reanalysis climate data via the Copernicus CDS API, compute anomalies, trend analysis, and produce publication-quality climate maps.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/xjtulyc/awesome-rosetta-skills --skill era5-climateコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SKILL.md を表示中
SOC 職業分類に基づく
| name | era5-climate |
| description | Download and analyze ERA5 reanalysis climate data via the Copernicus CDS API, compute anomalies, trend analysis, and produce publication-quality climate maps. |
| tags | ["climate","era5","reanalysis","xarray","cartopy","mann-kendall"] |
| version | 1.0.0 |
| authors | [{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}] |
| license | MIT |
| platforms | ["claude-code","codex","gemini-cli","cursor"] |
| dependencies | ["cdsapi>=0.6.1","xarray>=2023.6.0","numpy>=1.24.0","scipy>=1.11.0","matplotlib>=3.7.0","cartopy>=0.22.0","pymannkendall>=1.4.3","netCDF4>=1.6.4","cfgrib>=0.9.10","pandas>=2.0.0"] |
| last_updated | 2026-03-17 |
This skill covers downloading ERA5 reanalysis data from the Copernicus Climate Data Store (CDS), processing large NetCDF datasets with xarray, computing climate anomalies against a reference baseline, detecting long-term trends via the Mann-Kendall test, and producing publication-quality maps with Cartopy.
ERA5 is the fifth generation ECMWF atmospheric reanalysis of the global climate, providing hourly estimates of atmospheric, land, and oceanic climate variables from 1940 to near-present at roughly 31 km horizontal resolution.
The Copernicus Climate Data Store requires registration and an API key. After registering at
https://cds.climate.copernicus.eu, place your credentials in ~/.cdsapirc:
# ~/.cdsapirc
url: https://cds.climate.copernicus.eu/api/v2
key: YOUR_UID:YOUR_API_KEY
verify: 1
Replace YOUR_UID and YOUR_API_KEY with your actual CDS user ID and API key from your CDS
account profile page. The file must be readable only by you (chmod 600 ~/.cdsapirc).
pip install cdsapi xarray numpy scipy matplotlib cartopy pymannkendall netCDF4 cfgrib pandas
# On conda environments, cartopy is easier to install via conda:
# conda install -c conda-forge cartopy
"""
era5_climate.py
---------------
Core utilities for ERA5 reanalysis data download, anomaly computation,
trend analysis, and visualization.
"""
import os
import warnings
from pathlib import Path
from typing import Optional, Tuple, List, Dict
import cdsapi
import numpy as np
import pandas as pd
import xarray as xr
import matplotlib.pyplot plt
matplotlib.colors mcolors
cartopy.crs ccrs
cartopy.feature cfeature
pymannkendall mk
warnings.filterwarnings(, category=RuntimeWarning)
() -> Path:
output_dir = Path(output_dir)
output_dir.mkdir(parents=, exist_ok=)
region_tag = region
years_tag =
filename = output_dir /
filename.exists():
()
filename
c = cdsapi.Client()
dataset =
product_type =
request = {
: product_type,
: variable,
: [(y) y years],
: [ m (, )],
: ,
: ,
}
region :
request[] = region
pressure_level :
dataset =
request[] = (pressure_level)
()
c.retrieve(dataset, request, (filename))
()
filename
() -> xr.DataArray:
start, end = baseline_years
baseline = da.sel(time=da.time.dt.year.isin((start, end + )))
climatology = baseline.groupby().mean()
anomaly = da.groupby() - climatology
anomaly.attrs = da.attrs.copy()
anomaly.attrs[] = da.attrs.get(, da.name) +
anomaly
() -> [, xr.DataArray]:
() -> [, ]:
valid = ts[~np.isnan(ts)]
(valid) < :
np.nan, np.nan
result = mk.original_test(valid)
result.slope, result.p
spatial_dims = [d d da.dims d != dim]
spatial_dims:
result = mk.original_test(da.values[~np.isnan(da.values)])
{
: (result.slope),
: (result.p),
: result.trend,
}
slope_vals = np.full(da.shape[:], np.nan)
pval_vals = np.full(da.shape[:], np.nan)
data_np = da.values
flat = data_np.reshape(data_np.shape[], -)
slopes_flat = np.full(flat.shape[], np.nan)
pvals_flat = np.full(flat.shape[], np.nan)
i (flat.shape[]):
s, p = _mk_pixel(flat[:, i])
slopes_flat[i] = s
pvals_flat[i] = p
slope_vals = slopes_flat.reshape(data_np.shape[:])
pval_vals = pvals_flat.reshape(data_np.shape[:])
coords = {d: da.coords[d] d spatial_dims}
slope_da = xr.DataArray(slope_vals, dims=spatial_dims, coords=coords,
attrs={: , : })
pval_da = xr.DataArray(pval_vals, dims=spatial_dims, coords=coords,
attrs={: })
{: slope_da, : pval_da}
() -> xr.DataArray:
weights = np.cos(np.deg2rad(da[lat_dim]))
weights = weights / weights.()
(da * weights).([lat_dim, ])
() -> plt.Figure:
proj_map = {
: ccrs.Robinson(),
: ccrs.PlateCarree(),
: ccrs.Mollweide(),
: ccrs.NorthPolarStereo(),
: ccrs.SouthPolarStereo(),
}
proj = proj_map.get(projection, ccrs.Robinson())
fig, ax = plt.subplots(, , figsize=(, ),
subplot_kw={: proj})
ax.set_global()
ax.add_feature(cfeature.COASTLINE, linewidth=)
ax.add_feature(cfeature.BORDERS, linewidth=, linestyle=)
ax.add_feature(cfeature.LAND, facecolor=, alpha=)
lons = da[].values
lats = da[].values
data = da.values
vmin vmax :
absmax = np.nanpercentile(np.(data), )
vmin, vmax = -absmax, absmax
im = ax.pcolormesh(
lons, lats, data,
transform=ccrs.PlateCarree(),
cmap=cmap, vmin=vmin, vmax=vmax,
shading=,
)
stipple_mask :
sig_lons, sig_lats = np.meshgrid(lons, lats)
mask = stipple_mask.values.astype()
ax.scatter(
sig_lons[mask], sig_lats[mask],
transform=ccrs.PlateCarree(),
s=, c=, alpha=, linewidths=,
)
units_label = units da.attrs.get(, )
cbar = fig.colorbar(im, ax=ax, orientation=,
pad=, shrink=, aspect=)
cbar.set_label(units_label, fontsize=)
ax.set_title(title, fontsize=, pad=)
ax.gridlines(draw_labels=, linewidth=, color=, alpha=)
output_path:
fig.savefig(output_path, dpi=, bbox_inches=)
()
fig
This example downloads ERA5 2-metre temperature data, computes anomalies against the 1991–2020 reference period, and plots the mean anomaly for 2016 (a strong El Niño year).
"""
example_temperature_anomaly.py
-------------------------------
Global surface temperature anomaly relative to 1991-2020 climatology.
Reproduces a figure similar to NOAA/WMO annual climate state reports.
"""
import xarray as xr
import matplotlib.pyplot as plt
from era5_climate import (
download_era5_monthly,
compute_anomaly,
area_weighted_mean,
plot_climate_map,
)
# ---- 1. Download data (skip if already cached) ----
nc_file = download_era5_monthly(
variable="2m_temperature",
years=list(range(1979, 2024)),
region=None, # global
output_dir="era5_data",
)
# ---- 2. Load and unit-convert K -> °C ----
ds = xr.open_dataset(nc_file)
t2m = ds["t2m"] - 273.15
t2m.attrs["units"] = "°C"
t2m.attrs["long_name"] = "2-metre temperature"
# ---- 3. Compute monthly anomalies ----
anom = compute_anomaly(t2m, baseline_years=(1991, 2020))
# ---- 4. Annual mean anomaly time series (global) ----
gmt = area_weighted_mean(anom).resample(time="1Y").mean()
fig, ax = plt.subplots(figsize=(12, 4))
years_ts = gmt.time.dt.year.values
ax.bar(years_ts, gmt.values, color=["firebrick" if v > 0 else "steelblue" for v in gmt.values])
ax.axhline(0, color="black", linewidth=0.8)
ax.set_xlabel("Year")
ax.set_ylabel("Temperature anomaly (°C)")
ax.set_title("Global Mean Surface Temperature Anomaly 1979–2023\n(relative to 1991–2020)")
fig.tight_layout()
fig.savefig("gmt_anomaly_timeseries.png", dpi=150)
print("Saved: gmt_anomaly_timeseries.png")
# ---- 5. Spatial anomaly map for the year 2016 ----
anom_2016 = anom.sel(time=anom.time.dt.year == 2016).mean("time")
fig_map = plot_climate_map(
anom_2016,
projection="Robinson",
title="ERA5 Surface Temperature Anomaly – Annual Mean 2016\n(relative to 1991–2020)",
cmap="RdBu_r",
units="°C",
output_path="t2m_anomaly_2016.png",
)
plt.show()
# ---- 6. Quick summary statistics ----
print(f"\nWarmest year: {years_ts[gmt.values.argmax()]} "
f"(+{gmt.values.max():.3f} °C)")
print(f"Coldest year: {years_ts[gmt.values.argmin()]} "
f"({gmt.values.min():.3f} °C)")
print(f"Long-term trend: {(gmt.values[-1] - gmt.values[0]):.2f} °C over the period")
This example downloads ERA5 total precipitation over Europe, computes grid-point Mann-Kendall trends, and overlays significance stippling on the trend map.
"""
example_precipitation_trend.py
--------------------------------
Detect statistically significant precipitation trends (1979-2023) over Europe
using the Mann-Kendall test and Theil-Sen slope estimation.
"""
import numpy as np
import xarray as xr
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy.feature as cfeature
from era5_climate import (
download_era5_monthly,
calculate_trend,
plot_climate_map,
)
# ---- 1. Download ERA5 total precipitation for Europe ----
# region = [north, west, south, east]
nc_file = download_era5_monthly(
variable="total_precipitation",
years=list(range(1979, 2024)),
region=[72.0, -25.0, 25.0, 45.0], # Europe
output_dir="era5_data",
)
# ---- 2. Load and convert m/month -> mm/month ----
ds = xr.open_dataset(nc_file)
tp = ds["tp"] * 1000.0
tp.attrs["units"] = "mm/month"
tp.attrs["long_name"] = "Total precipitation"
# ---- 3. Compute annual totals (sum over months within each year) ----
tp_annual = tp.resample(time="1Y").sum("time")
# ---- 4. Grid-point trend analysis ----
print("Running Mann-Kendall test (this may take a few minutes for large grids) ...")
trend_results = calculate_trend(tp_annual, dim="time")
slope = trend_results["slope"] # mm/year per year
pval = trend_results["p_value"]
# Significance mask at 95% confidence
sig_mask = pval < 0.05
# ---- 5. Plot trend map with significance stippling ----
fig_trend = plot_climate_map(
slope * 10, # scale to mm/decade
projection="PlateCarree",
title="ERA5 Annual Precipitation Trend 1979–2023 (Europe)\n"
"Stippled: p < 0.05 (Mann-Kendall)",
cmap="BrBG",
units="mm / decade",
stipple_mask=sig_mask,
output_path="europe_precip_trend.png",
)
plt.show()
# ---- 6. Regional averages: Mediterranean vs Northern Europe ----
regions = {
"Mediterranean": {"lat": slice(47, 30), "lon": slice(-10, 40)},
"Northern Europe": {"lat": slice(72, 55), "lon": slice(-10, 40)},
}
print("\nRegional precipitation trends:")
print(f"{'Region':<20} {'Trend (mm/decade)':>18} {'MK p-value':>12}")
print("-" * 52)
for name, sel in regions.items():
sub = tp_annual.sel(latitude=sel["lat"], longitude=sel["lon"])
weights = np.cos(np.deg2rad(sub["latitude"]))
ts = (sub * weights).sum(["latitude", "longitude"]) / weights.sum()
res = calculate_trend(ts, dim="time")
print(f"{name:<20} {res['slope']*10:>18.2f} {res['p_value']:>12.4f}")
# ---- 7. CMIP6 comparison stub ----
def compare_with_cmip6(era5_slope: xr.DataArray, cmip6_nc_path: str) -> None:
"""
Overlay ERA5 trend with a CMIP6 multi-model mean trend for visual comparison.
Load a pre-processed CMIP6 trend file and plot side-by-side.
"""
cmip6_ds = xr.open_dataset(cmip6_nc_path)
cmip6_slope = cmip6_ds["pr_trend"] # adjust variable name as needed
fig, axes = plt.subplots(1, 2, figsize=(18, 6),
subplot_kw={"projection": ccrs.PlateCarree()})
datasets = [(era5_slope * 10, "ERA5 (1979–2023)"),
(cmip6_slope, "CMIP6 MMM (historical)")]
for ax, (data, label) in zip(axes, datasets):
ax.set_extent([-25, 45, 25, 72])
ax.add_feature(cfeature.COASTLINE, linewidth=0.5)
im = ax.pcolormesh(data["longitude"], data["latitude"], data.values,
transform=ccrs.PlateCarree(), cmap="BrBG",
vmin=-30, vmax=30, shading="auto")
ax.set_title(label)
fig.colorbar(im, ax=ax, orientation="horizontal",
pad=0.05, label="mm/decade")
fig.suptitle("Precipitation Trend Comparison: ERA5 vs CMIP6", fontsize=14)
fig.savefig("era5_vs_cmip6_precip_trend.png", dpi=150, bbox_inches="tight")
plt.show()
# Uncomment the line below once you have a CMIP6 trend file available:
# compare_with_cmip6(slope, "cmip6_precip_trend_europe.nc")
"""
extreme_events.py
-----------------
Detect hot days and heavy precipitation events using percentile thresholds.
"""
import numpy as np
import xarray as xr
def detect_extremes(
da: xr.DataArray,
percentile: float = 95.0,
baseline_years: tuple = (1981, 2010),
extreme_type: str = "upper",
) -> xr.DataArray:
"""
Flag time steps exceeding (or falling below) a percentile threshold
computed from a reference period.
Parameters
----------
da : xr.DataArray
Daily or monthly DataArray (time, lat, lon).
percentile : float
Threshold percentile (e.g. 95 for upper tail, 5 for lower tail).
baseline_years : tuple
Reference period for computing percentile thresholds.
extreme_type : str
'upper' (values above threshold) or 'lower' (values below threshold).
Returns
-------
xr.DataArray
Boolean DataArray; True where the condition is met.
"""
start, end = baseline_years
baseline = da.sel(time=da.time.dt.year.isin(range(start, end + 1)))
threshold = baseline.quantile(percentile / 100.0, dim="time")
if extreme_type == "upper":
return da > threshold
return da < threshold
def count_extreme_days_per_year(
extreme_mask: xr.DataArray,
) -> xr.DataArray:
"""Count the number of extreme days per calendar year at each grid point."""
return extreme_mask.resample(time="1Y").sum("time")
# Usage example
if __name__ == "__main__":
ds = xr.open_dataset("era5_data/era5_2m_temperature_1979-2023_global.nc")
t2m = ds["t2m"] - 273.15
hot_days = detect_extremes(t2m, percentile=95, baseline_years=(1981, 2010))
hot_days_per_year = count_extreme_days_per_year(hot_days)
# Plot trend in hot-day frequency for 2000-2023
hd_trend = hot_days_per_year.sel(
time=hot_days_per_year.time.dt.year >= 2000
).mean(["latitude", "longitude"])
print("Global mean hot days per year (2000-2023):")
for yr, val in zip(hd_trend.time.dt.year.values, hd_trend.values):
print(f" {yr}: {val:.1f} days")
chunks={"time": 12} to
enable lazy, out-of-core processing.cftime_range when
selecting dates if xarray raises calendar errors.reanalysis-era5-pressure-levels-monthly-means dataset and
supply pressure_level parameter. Common levels: 850, 700, 500, 250, 100 hPa.