Heatwave hazard assessment based on EURO-CORDEX data analysis

Heatwave hazard assessment based on EURO-CORDEX data analysis#

A workflow from the CLIMAAX Handbook and HEATWAVES GitHub repository.
See our how to use risk workflows page for information on how to run this notebook.

Description of the assessment#

In this workflow we will assess the heatwave hazard by directly analyzing EURO-CORDEX climate model data, making use of the xclim package to compute heatwave indicators.

Xclim package allows to identify hot and cold spells in the data, calculate heatwave frequency (per year) and total length of heatwaves.

In this workflow the heatwave definition is based on user-defined absolute temperature thresholds for the maximum and minimum daily temperatures (i.e. day and night temperatures), and a mimimum time duration (e.g. 2 or 3 days). Using absolute thresholds for temperature requires input from the user, these limits can be made specific to the region of interest and based on expected health impacts.

The calculation is based on climate data with resolution of 12x12km (EURO-CORDEX), where data is available for 1971-2100.

Advantages of using this methodology:

Heatwave calculation based on the minimum and maximum temperature, suitable also for the regions where the temperature can significantly cool down at night.
Flexibility of the methodology: the possibility of changing the temperature thresholds according to the needs of the user.

Disadvantages:

Computationally intensive due to the large amount of data.
Heatwaves are estimated on a yearly basis - not possible to analyze seasonal heatwaves.

Step 1: Preparation work#

Import packages#

In this notebook we will use the following Python libraries:

zipfile - Working with ZIP archive files (compression and extraction).
os - Interacting with the operating system, including handling the current working directory.
rasterio - Reading and writing geospatial raster data.
cdsapi - Interacting with the Climate Data Store (CDS) API for downloading climate data.
numpy - Handling large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays.
xarray - Handling labeled multi-dimensional arrays, commonly used for 2D and 3D array data handling.
dask - Efficient handling of large datasets and computations.
cartopy - Cartographic projections and coordinate transformations for geospatial data.
plotly - Creating interactive plots and visualizations.
ipyleaflet - Creating interactive maps in Jupyter notebooks.
ipywidgets - Creating interactive HTML widgets for Jupyter notebooks.
localtileserver - Serving local raster data as tiles and integrating with Leaflet maps.
xclim - Climate indices computation and analysis based on netCDF files using xarray.

import zipfile
import os
from itertools import chain

import rasterio
import cdsapi
import numpy as np
import xarray as xr
from dask.diagnostics import ProgressBar
import cartopy.crs as ccrs
import plotly.graph_objects as go
from ipyleaflet import Map, DrawControl, Marker, LayersControl
import ipywidgets as widgets
from localtileserver import get_leaflet_tile_layer, TileClient
import xclim
from IPython.display import display

# Set host forwarding for remote jupyterlab sessions
if 'JUPYTERHUB_SERVICE_PREFIX' in os.environ:
    os.environ['LOCALTILESERVER_CLIENT_PREFIX'] = f"{os.environ['JUPYTERHUB_SERVICE_PREFIX']}/proxy/{{port}}"

Create directory structure#

# Define the directory for the heatwave workflow preprocess
workflow_folder = 'Heatwave_hazard_XCLIM'
# Define directories for data and results within the previously defined workflow directory
data_dir = os.path.join(workflow_folder,'data')
results_dir = os.path.join(workflow_folder,'results')
# Check if the workflow directory exists, if not, create it along with subdirectories for data and results
if not os.path.exists(workflow_folder):
    os.makedirs(workflow_folder)
    os.makedirs(os.path.join(data_dir))
    os.makedirs(os.path.join(results_dir))

Step 3: Calculation of the heatwave occurrence based on the XCLIM methodology#

Convert the maximum temperature data from Kelvin (K) to Celsius (°C)

# Max Temperature historical
dmaxch = dmaxch['tasmax']
tasmaxh = dmaxch - 273.15
tasmaxh = tasmaxh.assign_attrs(dmaxch.attrs)
tasmaxh.attrs['units']='°C'

