This python package contains three (3) algorithms/models for estimating WBGT from standard, widely available meteorological variables. The algorithms/models come from the following papers:

Liljegren, J. C., Carhart, R. A., Lawday, P., Tschopp, S., & Sharp, R. (2008). Modeling the wet bulb globe temperature using standard meteorological measurements. Journal of occupational and environmental hygiene, 5(10), 645-655.
Dimiceli, V. E., Piltz, S. F., & Amburn, S. A. (2013). Black globe temperature estimate for the WBGT index. In IAENG Transactions on Engineering Technologies (pp. 323-334). Springer, Dordrecht.
Bernard, T. E., & Pourmoghani, M. (1999). Prediction of workplace wet bulb global temperature. Applied occupational and environmental hygiene, 14(2), 126–134. https://doi.org/10.1080/104732299303296

[TOC]

Installation

This package depends on some C/Cython modules; namely the Liljegren and Bernard methods and the National Renewable Energy Laboratory (NREL) Solar Position Algorithm (SPA; Reda and Andreas 2003). These codes are bundled with this package and should compile during installation.

For these to be compiled/installed, a C compiler must be installed on your system. The Cython wrappers for the C-codes are designed to take advantage of multi-core CPUs. For this to work, the OpenMP library is required and can be installed using your preferred package manager.

To actually install the package, cd into this directory and run the following command

pip install ./

If you must specify the path to your C-compiler and/or OpenMP installations, you can use the CC, CFLAGS, and LDFLAGS environmental variables to specify paths. For example

CC=/path/to/gcc CFLAGS=-I/path/to/include LDFLAGS=-L/path/to/lib pip install ./

Or, these can be exported before running pip

export CC=/path/to/gcc
export CFLAGS=-I/path/to/include
export LDFLAGS=-L/path/to/lib
pip install ./

Advanced Option

As some of the code in this package is dependant on Cython, some program files must be 'cythonized' into C-code before they can be fully compiled. For ease of use, both the source (.pyx) and cythonized (.c) versions of the files are provided in the repo/distribution, with the cythonized files being used during installation. It is possible to re-cythonize the source files using the following command:

python3 setup.py build_ext

After this, the standard pip install ./ command can be run to install the package using the new, re-cythonized files.

Note that this re-cythonizing step is necessary when making changes to any of the source Cython files because the install script only compiles the .c files. So, if the .pyx files are not run through Cython after making changes, none of the changes will appear in the installed package.

Also note that Cython 3+ must be installed for this to work, as it is not installed as part of this package.

Using the package

This package includes codes a few algorithms for estimating wetbulb temperature and natural wetbulb temperature that are not associated with the three main WBGT algorithms. Codes for adjusting wind speeds to given heights above ground level are also included. The NREL SPA code is also provided as part of this package.

Then, there are the three modules that provide the WBGT algorithms, which are provided as a mix of pure python and Cython wrappers for C codes. These modules include the main WBGT functions along with various other helper functions associated with the algorithms. A main wbgt function provides a simple API for calling any of the three WBGT algorithms by specifying the algorithm via string and providing the required meteorological parameters.

Example

from pywbgt import wbgt
vals = wbgt(
    dates,
    latitudes,
    longitudes,
    solar,
    pres,
    temp_air,
    temp_dew,
    speed,
    method='liljegren',
)

Input Variables and Unit Handling

There are a large number of input parameters that are required for running the various WBGT algorithms. These are outlined in the below table:

Variable	Units	Description
datetime	various	Datetime of observation as pandas DatetimeIndex object
Latitude	degrees North	Latitude of observation; positive North
Longitude	degrees East	Longitude of observation; positive East
solar	various	Solar irradiance; Quantity
pres	various	Barometric pressure; Quantity
temp_air	various	Ambient (dry bulb) temperature; Quantity
temp_dew	various	Dew point temperature; Quantity
speed	various	Wind speed; Quantity

