The following procedures describe how to compute the pressure and geopotential on model levels, geopotential height and geometric height.
Pressure on model levels
In ERA5, pressure is provided at the surface, but not on individual model levels. However, an illustration of pressure on model levels (p_ml) is shown in Figure 1, and can be computed for particular dates and times using the procedure described below.
You will need the following Inputs:
logarithm of surface pressure (lnsp)
Example to download ERA5 lnsp data for a given area at a regular lat/lon grid in NetCDF formatExpand source
#!/usr/bin/env python
import cdsapi
c = cdsapi.Client()
c.retrieve('reanalysis-era5-complete', { # Requests follow MARS syntax
# Keywords 'expver' and 'class' can be dropped. They are obsolete
# since their values are imposed by 'reanalysis-era5-complete'
'date' : '2013-01-01', # The hyphens can be omitted
'levelist': '1', # 1 is top level, 137 the lowest model level in ERA5. Use '/' to separate values.
'levtype' : 'ml',
'param' : '152', # Full information at https://apps.ecmwf.int/codes/grib/param-db/
# The native representation for temperature is spherical harmonics
'stream' : 'oper', # Denotes ERA5. Ensemble members are selected by 'enda'
'time' : '00/to/23/by/6', # You can drop :00:00 and use MARS short-hand notation, instead of '00/06/12/18'
'type' : 'an',
'area' : '80/-50/-25/0', # North, West, South, East. Default: global
'grid' : '1.0/1.0', # Latitude/longitude. Default: spherical harmonics or reduced Gaussian grid
'format' : 'netcdf', # Output needs to be regular lat-lon, so only works in combination with 'grid'!
}, 'ERA5-ml-lnsp-subarea.nc') # Output file. Adapt as you wish.
a(n) and b(n) coefficients defining the model levels; these are included in the GRIB header of each model level GRIB message and are also tabulated here.
The model half-level pressure (p_half), illustrated in Figure 2, is given by:
\[ \text{p_half} = a + b \ast \text{sp} \]
where sp (
\( \text{sp} = e^{lnsp} \)
) is the surface pressure (and lnsp is it's natural logarithm).
The pressure on model levels (p_ml), illustrated in Figure 1, is given by the mean of the pressures on the model half levels immediately above and below:
Illustrations of model levels, model half levels and model layers
Figure 1. An illustration of IFS model levels, showing how they follow the terrain near the surface of the Earth. Level=1 is near the top of the atmosphere and Level=137 is near the surface of the Earth. The left hand axes are altitude (km) and pressure (hPa), while the right hand axis is level number.
Figure 2. An illustration of model half-levels and model layers. The pressure on model levels is in the middle of the layers defined by the model half levels. The uppermost layer is adjacent to the top of the atmosphere (where p=0), while the lowest layer is adjacent to the surface of the Earth (where p=sp).
Geopotential on model levels
In ERA5, geopotential (z) is provided at the surface, but not on individual model levels. However, geopotential on model levels can be computed using the procedure described below.
Inputs:
geopotential at the surface
logarithm of surface pressure (lnsp)
temperature and specific humidity on all the model levels
Output: Geopotential for each level, in m2/s2.
In the procedure below, the output data is written in GRIB format.
Please note, this procedure is an approximation to the calculation performed in the IFS (which also takes account of the effects of cloud ice and water and rain and snow).
Prerequisites to calculating Geopotential on model levels
You will need:
A computer running Linux
Python3
The CDS API installed; Your computer must be set up for downloading ERA5 model level data (from the 'reanalysis-era5-complete' dataset, stored in ECMWF's MARS catalogue) through the CDS API. For more details, please follow the instructions here (step B).
First we must retrieve the required ERA5 data. We need:
Temperature (t) and specific humidity (q) on each model level.
The logarithm of surface pressure (lnsp) and geopotential (z) on model level 1.
We use a Python script to download the ERA5 data from the MARS catalogue using the CDS API. The procedure is:
Copy the script below to a text editor on your computer
Edit the date, type, step, time, grid and area in the script to meet your requirements
Save the script (for example with the filename as 'get_data_geopotential_on_ml.py')
Run the script
Python script to download ERA5 data NOT listed in CDS through CDS APIExpand source
#!/usr/bin/env python
import cdsapi
c = cdsapi.Client()
# data download specifications:
cls = "ea" # do not change
expver = "1" # do not change
levtype = "ml" # do not change
stream = "oper" # do not change
date = "2018-01-01" # date: Specify a single date as "2018-01-01" or a period as "2018-08-01/to/2018-01-31". For periods > 1 month see https://software.ecmwf.int/wiki/x/l7GqB
tp = "an" # type: Use "an" (analysis) unless you have a particular reason to use "fc" (forecast).
time = "00:00:00" # time: ERA5 data is hourly. Specify a single time as "00:00:00", or a range as "00:00:00/01:00:00/02:00:00" or "00:00:00/to/23:00:00/by/1".
c.retrieve('reanalysis-era5-complete', {
'class' : cls,
'date' : date,
'expver' : expver,
'levelist': '1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43/44/45/46/47/48/49/50/51/52/53/54/55/56/57/58/59/60/61/62/63/64/65/66/67/68/69/70/71/72/73/74/75/76/77/78/79/80/81/82/83/84/85/86/87/88/89/90/91/92/93/94/95/96/97/98/99/100/101/102/103/104/105/106/107/108/109/110/111/112/113/114/115/116/117/118/119/120/121/122/123/124/125/126/127/128/129/130/131/132/133/134/135/136/137', # For each of the 137 model levels
'levtype' : 'ml',
'param' : '130/133', # Temperature (t) and specific humidity (q)
'stream' : stream,
'time' : time,
'type' : tp,
'grid' : [1.0, 1.0], # Latitude/longitude grid: east-west (longitude) and north-south resolution (latitude). Default: 0.25 x 0.25
'area' : area, #example: [60, -10, 50, 2], # North, West, South, East. Default: global
}, 'tq_ml.grib')
c.retrieve('reanalysis-era5-complete', {
'class' : cls,
'date' : date,
'expver' : expver,
'levelist': '1', # Geopotential (z) and Logarithm of surface pressure (lnsp) are 2D fields, archived as model level 1
'levtype' : levtype,
'param' : '129/152', # Geopotential (z) and Logarithm of surface pressure (lnsp)
'stream' : stream,
'time' : time,
'type' : tp,
'grid' : [1.0, 1.0], # Latitude/longitude grid: east-west (longitude) and north-south resolution (latitude). Default: 0.25 x 0.25
'area' : area, #example: [60, -10, 50, 2], # North, West, South, East. Default: global
}, 'zlnsp_ml.grib')
Running the script produces two new files in the current working directory:
'tq_ml.grib' (a GRIB file containing temperature and specific humidity)
'zlnsp_ml.grib' (a GRIB file containing geopotential and log of surface pressure).
Step 2: Compute geopotential on model levels
We then use a Python script to compute geopotential (z) for all model levels:
Copy the script below to a text editor
Save the script as 'compute_geopotential_on_ml.py'
Run the script 'compute_geopotential_on_ml.py' with the correct arguments, i.e. : python compute_geopotential_on_ml.py tq_ml.grib zlnsp_ml.grib -o z_on_ml.grib
#!/usr/bin/env python3
'''
Copyright 2023 ECMWF.
This software is licensed under the terms of the Apache Licence Version 2.0
which can be obtained at http://www.apache.org/licenses/LICENSE-2.0
In applying this licence, ECMWF does not waive the privileges and immunities
granted to it by virtue of its status as an intergovernmental organisation
nor does it submit to any jurisdiction.
**************************************************************************
Function : compute_geopotential_on_ml
Author (date) : Cristian Simarro (09/10/2015)
modified: Cristian Simarro (20/03/2017) - migrated to eccodes
Xavi Abellan (03/12/2018) - compatibilty with Python 3
Xavi Abellan (27/03/2020) - Corrected steps in output file
Xavi Abellan (05/08/2020) - Better handling of levels
Xavi Abellan (31/01/2023) - Better handling of steps
Category : COMPUTATION
OneLineDesc : Computes geopotential on model levels
Description : Computes geopotential on model levels.
Based on code from Nils Wedi, the IFS documentation:
https://software.ecmwf.int/wiki/display/IFS/CY41R1+Official+IFS+Documentation
part III. Dynamics and numerical procedures
optimised implementation by Dominique Lucas.
ported to Python by Cristian Simarro
Parameters : tq.grib - grib file with all the levelist
of t and q
zlnsp.grib - grib file with levelist 1 for params
z and lnsp
-l levelist (optional) - slash '/' separated list of levelist
to store in the output
-o output (optional) - name of the output file
(default='z_out.grib')
Return Value : output (default='z_out.grib')
A fieldset of geopotential on model levels
Dependencies : None
Example Usage :
compute_geopotential_on_ml.py tq.grib zlnsp.grib
'''
from __future__ import print_function
import sys
import argparse
import numpy as np
from eccodes import (codes_index_new_from_file, codes_index_get, codes_get,
codes_index_select, codes_new_from_index, codes_set,
codes_index_add_file, codes_get_array, codes_get_values,
codes_index_release, codes_release, codes_set_values,
codes_write)
R_D = 287.06
R_G = 9.80665
def parse_args():
''' Parse program arguments using ArgumentParser'''
parser = argparse.ArgumentParser(
description='Python tool to calculate the Z of the model levels')
parser.add_argument('-l', '--levelist', help='levelist to store',
default='all')
parser.add_argument('-o', '--output', help='name of the output file',
default='z_out.grib')
parser.add_argument('t_q', metavar='tq.grib', type=str,
help=('grib file with temperature(t) and humidity(q)'
'for the model levels'))
parser.add_argument('z_lnsp', metavar='zlnsp.grib', type=str,
help=('grib file with geopotential(z) and Logarithm'
'of surface pressure(lnsp) for the ml=1'))
args = parser.parse_args()
# Handle levelist posibilities
if args.levelist == 'all':
args.levelist = range(1, 138)
elif "to" in args.levelist.lower():
if "by" in args.levelist.lower():
args.levelist = args.levelist.split('/')
args.levelist = list(range(int(args.levelist[0]),
int(args.levelist[2]) + 1,
int(args.levelist[4])))
else:
args.levelist = args.levelist.split('/')
args.levelist = list(range(int(args.levelist[0]),
int(args.levelist[2]) + 1))
else:
args.levelist = [int(l) for l in args.levelist.split('/')]
return args
def main():
'''Main function'''
args = parse_args()
print('Arguments: %s' % ", ".join(
['%s: %s' % (k, v) for k, v in vars(args).items()]))
fout = open(args.output, 'wb')
index_keys = ['date', 'time', 'shortName', 'level', 'step']
idx = codes_index_new_from_file(args.z_lnsp, index_keys)
codes_index_add_file(idx, args.t_q)
if 'u_v' in args:
codes_index_add_file(idx, args.u_v)
values = None
# iterate date
for date in codes_index_get(idx, 'date'):
codes_index_select(idx, 'date', date)
# iterate time
for time in codes_index_get(idx, 'time'):
codes_index_select(idx, 'time', time)
for step in codes_index_get(idx, 'step'):
codes_index_select(idx, 'step', step)
if not values:
values = get_initial_values(idx, keep_sample=True)
if 'height' in args:
values['height'] = args.height
values['gh'] = args.height * R_G + values['z']
if 'levelist' in args:
values['levelist'] = args.levelist
# surface pressure
try:
values['sp'] = get_surface_pressure(idx)
production_step(idx, step, values, fout)
except WrongStepError:
if step != '0':
raise
try:
codes_release(values['sample'])
except KeyError:
pass
codes_index_release(idx)
fout.close()
def get_initial_values(idx, keep_sample=False):
'''Get the values of surface z, pv and number of levels '''
codes_index_select(idx, 'level', 1)
codes_index_select(idx, 'shortName', 'z')
gid = codes_new_from_index(idx)
values = {}
# surface geopotential
values['z'] = codes_get_values(gid)
values['pv'] = codes_get_array(gid, 'pv')
values['nlevels'] = codes_get(gid, 'NV', int) // 2 - 1
check_max_level(idx, values)
if keep_sample:
values['sample'] = gid
else:
codes_release(gid)
return values
def check_max_level(idx, values):
'''Make sure we have all the levels required'''
# how many levels are we computing?
max_level = max(codes_index_get(idx, 'level', int))
if max_level != values['nlevels']:
print('%s [WARN] total levels should be: %d but it is %d' %
(sys.argv[0], values['nlevels'], max_level),
file=sys.stderr)
values['nlevels'] = max_level
def get_surface_pressure(idx):
'''Get the surface pressure for date-time-step'''
codes_index_select(idx, 'level', 1)
codes_index_select(idx, 'shortName', 'lnsp')
gid = codes_new_from_index(idx)
if gid is None:
raise WrongStepError()
if codes_get(gid, 'gridType', str) == 'sh':
print('%s [ERROR] fields must be gridded, not spectral' % sys.argv[0],
file=sys.stderr)
sys.exit(1)
# surface pressure
sfc_p = np.exp(codes_get_values(gid))
codes_release(gid)
return sfc_p
def get_ph_levs(values, level):
'''Return the presure at a given level and the next'''
a_coef = values['pv'][0:values['nlevels'] + 1]
b_coef = values['pv'][values['nlevels'] + 1:]
ph_lev = a_coef[level - 1] + (b_coef[level - 1] * values['sp'])
ph_levplusone = a_coef[level] + (b_coef[level] * values['sp'])
return ph_lev, ph_levplusone
def compute_z_level(idx, lev, values, z_h):
'''Compute z at half & full level for the given level, based on t/q/sp'''
# select the levelist and retrieve the vaules of t and q
# t_level: values for t
# q_level: values for q
codes_index_select(idx, 'level', lev)
codes_index_select(idx, 'shortName', 't')
gid = codes_new_from_index(idx)
if gid is None:
raise MissingLevelError('T at level {} missing from input'.format(lev))
t_level = codes_get_values(gid)
codes_release(gid)
codes_index_select(idx, 'shortName', 'q')
gid = codes_new_from_index(idx)
if gid is None:
raise MissingLevelError('Q at level {} missing from input'.format(lev))
q_level = codes_get_values(gid)
codes_release(gid)
# compute moist temperature
t_level = t_level * (1. + 0.609133 * q_level)
# compute the pressures (on half-levels)
ph_lev, ph_levplusone = get_ph_levs(values, lev)
if lev == 1:
dlog_p = np.log(ph_levplusone / 0.1)
alpha = np.log(2)
else:
dlog_p = np.log(ph_levplusone / ph_lev)
alpha = 1. - ((ph_lev / (ph_levplusone - ph_lev)) * dlog_p)
t_level = t_level * R_D
# z_f is the geopotential of this full level
# integrate from previous (lower) half-level z_h to the
# full level
z_f = z_h + (t_level * alpha)
# z_h is the geopotential of 'half-levels'
# integrate z_h to next half level
z_h = z_h + (t_level * dlog_p)
return z_h, z_f
def production_step(idx, step, values, fout):
'''Compute z at half & full level for the given level, based on t/q/sp'''
# We want to integrate up into the atmosphere, starting at the
# ground so we start at the lowest level (highest number) and
# keep accumulating the height as we go.
# See the IFS documentation, part III
# For speed and file I/O, we perform the computations with
# numpy vectors instead of fieldsets.
z_h = values['z']
codes_set(values['sample'], 'step', int(step))
for lev in sorted(values['levelist'], reverse=True):
try:
z_h, z_f = compute_z_level(idx, lev, values, z_h)
# store the result (z_f) in a field and add to the output
codes_set(values['sample'], 'level', lev)
codes_set_values(values['sample'], z_f)
codes_write(values['sample'], fout)
except MissingLevelError as e:
print('%s [WARN] %s' % (sys.argv[0], e),
file=sys.stderr)
class WrongStepError(Exception):
''' Exception capturing wrong step'''
pass
class MissingLevelError(Exception):
''' Exception capturing missing levels in input'''
pass
if __name__ == '__main__':
main()
Alternatively, there is a customer-supplied script (which runs on Microsoft Windows) that computes geopotential on model levels for a specific location. This script was written for the ERA-Interim dataset, but can be adapted to ERA5. Please see the article ERA-Interim: compute geopotential on model levels for details.
In ERA5, and often in meteorology, heights (the height of the land and sea surface, or specific heights in the atmosphere) are not represented as geometric height, or altitude (in metres above the spheroid), but as geopotential height (in metres above the geoid, which is represented by the mean sea level in ERA5). Note, that ECMWF usually archive the geopotential (in m2/s2), not the geopotential height.
To obtain the geopotential height (h) in metres (of the land and sea surface or at particular heights in the atmosphere), simply divide the geopotential by the Earth's gravitational acceleration, which has a fixed value of 9.80665 m/s2 in the IFS. This geopotential height is relative to mean sea level - for more information see ERA5: data documentation.
The geometric height or altitude (alt) is given by:
\[ alt = Re \ast h/(Re-h) \]
where Re is the radius of the Earth. Note, this geometric height is relative to mean sea level and it is assumed that the Earth is a perfect sphere - for more information see ERA5: data documentation - spatial reference systems.
This document has been produced in the context of the Copernicus Climate Change Service (C3S).
The activities leading to these results have been contracted by the European Centre for Medium-Range Weather Forecasts, operator of C3S on behalf of the European Union (Delegation agreement signed on 11/11/2014). All information in this document is provided "as is" and no guarantee or warranty is given that the information is fit for any particular purpose.
The users thereof use the information at their sole risk and liability. For the avoidance of all doubt, the European Commission and the European Centre for Medium-Range Weather Forecasts have no liability in respect of this document, which is merely representing the author's view.