# Min Temperature historical
dminch = dminch['tasmin']
tasminh = dminch - 273.15
tasminh = tasminh.assign_attrs(dminch.attrs)
tasminh.attrs['units']='°C'

# Max Temperature rcp 45
dmaxc45 = dmaxc45['tasmax']
tasmax45 = dmaxc45 - 273.15
tasmax45 = tasmax45.assign_attrs(dmaxc45.attrs)
tasmax45.attrs['units']='°C'

# Min Temperature rcp 45
dminc45 = dminc45['tasmin']
tasmin45 = dminc45 - 273.15
tasmin45 = tasmin45.assign_attrs(dminc45.attrs)
tasmin45.attrs['units']='°C'

# Max Temperature rcp 85
dmaxc85 = dmaxc85['tasmax']
tasmax85 = dmaxc85 - 273.15
tasmax85 = tasmax85.assign_attrs(dmaxc85.attrs)
tasmax85.attrs['units']='°C'

# Min Temperature rcp 85
dminc85 = dminc85['tasmin']
tasmin85 = dminc85 - 273.15
tasmin85 = tasmin85.assign_attrs(dminc85.attrs)
tasmin85.attrs['units']='°C'

XCLIM is an operational Python library for climate services, providing numerous climate-related indicator tools with a framework for constructing custom climate indicators, statistical downscaling and bias adjustment of climate model simulations, as well as climate model ensemble analysis tools. XCLIM is built using xarray and can seamlessly benefit from the parallelization handling provided by dask. Its objective is to make it as simple as possible for users to perform typical climate data analyses. Leveraging xarray and dask, users can easily bias-adjust climate simulations over large spatial domains or compute indices from large climate datast [XCLIM]

Examples of the code for the computing of the climate indices.

xclim.indices.heat_wave_max_length(tasmin, tasmax, thresh_tasmin='22.0 degC', thresh_tasmax='30 degC', window=3, freq='YS', op='>', resample_before_rl=True)

In the example above (from XCLIM documentation) the thresholds of 22°C for night temperatures and 30°C for day temperatures were selected by Health Canada professionals, following a temperature–mortality analysis. These absolute temperature thresholds characterize the occurrence of hot weather events that can result in adverse health outcomes for Canadian communities [Casati et al., 2013]. For other regions these thresholds may need to be selected differently.

Loading data#

# This code selects the periods and RCPs for the computation of the climate indices by the XCLIM
# Max T
tasmaxh = tasmaxh.sel(time=slice("1971-01-01", "2005-12-31"))
tasmaxp_45 = tasmax45.sel(time=slice("2006-01-01", "2100-12-31"))
tasmaxp_85 = tasmax85.sel(time=slice("2006-01-01", "2100-12-31"))
# Min T
tasminh = tasminh.sel(time=slice("1971-01-01", "2005-12-31"))
tasminp_45 = tasmin45.sel(time=slice("2006-01-01", "2100-12-31"))
tasminp_85 = tasmin85.sel(time=slice("2006-01-01", "2100-12-31"))

Defining the temperature and duration tresholds#

Treshold temperatures based on the impact on human health:

Based on the preferred studies e.g.: A multi-city epidemiologic study in Europe found that the mortality threshold for heat effects was 29.4 °C for Mediterranean cities and 23.3 °C for the north European cities [Maximum temperature threshold for EU].
Or use the thresholds for minimum and maximum temperature given by your national meteorological or health service.

We select three climate indices from the Xclim package:

Heatwave index
Heatwave frequency
Heatwave total length

But you can also choose others, all climate indices are listed on Xclim website [source]

Calculating the heatwave index [source]#

We need to specify the temperature threshold for maximum daily air temperature (in degC) and the duration threshold (in days).

thresh_tempmax = '25.0 degC' # maximum daily temperature threshold
thresh_window = 5 #duration threshold in days