Variables with 'various' units must be pint.Quantity objects for seamless unit conversion. As the WBGT algorithms require different units for input arguments, making these argument unit aware takes some burden off the end-user and moves unit conversions into the functions. Units can be specified using the metpy.units sub-package, which is installed as a dependency of this package. For example, to tag air temperature values with units of Kelvin, one could do:

from metpy.units import units
temp_air = units.Quantity([283, 293], 'K')

Or, using a numpy array:

import numpy as np
from metpy.units import units
temp_air = np.asarray([283, 293]) * units('K')

All the user needs to know is the units of their data and all conversions for the algorithms are done by the algorithms. Values returned from the algorithms are also pint.Quanity objects so that the user knows the units for the values.

Keyword Arguments:

There are various keywords associated with three main WBGT algorithms that control different aspects of the algorithms. The most relevant for most users will be the zspeed keyword, which sets the height at which the wind measurement was taken as a unit aware (i.e., pint.Quantity) value. This is important because the WBGT algorithms estimate the 2 meter wind speed for use in their WBGT estimates. As most weather stations measure wind at 10 meters, this is the default value for the keyword. However, if the station makes the measurement at 3 feet, then setting the keyword will ensure that the wind speed is adjusted properly to the 2 meter height. For example:

from metpy.units import units
from pywbgt import wbgt
vals = wbgt(datetime, lat, lon, ..., method='liljegren', zspeed=units.Quantity(3, 'ft'))

Another useful keyword argument is min_speed, wherein the minimum speed allowed for the 2m-adjusted wind speeds is set. After adjusting wind speeds to 2m height, this value is use to clip the wind speeds so that none are below this value. By default, min_speed = Quantity(2.0, 'knot') as ASOS stations report any wind speed of <= 2 knots as calm. This value can be overridden to the extent possible by the various algorithms. For example, there is a hard minimum speed of 1690 m/hr (~1 mph) for the Dimiceli method and 0.13 m/s for the Liljegren method. If a user inputs a value for min_speed less than either of these values, the user input is overridden and the hard limit used. Data dictionaries returned by the methods include a min_speed key/value pair indicating the value used in the algorithm. Note that this value must be a unit-aware object.

For more information about other keyword arguments, please refer to the function docstrings.

Xarray Support

Support for Xarray has been improved, with support for passing in a single Dataset containing all requred variables I have also implemented N-D suport, with reording of data handled internally in the package for computation; this is invisible to the user.

One limitation that still exists is lazy computation; all data is loaded before any computation occurs.

For data variable naming within the Dataset, the datetime, latitude, and longitude variables MUST have CF-compliant axis attributes (e.g., {'axis': 'X'} for longitude). This is done to ensure time and location values are parsed correctly regardless of name. For all other inputs (see table above), the variable in the Dataset MUST match the argument name.

An example of this process is outlined below:

import xarray as xr
from metpy.calc import wind_speed

dataset  = xr.open_dataset('/path/to/file.nc')

# Ensure that coordinates have proper axis attrs
dataset['time'].attrs['axis'] = 'T'
dataset['latitude'].attrs['axis'] = 'Y'
dataset['longitude'].attrs['axis'] = 'X'

# Ensure variables are named correctly and we have wind speed
dataset = dataset.rename(
    ssrd='solar',
    sp='pres',
    t2m='temp_air',
    d2m='temp_dew',
).assign(
    speed=wind_speed(dataset.u10, dataset.v10),
)

wetbulb_data = wbgt(
    dataset,
    method='dimiceli',
)

One major point to note is that the wind speed will likely need to be calculated from u- and v-components. To do this, use the metpy.calc.wind_speed() function to maintain unit information.

If working with accumlated fields (e.g., downward solar radation from a model or reanalysis), some 'unit trickery' may be required. For example, in the ERA5-Land dataset, solar radiation is accumlated over a given interval as denoted by the step variable in the grib files. This means the data are in units of Joules / m**2. To get to Watt/m**2 units we can do the following:

