def get_message(
data_path,
parameter,
level,
level_type="isobaricInhPa",
):
if parameter == "wind":
u_message, v_message = get_wind_message(
data_path=data_path,
level=level,
level_type=level_type,
)
message = eccodes.codes_clone(u_message)
u_array = eccodes.codes_get_double_array(u_message, "values")
v_array = eccodes.codes_get_double_array(v_message, "values")
w_array = np.sqrt(u_array * u_array + v_array * v_array)
eccodes.codes_release(u_message)
eccodes.codes_release(v_message)
eccodes.codes_set_double_array(message, "values", w_array)
else:
message = load_message_from_file(file_path=data_path,
parameter=parameter,
level_type=level_type,
level=level)
return message
def get_gids_for_grib_intertable(self):
# returns gids of messages to use to create interpolation tables
val = codes_get_double_array(self._gid_main_res, 'values')
val2 = None
if self._gid_ext_res:
val2 = codes_get_double_array(self._gid_ext_res, 'values')
return self._gid_main_res, val, self._gid_ext_res, val2
def latlons(self):
# this method is called only for scipy interpolation
if self._lats is None:
self._log('Fetching coordinates from grib file')
self._lats = eccodes.codes_get_double_array(self._gid, 'latitudes')
self._longs = eccodes.codes_get_double_array(
self._gid, 'longitudes')
return self._lats, self._longs
def get(self, name):
try:
if name == "values":
return eccodes.codes_get_values(self.handle)
if name in ("distinctLatitudes", "distinctLongitudes"):
return eccodes.codes_get_double_array(self.handle, name)
return eccodes.codes_get(self.handle, name)
except eccodes.KeyValueNotFoundError:
return None
def get_values(
file_path: pathlib.Path,
parameter: str or typing.Dict,
level: float or typing.Dict,
) -> np.ndarray:
message = get_message(
file_path,
parameter=parameter,
level=level,
)
array = eccodes.codes_get_double_array(message,
"values").reshape([121, 240])
eccodes.codes_release(message)
return array
def create_data_array_from_message(
message,
level_dim_name: str or None = None,
) -> xr.DataArray:
"""
Create ``xarray.DataArray`` from one GRIB 2 message.
"""
values = eccodes.codes_get_double_array(message, "values")
attr_keys = [
'edition',
'centre',
'subCentre',
'tablesVersion',
"localTablesVersion",
'dataType',
'dataDate',
'dataTime',
'validityDate',
'validityTime',
'step',
'stepType',
'stepUnits',
'stepRange',
'endStep',
"name",
"shortName",
'cfName',
'discipline',
'parameterCategory',
'parameterNumber',
'gridType',
'gridDefinitionDescription',
'typeOfFirstFixedSurface',
'typeOfLevel',
'level',
'numberOfPoints',
"missingValue",
'units',
]
grid_keys = [
'latitudeOfFirstGridPointInDegrees',
'longitudeOfFirstGridPointInDegrees',
'latitudeOfLastGridPointInDegrees',
'longitudeOfLastGridPointInDegrees',
'iDirectionIncrementInDegrees',
'jDirectionIncrementInDegrees',
'Ni',
'Nj',
]
level_keys = [
"typeOfFirstFixedSurface",
"typeOfSecondFixedSurface",
"scaleFactorOfFirstFixedSurface",
"scaledValueOfFirstFixedSurface",
]
all_keys = attr_keys + grid_keys + level_keys
all_attrs = {}
for key in all_keys:
try:
value = eccodes.codes_get(message, key)
except:
value = "undef"
all_attrs[key] = value
latitude_of_first_grid_point_in_degrees = all_attrs[
"latitudeOfFirstGridPointInDegrees"]
longitude_of_first_grid_point_in_degrees = all_attrs[
"longitudeOfFirstGridPointInDegrees"]
latitude_of_last_grid_point_in_degrees = all_attrs[
"latitudeOfLastGridPointInDegrees"]
longitude_of_last_grid_point_in_degrees = all_attrs[
"longitudeOfLastGridPointInDegrees"]
ni = all_attrs["Ni"]
nj = all_attrs["Nj"]
values = values.reshape(nj, ni)
lons = np.linspace(longitude_of_first_grid_point_in_degrees,
longitude_of_last_grid_point_in_degrees,
ni,
endpoint=True)
lats = np.linspace(latitude_of_first_grid_point_in_degrees,
latitude_of_last_grid_point_in_degrees,
nj,
endpoint=True)
coords = {}
# add time and step coordinate
time_name, value = get_time_from_attrs(all_attrs)
coords[time_name] = value
step_name, value = get_step_from_attrs(all_attrs)
coords[step_name] = value
# add valid time coordinate
valid_time_name, value = get_valid_time_from_attrs(all_attrs)
if valid_time_name is not None:
coords[valid_time_name] = value
# add level coordinate
level_name, value = get_level_from_attrs(all_attrs, level_dim_name)
coords[level_name] = value
coords["latitude"] = lats
coords["longitude"] = lons
dims = ("latitude", "longitude")
data_attrs = {
f"GRIB_{key}": all_attrs[key]
for key in attr_keys if all_attrs[key] not in ("undef", "unknown")
}
# set long_name
if "GRIB_name" in data_attrs:
data_attrs["long_name"] = data_attrs["GRIB_name"]
else:
name = (f"discipline={all_attrs['discipline']} "
f"parmcat={all_attrs['parameterCategory']} "
f"parm={all_attrs['parameterNumber']}")
data_attrs["long_name"] = name
# set name
if "shortName" in all_attrs:
var_name = all_attrs["shortName"]
else:
var_name = f"{all_attrs['discipline']}_{all_attrs['parameterCategory']}_{all_attrs['parameterNumber']}"
# set units
if "GRIB_units" in data_attrs:
data_attrs["units"] = data_attrs["GRIB_units"]
data = xr.DataArray(
values,
dims=dims,
coords=coords,
attrs=data_attrs,
name=var_name,
)
return data
def get_double_array(self, key):
return eccodes.codes_get_double_array(self.handle, key)
def select_messages(self, **kwargs):
self._selected_grbs = self._get_gids(**kwargs)
self._log(f'Selected {len(self._selected_grbs)} grib messages')
if len(self._selected_grbs) > 0:
self._gid_main_res = self._selected_grbs[0]
grid = GribGridDetails(self._selected_grbs[0])
# some cumulated messages come with the message at step=0 as instant, to permit aggregation
# cumulated rainfall rates could have the step zero instant message as kg/m^2, instead of kg/(m^2*s)
if len(self._selected_grbs) > 1:
unit = codes_get(self._selected_grbs[1], 'units')
type_of_step = codes_get(self._selected_grbs[1], 'stepType')
else:
type_of_step = codes_get(self._selected_grbs[0], 'stepType')
unit = codes_get(self._selected_grbs[0], 'units')
type_of_level = codes_get(self._selected_grbs[0], 'levelType')
missing_value = codes_get(self._selected_grbs[0], 'missingValue')
data_date = codes_get(self._selected_grbs[0], 'dataDate')
all_values = {}
all_values_second_res = {}
grid2 = None
input_step = self._step_grib
for g in self._selected_grbs:
start_step = codes_get(g, 'startStep')
end_step = codes_get(g, 'endStep')
points_meridian = codes_get(g, 'Nj')
level = codes_get(g, 'level')
if f'{start_step}-{end_step}' == self._change_step_at:
# second time resolution
input_step = self._step_grib2
step_key = Step(start_step, end_step, points_meridian,
input_step, level)
if points_meridian != grid.num_points_along_meridian and grid.get_2nd_resolution(
) is None:
# found second resolution messages
grid2 = GribGridDetails(g)
self._gid_ext_res = g
values = codes_get_double_array(g, 'values')
# Handling missing grib values.
# If bitmap is present, array will be a masked_array
# and array.mask will be used later
# in interpolation and manipulation
bitmap_present = codes_get(g, 'bitmapPresent')
if bitmap_present:
# Get the bitmap array which contains 0s and 1s
bitmap = codes_get_array(g, 'bitmap', int)
values = ma.masked_where(bitmap == 0, values, copy=False)
if not grid2:
all_values[step_key] = values
elif points_meridian != grid.num_points_along_meridian:
all_values_second_res[step_key] = values
if grid2:
key_2nd_spatial_res = min(all_values_second_res.keys())
grid.set_2nd_resolution(grid2, key_2nd_spatial_res)
return Messages(all_values,
missing_value,
unit,
type_of_level,
type_of_step,
grid,
all_values_second_res,
data_date=data_date)
# no messages found
else:
raise ApplicationException.get_exc(NO_MESSAGES,
details=f'using {kwargs}')