# This code uses the XCLIM package for the computation of the climate indices
# heatwave index
# RCP 4.5
HWIp45 = xclim.indices.heat_wave_index(tasmaxp_45, thresh=thresh_tempmax, window=thresh_window, freq='YS', op='>', resample_before_rl=True)
# RCP 8.5
HWIp85 = xclim.indices.heat_wave_index(tasmaxp_85, thresh=thresh_tempmax, window=thresh_window, freq='YS', op='>', resample_before_rl=True)
# Historical
HWIh = xclim.indices.heat_wave_index(tasmaxh, thresh=thresh_tempmax, window=thresh_window, freq='YS', op='>', resample_before_rl=True)

Calculating the heatwave frequency [source]#

We need to specify:

Temperature threshold for minimum daily air temperature (in degC)
Temperature threshold for maximum daily air temperature (in degC)
Duration threshold (in days)

thresh_tasmin = '22.0 degC' # threshold for minimum daily air temperature
thresh_tasmax = '28.0 degC' # threshold for maximum daily air temperature
thresh_window_hfreq = 3 #duration threshold in days

# Heatwave frequency
# RCP 4.5
HWFp45 = xclim.indices.heat_wave_frequency(tasminp_45, tasmaxp_45, thresh_tasmin=thresh_tasmin, thresh_tasmax=thresh_tasmax, window=thresh_window_hfreq, freq='YS', op='>', resample_before_rl=True)
# RCP 8.5
HWFp85 = xclim.indices.heat_wave_frequency(tasminp_85, tasmaxp_85, thresh_tasmin=thresh_tasmin, thresh_tasmax=thresh_tasmax, window=thresh_window_hfreq, freq='YS', op='>', resample_before_rl=True)
#Historical
HWFh = xclim.indices.heat_wave_frequency(tasminh, tasmaxh, thresh_tasmin=thresh_tasmin, thresh_tasmax=thresh_tasmax, window=thresh_window_hfreq, freq='YS', op='>', resample_before_rl=True)

# Data correction: set the right type
HWFp45 = HWFp45.astype(np.float64)
HWFp85 = HWFp85.astype(np.float64)
HWFh = HWFh.astype(np.float64)

Calculating heatwave total length [source]#

For this indicator we use the same thresholds as for the heatwave frequency indicator (above).

# heatwave total length
# RCP 4.5
HWTLp45=xclim.indices.heat_wave_total_length(tasminp_45, tasmaxp_45, thresh_tasmin=thresh_tasmin, thresh_tasmax=thresh_tasmax, window=thresh_window, freq='YS', op='>', resample_before_rl=True)
# RCP 8.5
HWTLp85=xclim.indices.heat_wave_total_length(tasminp_85, tasmaxp_85, thresh_tasmin=thresh_tasmin, thresh_tasmax=thresh_tasmax, window=thresh_window, freq='YS', op='>', resample_before_rl=True)
# Historical
HWTLh=xclim.indices.heat_wave_total_length(tasminh, tasmaxh, thresh_tasmin=thresh_tasmin, thresh_tasmax=thresh_tasmax, window=thresh_window, freq='YS', op='>', resample_before_rl=True)

# This code sets the rotated pole CRS to the calculated data
## CRS for Eurocordex data
rotated_pole = ccrs.RotatedPole(pole_latitude=39.25, pole_longitude=-162)
HWIp45.rio.write_crs(rotated_pole, inplace=True)
HWIp85.rio.write_crs(rotated_pole, inplace=True)
HWIh.rio.write_crs(rotated_pole, inplace=True)
HWFp45.rio.write_crs(rotated_pole, inplace=True)
HWFp85.rio.write_crs(rotated_pole, inplace=True)
HWFh.rio.write_crs(rotated_pole, inplace=True)
HWTLp45.rio.write_crs(rotated_pole, inplace=True)
HWTLp85.rio.write_crs(rotated_pole, inplace=True)
HWTLh.rio.write_crs(rotated_pole, inplace=True)
print("CRS written!")

CRS written!