ssrd = (
    dataset.ssrd.metpy.quantify() /
    (dataset.step.dt.seconds*units('second'))
)

This ensures that the ssrd DataArray is explicitly tagged with units using the .metpy.quantify() method and then is divided by the accumulation time in seconds. It is important to note that this will give the average radiation over the entire accumulation period NOT the instanteous value measured at the given model/reanalysis time step.

Support for `map_blocks`

This is a very powerful function/method that enables lazy/delayed compute of WBGT values. Using the example Dataset from above, we can call:

wetbulb_data = dataset.map_blocks(wbgt, kwargs={'method': 'liljegren'})

where wbgt is the function to apply over blocks of data and kwargs enables passing keyword arguments to the function. This will take data one block (or chunk) at a time and pass it into the function for computation. See the map_blocks documentation for more information.

Solar position calculations

The Liljegren code provides an algorithm for calculating solar position parameters; however, the algorithm is only valid from 1950 to 2050. To get around this limiation, the Python pvlib package is used to calculate the solar position using their implementation of the National Renewable Energy Laboratory Solar Postition Algorithm (SPA). The Python implementation of the SPA code is combined with the solar parameters code of the Liljegren algorithm to create a hybrid function for calculating the adjusted solar irradiance, cosine of solar zenith angle, and fraction of direct beam radiation. This new solar_parameters() function is used in all the included algorithms to compute the parameters requried to estimate WBGT.

Updates

There have been some updates to the solar position calculations! The numba dependency has been removed and some of the pvlib.spa code has been ported/updated to enable array multiplication and summing for fast computation. There is no need to iterate over locations now, with everything handled through reshaping and broadcasting mechanics.

Comparative tests for computation of cza using the native pvlib.spa code and the numba and new numpy based methods yields values within 7 decimals of each other, idicating everything is working properly. However, there are some very small differences in cza values, which lead to some updates to unittests to account for these very minor changes. Note that unit tests were failing out at 7-8 decimals of percision, so that was very minimal impact with these changes.

Notes on the algorithms

Liljegren et al.

The most robust algorithm with explicit calculation of many aspects of the WBGT, this has been the de facto standard for WBGT computation. One limitation of this algorithm is that the included code for estimating solar position is most accurate for dates between 1950 to 2050. As previously mentioned, this is overriden by the pvlib SPA implemenation and augmented code for computing the solar parameters.

Dimiceli et al.

In the Dimiceli paper, they provide an equation for calculating the convective heat transfer coefficient; however, the constants a, b, and c are not provided. In another paper by Dimiceli and Piltz a constant value of h = 0.315 is recommended. Liljegren et al. (2008) does provide a formula/function to estimate this value that could be used in the Dimiceli method; this is an option I should code into the Dimiceli method (use the constant, use Dimiceli function if can get their formula working, or use the Liljegren method).

Limitations

The Dimiceli has a limitation around wind speed: when wind speeds are below 1 mile per hour, globe temperatures become exponentially large. To get around this limitation, wind speeds are clamped to be at least 1 mile per hour. As the code needs wind speeds in meters per hour, the minimum value (after conversion) for wind speed is 1690.0 meters/hour.

A second limitation is that no formula for the natural wet bulb temperature is provided. Two algorithms for computing the natural wet bulb temperature are included to address this limitation: Malchaire (1976) and Hunter and Minyard (1999) Either of these algorithms can be selected when running the Dimiceli method.

After some testing, it was discovered that the psychrometric wet bulb algorithm provided by the Dimiceli method was not the most accurate. This has been addressed by providing the option to use the Stull (2011) algorithm instead of the Dimiceli wet bulb algorithm.

By default the Dimiceli wet bulb and the Malchaire natural wet bulb algorithms are used.

Bernard and Pourmoghani

The Bernard method focused on indoor WBGT, so there is no discussion of globe temperature estimation methods. Thus, the method outlined in the article has been modified to include solar radiation as a source in the calculations. This is done using an approach similar to that of Liljegren et al. (2008), using an iterative approach to determine black globe temperature.