The next step will perform the calculations and save the result to the disk. Depending on your machine’s computational capacity, this step may take some time.

# This code saves the computed indices in the disk in raster tif format 
with ProgressBar():
    print("Heatwave index")
    HWIp45.rio.to_raster(raster_path=f'{data_dir}/HWIp45.tif')
    HWIp85.rio.to_raster(raster_path=f'{data_dir}/HWIp85.tif')
    HWIh.rio.to_raster(raster_path=f'{data_dir}/HWIh.tif')
    print("Heatwave frequency")
    HWFp45.rio.to_raster(raster_path=f'{data_dir}/HWFp45.tif')
    HWFp85.rio.to_raster(raster_path=f'{data_dir}/HWFp85.tif')
    HWFh.rio.to_raster(raster_path=f'{data_dir}/HWFh.tif')
    print("Heatwave total length")
    HWTLp45.rio.to_raster(raster_path=f'{data_dir}/HWTLp45.tif')
    HWTLp85.rio.to_raster(raster_path=f'{data_dir}/HWTLp85.tif')
    HWTLh.rio.to_raster(raster_path=f'{data_dir}/HWTLh.tif')

Heatwave index
Heatwave frequency
Heatwave total length

Select location for plotting#

# This code reprojects the computed indices to the WGS84 (EPSG:4326)
# Define the files and their corresponding variables
file_variables = [
    ("HWIp45.tif", "HWIp45"),
    ("HWIp85.tif", "HWIp85"),
    ("HWIh.tif", "HWIh"),
    ("HWFp45.tif", "HWFp45"),
    ("HWFp85.tif", "HWFp85"),
    ("HWFh.tif", "HWFh"),
    ("HWTLp45.tif", "HWTLp45"),
    ("HWTLp85.tif", "HWTLp85"),
    ("HWTLh.tif", "HWTLh")
]
# Define the target CRS
target_crs = 'EPSG:4326'  # WGS84
# Iterate over each file and variable
for filename, var_name in file_variables:
    # Open the raster dataset
    data = xr.open_dataset(f'{data_dir}/{filename}')['band_data']   
    # Write the CRS information to the dataset
    data.rio.write_crs(rotated_pole, inplace=True)  
    # Reproject the clipped raster dataset to the target CRS
    reprojected_data = data.rio.reproject(target_crs)
    # Replace NaN values
    reprojected_data = reprojected_data.where(reprojected_data != 1.7976931348623157e+308, np.nan)   
    # Optionally, you can save the reprojected raster to a new file
    reprojected_data.rio.to_raster(raster_path=f'{data_dir}/{var_name}_reprojected.tif') 
    # Calculate mean and save to file
    mean_data = reprojected_data.mean(dim='band', skipna=True, keep_attrs=True)
    mean_data.rio.to_raster(raster_path=f'{data_dir}/{var_name}_m.tif')

With this code, you select the point on the map, for which you want to plot the bar and line graphs (select only one point, if you accidentally select multiple points, run this code (below) again and select the point again).

# This code plots the map where we need to select the point for the plot of the graphs for computed indices
# First, create a tile server from local raster file
client1 = TileClient(f'{data_dir}/HWIp85_m.tif')
# Create ipyleaflet tile layer from that server
t1 = get_leaflet_tile_layer(client1, colormap='Reds', opacity=0.5, nodata=0, name='heatwave index')
m = Map(center=client1.center(), zoom=client1.default_zoom)
m.add(t1)
control = LayersControl(position='topright')
m.add_control(control)
# Create lists to store point coordinates
point_lon_list = []
point_lat_list = []
# Create a DrawControl with point drawing enabled
draw_control = DrawControl(marker={'shapeOptions': {'color': '#FF0000'}})
# Add the DrawControl to the map
m.add_control(draw_control)
# Create a text widget to display coordinates
coord_output = widgets.Text(placeholder='Coordinates will appear here', disabled=True)
# Define a function to handle draw events
def handle_draw_point(self, action, geo_json):
    if action == 'created':
        if geo_json['geometry']['type'] == 'Point':
            # Extract coordinates of the point
            lon, lat = geo_json['geometry']['coordinates']
            # Update text widget with coordinates
            coord_output.value = f'Coordinates: ({lon:.2f}, {lat:.2f})'
            # Append coordinates to lists
            point_lon_list.append(lon)
            point_lat_list.append(lat)
            # Create and add a marker to the map
            marker = Marker(location=(lat, lon))
            m.add_layer(marker)
# Attach the event handler to the DrawControl
draw_control.on_draw(handle_draw_point)
# Arrange the map and text widget vertically
display(widgets.VBox([m, coord_output]))

c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\localtileserver\widgets.py:90: UserWarning: The `cmap` keyword argument is deprecated. Please use `colormap` instead.
  warnings.warn(

c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)
c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)
c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)
c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)
c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)
c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)
c:\Users\aleksand\AppData\Local\anaconda3\envs\climaax_heatwaves\Lib\site-packages\rio_tiler\models.py:140: RuntimeWarning: invalid value encountered in cast
  return array.astype(out_dtype)

In the picture above, we can find the plotted raster data in the area that we select by bbox at the beginning of the code.

The shown data is based on the calculated heatwave index. This visual comparison is intended to help understand which locations in your selected area will suffer more from heat (dark red will be most affected).

For the visual comparison of the number of heat occurrences you need to select a point (flag) from the left panel and select a pixel that you prefer. The skewness of the rasters was caused by the transformation of the coordinates system.

# This code extracts the values from the computed indices for the selected pixel 
def get_pixel_values(raster_file, lat, lon):
    with rasterio.open(raster_file) as src:
        # Transform lat/lon coordinates to pixel coordinates
        row, col = src.index(lon, lat)
        
        # Read pixel values from each band
        pixel_values = [band[row, col] for band in src.read()]
        
        # Return pixel values for each band
        return pixel_values

# Example usage
raster_file_hwi45 = f'{data_dir}/HWIp45_reprojected.tif'
raster_file_hwi85 = f'{data_dir}/HWIp85_reprojected.tif'
raster_file_hwih = f'{data_dir}/HWIh_reprojected.tif'
raster_file_hwf45 = f'{data_dir}/HWFp45_reprojected.tif'
raster_file_hwf85 = f'{data_dir}/HWFp85_reprojected.tif'
raster_file_hwfh = f'{data_dir}/HWFh_reprojected.tif'
raster_file_hwtl45 = f'{data_dir}/HWTLp45_reprojected.tif'
raster_file_hwtl85 = f'{data_dir}/HWTLp85_reprojected.tif'
raster_file_hwtlh = f'{data_dir}/HWTLh_reprojected.tif'
# extract lat lon from map
lat = point_lat_list[0]
lon = point_lon_list[0]
# extract values for selected pixel 
pixel_values_hwi45 = get_pixel_values(raster_file_hwi45, lat, lon)
pixel_values_hwi85 = get_pixel_values(raster_file_hwi85, lat, lon)
pixel_values_hwih = get_pixel_values(raster_file_hwih, lat, lon)
pixel_values_hwf45 = get_pixel_values(raster_file_hwf45, lat, lon)
pixel_values_hwf85 = get_pixel_values(raster_file_hwf85, lat, lon)
pixel_values_hwfh = get_pixel_values(raster_file_hwfh, lat, lon)
pixel_values_hwtl45 = get_pixel_values(raster_file_hwtl45, lat, lon)
pixel_values_hwtl85 = get_pixel_values(raster_file_hwtl85, lat, lon)
pixel_values_hwtlh = get_pixel_values(raster_file_hwtlh, lat, lon)

Plot the heatwave index (HWI)#

Number of days that are part of a heatwave, defined as five or more consecutive days over a threshold of 25 degrees (or with other thresholds if specified differently above!).