References

Liljegren, J. C., Carhart, R. A., Lawday, P., Tschopp, S., & Sharp, R. (2008). Modeling the wet bulb globe temperature using standard meteorological measurements. Journal of occupational and environmental hygiene, 5(10), 645-655.
Dimiceli, V. E., Piltz, S. F., & Amburn, S. A. (2013). Black globe temperature estimate for the WBGT index. In IAENG Transactions on Engineering Technologies (pp. 323-334). Springer, Dordrecht.
Dimiceli, V. E., & Piltz, S. F., Estimation of Black Globe Temperature for Calculation of the WBGT Index. https://www.weather.gov/media/tsa/pdf/WBGTpaper2.pdf
Bernard, T. E., & Pourmoghani, M. (1999). Prediction of workplace wet bulb global temperature. Applied occupational and environmental hygiene, 14(2), 126–134. https://doi.org/10.1080/104732299303296
Malchaire, J. B., (1976) EVALUATION OF NATURAL WET BULB AND WET GLOBE THERMOMETERS. The Annals of Occupational Hygiene, Volume 19, Issue 3-4, December 1976, Pages 251–258, https://doi.org/10.1093/annhyg/19.3-4.251
Hunter, Charles H., and C. Olivia Minyard. (1999) Estimating wet bulb globe temperature using standard meteorological measurements." Proceedings of the Conference: 2nd Conference on Environmental Applications, Long Beach, CA, USA. Vol. 18. 1999.
Stull, R. (2011). Wet-Bulb Temperature from Relative Humidity and Air Temperature, Journal of Applied Meteorology and Climatology, 50(11), 2267-2269. Retrieved Jul 20, 2022, from https://journals.ametsoc.org/view/journals/apme/50/11/jamc-d-11-0143.1.xml
Reda, I. and Andreas, A. (2003). Solar Position Algorithm for Solar Radiation Applications. 55 pp.; NREL Report No. TP-560-34302, Revised January 2008.

NCICS/CICSNC K. R. Wodzicki 2023

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

pywbgt-3.0.7.tar.gz (798.7 kB view details)

Uploaded Jul 22, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

pywbgt-3.0.7-cp312-cp312-win_amd64.whl (1.1 MB view details)

Uploaded Jul 22, 2026 CPython 3.12Windows x86-64

pywbgt-3.0.7-cp312-cp312-win32.whl (1.0 MB view details)

Uploaded Jul 22, 2026 CPython 3.12Windows x86

pywbgt-3.0.7-cp312-cp312-manylinux_2_28_x86_64.whl (2.8 MB view details)

Uploaded Jul 22, 2026 CPython 3.12manylinux: glibc 2.28+ x86-64

pywbgt-3.0.7-cp312-cp312-manylinux_2_28_aarch64.whl (2.7 MB view details)

Uploaded Jul 22, 2026 CPython 3.12manylinux: glibc 2.28+ ARM64

pywbgt-3.0.7-cp312-cp312-macosx_14_0_arm64.whl (1.3 MB view details)

Uploaded Jul 22, 2026 CPython 3.12macOS 14.0+ ARM64

pywbgt-3.0.7-cp311-cp311-win_amd64.whl (1.1 MB view details)

Uploaded Jul 22, 2026 CPython 3.11Windows x86-64

pywbgt-3.0.7-cp311-cp311-win32.whl (1.0 MB view details)

Uploaded Jul 22, 2026 CPython 3.11Windows x86

pywbgt-3.0.7-cp311-cp311-manylinux_2_28_x86_64.whl (2.8 MB view details)

Uploaded Jul 22, 2026 CPython 3.11manylinux: glibc 2.28+ x86-64

pywbgt-3.0.7-cp311-cp311-manylinux_2_28_aarch64.whl (2.8 MB view details)

Uploaded Jul 22, 2026 CPython 3.11manylinux: glibc 2.28+ ARM64

pywbgt-3.0.7-cp311-cp311-macosx_14_0_arm64.whl (1.3 MB view details)

Uploaded Jul 22, 2026 CPython 3.11macOS 14.0+ ARM64

pywbgt-3.0.7-cp310-cp310-win_amd64.whl (1.1 MB view details)

Uploaded Jul 22, 2026 CPython 3.10Windows x86-64

pywbgt-3.0.7-cp310-cp310-win32.whl (1.0 MB view details)

Uploaded Jul 22, 2026 CPython 3.10Windows x86

pywbgt-3.0.7-cp310-cp310-manylinux_2_28_x86_64.whl (2.7 MB view details)

Uploaded Jul 22, 2026 CPython 3.10manylinux: glibc 2.28+ x86-64

pywbgt-3.0.7-cp310-cp310-manylinux_2_28_aarch64.whl (2.7 MB view details)

Uploaded Jul 22, 2026 CPython 3.10manylinux: glibc 2.28+ ARM64

pywbgt-3.0.7-cp310-cp310-macosx_14_0_arm64.whl (1.3 MB view details)

Uploaded Jul 22, 2026 CPython 3.10macOS 14.0+ ARM64

File details

Details for the file pywbgt-3.0.7.tar.gz.

File metadata

Download URL: pywbgt-3.0.7.tar.gz
Upload date: Jul 22, 2026
Size: 798.7 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/6.1.0 CPython/3.13.14

File hashes

Hashes for pywbgt-3.0.7.tar.gz
Algorithm	Hash digest
SHA256	`91910aa2139f49c7bfbc2a08eda70db8e7b9d15cb5c0c53201c52df08bfff3e1`
MD5	`64370f40a8826e65b87f5e41df50b208`
BLAKE2b-256	`016fcc261ff2b29b58f8ce9455f2d86d25ef67437d8d7ee6211fe6e5954b59e2`

Algorithm	Hash digest
SHA256	`b662376fc91c0a4a2ab75c521e9e74c37bb7761e4d1d27dfa9028498d9c5e4e8`
MD5	`b2bde895a549503e09a3a6c3f43f539f`
BLAKE2b-256	`613b4a805c9513db29c3cabcbf8ccae3380279827a9096fbb6143d71f1623e35`

Algorithm	Hash digest
SHA256	`0b47f61816c11f08fc0f35734fb28c2f71353ce1769b8d7c4b0b5a5f6f135141`
MD5	`e2258fac0f3c356ca0e25df2b6798533`
BLAKE2b-256	`489aa73ce67fdd4627119aa661c13395e4a4a164411813361615238fff474ed1`

Algorithm	Hash digest
SHA256	`34166e73ebce44177effa942132f05933fff2f33397a5c4856b60ea89c131233`
MD5	`3f719fdf7fa8b7f702bd1630e83fa0f0`
BLAKE2b-256	`d9a8957cb585af12e40c27bdbf01e5f9f4fa489e5d6918d4ac281ffefd0756cf`

Algorithm	Hash digest
SHA256	`ed9e287627dc251682c5f159f3a21b9c618b4ecdf8d72bdd0d6292804cb41fe4`
MD5	`6503bdac56f48318ca33fa7fa9233fa6`
BLAKE2b-256	`ec37cab10f6b5fbe0588f19ace16335a15b9da641cda681d8a95190c9ef461b6`

Algorithm	Hash digest
SHA256	`427cbc2a9aa70c24cd6ab25dcc8840792f1917b76e5bf79dab427e9ca298c96a`
MD5	`5149356573e3bfef2dd13e25dea3ceec`
BLAKE2b-256	`acfa2264d3650fdcf0672a8d01b52a8c1d938fe6d3dd3e0de0cdaf40f1e11378`