# This code plots the data with heatwave index for the selected pixel 
# Sample data
b = pixel_values_hwih + pixel_values_hwi45
t = pixel_values_hwih + pixel_values_hwi85 
# Define years
yearh = list(range(1971, 2005))
yearp1 = list(range(2006, 2101))
year = yearh + yearp1
# Create figure
fig = go.Figure()
# Add bar trace for 'b'
fig.add_trace(go.Bar(x=year, y=b, name='RCP4.5', marker_color='blue'))
# Add bar trace for 't'
fig.add_trace(go.Bar(x=year, y=t, name='RCP8.5', opacity=0.5, marker_color='red'))

# Add information on models
fig.add_annotation(xref='paper',yref='paper', y=-0.2,x=1, showarrow=False,
            text=f'GCM-RCM: {gcm_model} - {rcm_model}')

# Update layout
fig.update_layout(
    title={'text':f'HEATWAVE INDEX<br>Number of days that are part of a heatwave defined as {thresh_window} or more consequtive days over a threshold of {thresh_tempmax}<br>Location: lat {lat:.02f}\u00B0, lon {lon:.02f}\u00B0','x':0.5,'xanchor': 'center'},
    xaxis_title='Year',
    yaxis_title='Number of days',
    legend=dict(x=0, y=1, traceorder='normal', orientation='h'),
    width=1100,
    height=500)

Plot the heatwave frequency#

Number of heatwaves over a given period. A heatwave is defined as an event where the minimum and maximum daily temperature both exceed specific thresholds over a minimum number of days. The number of the heatwaves depends strictly on the threshold which we selected above.

# This code plots the data with heatwave frequency for the selected pixel 
# Sample data
b = pixel_values_hwfh + pixel_values_hwf45
t = pixel_values_hwfh + pixel_values_hwf85 
# Define years
yearh = list(range(1971, 2001))
yearp1 = list(range(2011, 2101))
year = yearh + yearp1
# Create figure
fig = go.Figure()
# Add bar trace for 'b'
fig.add_trace(go.Bar(x=year, y=b, name='RCP4.5', marker_color='blue'))
# Add bar trace for 't'
fig.add_trace(go.Bar(x=year, y=t, name='RCP8.5', opacity=0.5, marker_color='red'))
# Update layout

# Add information on models
fig.add_annotation(xref='paper',yref='paper', y=-0.2,x=1, showarrow=False,
            text=f'GCM-RCM: {gcm_model} - {rcm_model}')

fig.update_layout(
    title={'text':f'HEATWAVE FREQUENCY<br>based on temperature thresholds for day and night: {thresh_tasmax} and {thresh_tasmin}, for at least {thresh_window_hfreq} consequtive days<br>Location: lat {lat:.02f}\u00B0, lon {lon:.02f}\u00B0','x':0.5,'xanchor': 'center'},
    xaxis_title='Year',
    yaxis_title='Number of heatwaves per year',
    legend=dict(x=0, y=1, traceorder='normal', orientation='h'),
    width=1100,
    height=500)

Plot the heatwave total length#

Total length of heatwaves over a given period. A heatwave is defined as an event where the minimum and maximum daily temperature both exceeds specific thresholds over a minimum number of days. This the sum of all days in such events.

# This code plots the data with heatwave total length for the selected pixel 
# Sample data
b = pixel_values_hwtlh + pixel_values_hwtl45
t = pixel_values_hwtlh + pixel_values_hwtl85 
# Define years
yearh = list(range(1971, 2001))
yearp1 = list(range(2011, 2101))
year = yearh + yearp1
# Create figure
fig = go.Figure()
# Add bar trace for 'b'
fig.add_trace(go.Bar(x=year, y=b, name='RCP4.5', marker_color='blue'))
# Add bar trace for 't'
fig.add_trace(go.Bar(x=year, y=t, name='RCP8.5', opacity=0.5, marker_color='red'))

# Add information on models
fig.add_annotation(xref='paper',yref='paper', y=-0.2,x=1, showarrow=False,
            text=f'GCM-RCM: {gcm_model} - {rcm_model}')

# Update layout
fig.update_layout(
    title={'text':f'Total number of heatwave days<br>based on temperature thresholds for day and night: {thresh_tasmax[:4]}\u00B0C and {thresh_tasmin[:4]}\u00B0C, for at least {thresh_window_hfreq} consequtive days<br>Location: lat {lat:.02f}\u00B0, lon {lon:.02f}\u00B0','x':0.5,'xanchor': 'center'},
    xaxis_title='Year',
    yaxis_title='Total number of days during heatwave events',
    legend=dict(x=0, y=1, traceorder='normal', orientation='h'),
    width=1100,
    height=500)

Conclusions for the XCLIM results#

We calculated three climate indices connected to extreme temperature: heatwave index, heatwave frequency, and heatwave total length for two climate scenarios (RCP4.5 and RCP8.5) based on the EURO-CORDEX data.

To interpret the plotted results, it is important to remember that the result is dependent on the GCM-RCM combination of climate models that is used in the analysis. This workflow is based on a single model combination, and using a different combination will lead to a different distribution of temperature for specific years. However, the general trend over the entire analysis period will be similar. It is recommended to perform this analysis for several GCM-RCM combinations to check how much the result is dependent on the selection of the models.

The plotted data with indicator values per year should not be used as a forecast of heatwaves for specific years, as this is strongly dependent on the model realization. For policy and planning it may be useful to calculate average indices (e.g. average heatwave occurence) over periods of 20-30 years and compare to historical periods of the same length (e.g. 2040-2060 vs. 1990-2010).

The plotted results are obtained for a single location within the EURO-CORDEX dataset, which corresponds to a 12x12 km cell. The data within this cell does not take into account the finer resolution effects such as the urban heat island effect, and does not take into account future land use changes.

References#

Copernicus Climate Data Store, heatwave days for European countries derived from climate projections (2021), https://cds.climate.copernicus.eu/cdsapp#!/software/app-health-heatwaves-projections?tab=app [2024-06-17].
Copernicus Climate Data Store, heatwave days for Europe derived from ERA5 reanalysis (2021), https://cds.climate.copernicus.eu/cdsapp#!/software/app-health-heatwaves-current-climate?tab=app [2024-06-17].
Copernicus Climate Data Store, heatwave days and heat-related mortality for nine European cities (2021), https://cds.climate.copernicus.eu/cdsapp#!/software/app-health-urban-heat-related-mortality-projections?tab=app [2024-06-17].
Copernicus Climate Data Store, heatwaves and cold spells in Europe derived from climate projections (2019), https://cds.climate.copernicus.eu/datasets/sis-heat-and-cold-spells?tab=overview [2024-06-17].
Climate adapt, Apparent temperature heatwave days (2021), https://climate-adapt.eea.europa.eu/en/metadata/indicators/apparent-temperature-heatwave-days [2024-06-17].
Hooyberghs, H., Berckmans, J., Lefebre, F., De Ridder, K. (2019): heatwaves and cold spells in Europe derived from climate projections. Copernicus Climate Change Service (C3S) Climate Data Store (CDS). DOI: 10.24381/cds.9e7ca677 (Accessed on 06-17-2024)
Climate adapt, Tropical nights (2021), https://climate-adapt.eea.europa.eu/en/observatory/++aq++metadata/indicators/tropical-nights/ [2024-06-17].
Climate adapt, High UTCI Days (2021), https://climate-adapt.eea.europa.eu/en/metadata/indicators/high-utci-days [2024-06-17].
Bourgault et al., (2023). Xclim: xarray-based climate data analytics. Journal of Open Source Software, 8(85), 5415, https://doi.org/10.21105/joss.05415

Authors#

Martin Kuban, KAJO services (martin.kuban@kajoservices.com)
Milan Kalas, KAJO services (milan.kalas@kajoservices.com)
Milica Aleksic, KAJO services (milica.aleksic@kajoservices.com)
Natalia Aleksandrova, Deltares (review and editing)