Algorithm	Hash digest
SHA256	`d5e03d9b5d07052b74c147a9f999e351fbd63ae9363f758f35d2d54290d3f3cf`
MD5	`9e674e2899c6457b88d9573fb5026f73`
BLAKE2b-256	`0b4cd269e1d7512e61cce3e6df53309fe9235a2823d723512d668cfc9a39db24`

Algorithm	Hash digest
SHA256	`60cf51b893b9617b4c5d780a4655dbecb1fc76e8a6f68e653f16785cc7535c93`
MD5	`035480df316cab01bab2dbc8c18a193c`
BLAKE2b-256	`f7600f2e778d780c6041b729e6fec7fa91673c8e838dfae2a11fee94d31b33a6`

Algorithm	Hash digest
SHA256	`178cd1f779a6fff984f069e0ea7a6de2de199cdb13497aa46216300f57be8cdf`
MD5	`989708a40611e9839e1a487cedd6da1d`
BLAKE2b-256	`9539c18b841a49f6f0826a19c9652e02745fe69cfae5c9e272c8cc8a995ae636`

Algorithm	Hash digest
SHA256	`38002ef110662aef30fd61b0232385af4785306a09298328ac2dde3db183a4de`
MD5	`74634a49e726a1e2c9f1dcd060335880`
BLAKE2b-256	`067578ea2bb61ee3e2acf0cac1d2b67ce1b622595558d7ab577c24de3add7ea7`

Algorithm	Hash digest
SHA256	`9fe1dc815e99b416b6a4dd091a6529fcfd5dc4a2882277972488b935f7f8ea53`
MD5	`7967299818135d8fffff014d6a7586b6`
BLAKE2b-256	`a912e239ab1c65b78eab32951dcd2eb4279e71567327fb3a32e719a7faefea79`

Algorithm	Hash digest
SHA256	`751ac66e8def2a2d7e644d4ba8b894a6229eb9c6c82e63f081a4aebdad509b46`
MD5	`511de3476e561c62105c7cceb3a4507a`
BLAKE2b-256	`13e637f884f993d4a326dece7e42ed68c41f94bddbbc621a493fa3b1f79366c0`

Algorithm	Hash digest
SHA256	`95bb4e2ba687aa93aeef4c1c8a3c27cb482c40c1ee0b61a684d88645a2dfa154`
MD5	`fc591c103e23d325ac3c6b35346189c2`
BLAKE2b-256	`71410bab7d70ffe3d3a496481e77d450ecfa270e3ee46cf69b0076177e32db96`

Algorithm	Hash digest
SHA256	`a6fe6404c4f779a3fc71b051f869ae39adcf2ebfafe52d7662eecc1687245d64`
MD5	`249c014f13f0115018515ad68d18b0b9`
BLAKE2b-256	`9fa240292af83c54b57e3bb7066203487b2fa826b94e104a2a9dd373cd9d6c9c`

Algorithm	Hash digest
SHA256	`9e05137bce6e1d1893746a702dc39e1ba84fbbff8ce57a05aeb2c1b801e26053`
MD5	`bb486b87f7b75c4db46def0b0bf204f9`
BLAKE2b-256	`51ef8c0691440354d9b4984b8c33f26409897deaea7a4ad58fbc0e321c349985`

Algorithm	Hash digest
SHA256	`3efb868f7fa3f843522f0ccd364761f6bcaec943bb65c1569d90effe544dd01a`
MD5	`2a256c5699268a56b071c38d97890f58`
BLAKE2b-256	`f8f3ca187d7bee6a37099698143b8ab4652f7d6d7a9aa0e7c8dae6391765ee94`

pywbgt 3.0.7

Table of Contents

Installation

Advanced Option

Using the package

Example

Input Variables and Unit Handling

Keyword Arguments:

Xarray Support

Support for map_blocks

Solar position calculations

Updates

Notes on the algorithms

Liljegren et al.

Dimiceli et al.

Limitations

Bernard and Pourmoghani

References

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

Requires

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

Support for `map_blocks`