def test_bufr_multi_element_constant_arrays():
eccodes.codes_bufr_multi_element_constant_arrays_off()
bid = eccodes.codes_bufr_new_from_samples("BUFR3_local_satellite")
eccodes.codes_set(bid, "unpack", 1)
assert eccodes.codes_get_size(bid, "satelliteIdentifier") == 1
eccodes.codes_release(bid)
eccodes.codes_bufr_multi_element_constant_arrays_on()
bid = eccodes.codes_bufr_new_from_samples("BUFR3_local_satellite")
eccodes.codes_set(bid, "unpack", 1)
numSubsets = eccodes.codes_get(bid, "numberOfSubsets")
assert eccodes.codes_get_size(bid, "satelliteIdentifier") == numSubsets
eccodes.codes_release(bid)
def get_subset_values(self, subset_nr , autoget_cval=False):
# #[
"""
request an array of values containing the values
for a given subset for this bufr message
"""
if (self.msg_loaded == -1):
raise NoMsgLoadedError
data = []
field_names = self._get_abbr_names(subset_nr)
print('field_names = ', field_names)
print('DEBUG: names = ',self.get_names(subset_nr))
for field in field_names:
if field[0] in string.digits:
print('cannot get data for field: ',field)
continue
print('trying field name: ', field)
s = eccodes.codes_get_size(self.bufr_id,field)
if s==1:
value = eccodes.codes_get(self.bufr_id,field)
data.append(value)
else:
values = eccodes.codes_get_array(self.bufr_id,field)
data.append(values[subset_nr])
return data
def get(self, key, ktype=None):
"""Get value of a given key as its native or specified type."""
# if self.missing(key):
# raise KeyError("Value of key %s is MISSING." % key)
if eccodes.codes_get_size(self.codes_id, key) > 1:
ret = eccodes.codes_get_array(self.codes_id, key, ktype)
else:
ret = eccodes.codes_get(self.codes_id, key, ktype)
return ret
def cli(output_file_path):
handle = eccodes.codes_grib_new_from_samples('regular_ll_pl_grib2')
value_size = eccodes.codes_get_size(handle, 'values')
values = []
for i in range(0, value_size):
values.append(i)
eccodes.codes_set_values(handle, values)
with open(output_file_path, 'wb') as output_file:
eccodes.codes_write(handle, output_file)
eccodes.codes_release(handle)
def get(self, name):
# LOG.warn(str(self) + str(name))
if name in CHEAT:
return CHEAT[name]
try:
if name == "values":
return eccodes.codes_get_values(self.handle)
size = eccodes.codes_get_size(self.handle, name)
LOG.debug(f"{name}:{size}")
if size and size > 1:
return eccodes.codes_get_array(self.handle, name)
return eccodes.codes_get(self.handle, name)
except eccodes.KeyValueNotFoundError:
return None
def get_any(self, keys, key_type=None):
# single key with key_type specified
if key_type is not None:
assert isinstance(keys, str)
func = key_type[1]
return func(self.handle, keys)
# list of keys
else:
result = []
for key in keys:
key_type_str = "s"
parts = key.split(":")
if len(parts) == 2:
key, key_type_str = parts
if (key_type_str == "n"
and eccodes.codes_get_size(self.handle, key) > 1):
key_type_str = "na"
func = CodesHandle._STR_TYPES.get(key_type_str, None)[0]
result.append(self.call_get_func(func, key, default=None))
return result
def get_values(self, descr_nr, autoget_cval=False):
# #[
"""
request an array of values containing the values
for a given descriptor number for all subsets
NOTE: this may not work for templates using delayed replication.
"""
if (self.msg_loaded == -1):
raise NoMsgLoadedError
list_of_names = self._get_abbr_names()
keyname = list_of_names[descr_nr]
print('keyname: ', keyname)
s = eccodes.codes_get_size(self.bufr_id,keyname)
t = eccodes.codes_get_native_type(self.bufr_id, keyname)
print('key:', keyname, 'size = ', s, 'type = ', t)
if s==1: # or t==str:
# values = eccodes.codes_get_string(bufr_id, keyname)
values = [eccodes.codes_get(self.bufr_id, keyname),]
else:
values = eccodes.codes_get_array(self.bufr_id, keyname)
return values
def get_ecc_msg(gid, namespace=None, skipkeys=None):
"""Read data from one particular ecc message
Parameters
----------
gid : ecc message id
namespace : string
namespace to be retrieved, defaults to None (means all)
'ls', 'parameter', 'time', 'geography', 'vertical', 'statistics', 'mars'
skipkeys : list of strings
keys to be skipped, defaults to None
possible keys: 'computed', 'coded', 'edition', 'duplicates', 'read_only', 'function'
Returns
-------
data : dictionary of ecc message contents
"""
# get key iterator
iterid = ecc.codes_keys_iterator_new(gid, namespace)
# Different types of keys can be skipped
if skipkeys:
if 'computed' in skipkeys:
ecc.codes_skip_computed(iterid)
if 'coded' in skipkeys:
ecc.codes_skip_coded(iterid)
if 'edition' in skipkeys:
ecc.codes_skip_edition_specific(iterid)
if 'duplicates' in skipkeys:
ecc.codes_skip_duplicates(iterid)
if 'read_only' in skipkeys:
ecc.codes_skip_read_only(iterid)
if 'function' in skipkeys:
ecc.codes_skip_function(iterid)
data = OrderedDict()
# iterate over message keys
while ecc.codes_keys_iterator_next(iterid):
keyname = ecc.codes_keys_iterator_get_name(iterid)
#print(keyname)
#print("Size:", ecc.codes_get_size(gid, keyname))
#print("Values:", ecc.codes_get_values(gid, keyname))
#print("Array:", ecc.codes_get_values(gid, keyname))
# try to get key values,
# use get_array for sizes > 1 and get for sizes == 1
if ecc.codes_get_size(gid,keyname) > 1:
#print("has array", type is str)
#print(type is not <type 'str'>)
if ecc.codes_get_native_type(iterid, keyname) is not str:
keyval = ecc.codes_get_array(gid, keyname, None)
else:
keyval = ecc.codes_get(gid, keyname, None)
#print("Arr:", keyval)
else:
# Todo: fix reading mybits
if keyname not in ['mybits']:
keyval = ecc.codes_get(gid, keyname, None)
#print("Val:", keyval)
else:
keyval = 'err'
# add keyname-keyvalue-pair to output dictionary
data[keyname] = keyval
#print('Message processed')
# release iterator
ecc.codes_keys_iterator_delete(iterid)
return data
def read_field(self):
geography = [
"bitmapPresent", "Nx", "Ny", "latitudeOfFirstGridPointInDegrees",
"longitudeOfFirstGridPointInDegrees", "LoVInDegrees", "DxInMetres",
"DyInMetres", "iScansNegatively", "jScansPositively",
"jPointsAreConsecutive", "Latin1InDegrees", "LaDInDegrees",
"Latin2InDegrees", "latitudeOfSouthernPoleInDegrees",
"longitudeOfSouthernPoleInDegrees", "gridType"
]
if self.fname == None or not os.path.isfile(self.fname):
print("The file " + str(self.fname) + " does not exist!")
sys.exit(1)
print("Reading file: " + self.fname)
f = open(self.fname, "r")
while 1:
gid = ec.codes_grib_new_from_file(f)
if gid is None:
break
par = ec.codes_get(gid, "indicatorOfParameter")
lev = ec.codes_get(gid, "level")
typ = ec.codes_get(gid, "indicatorOfTypeOfLevel")
tri = ec.codes_get(gid, "timeRangeIndicator")
#print("Search::", w_par, w_lev, w_typ, w_tri)
if self.par == par and self.lev == lev and self.typ == typ and self.tri == tri:
print("Found:", self.par, self.lev, self.typ, self.tri)
geo = {}
for key in geography:
try:
geo.update({key: ec.codes_get(gid, key)})
except ec.CodesInternalError as err:
print('Error with key="%s" : %s' % (key, err.msg))
print(
'There are %d values, average is %f, min is %f, max is %f'
% (ec.codes_get_size(gid, 'values'),
ec.codes_get(gid, 'average'), ec.codes_get(
gid, 'min'), ec.codes_get(gid, 'max')))
# Date/time
d = ec.codes_get(gid, "validityDate")
t = ec.codes_get(gid, "validityTime")
h = int(t) / 100
m = t % h
s = (h * 3600) + (m * 60)
date = datetime.strptime(str(d), "%Y%m%d")
time = timedelta(seconds=s)
dt = date + time
# Missing values
mv = None
try:
mv = ec.codes_get(gid, "missingValue")
except:
print("Field does not contanin missing values")
if geo["gridType"].lower() == "lambert":
values = ec.codes_get_values(gid)
nx = geo["Nx"]
ny = geo["Ny"]
lonCenter = geo["LoVInDegrees"]
latCenter = geo["LaDInDegrees"]
latRef = geo["Latin2InDegrees"]
lon0 = geo["longitudeOfFirstGridPointInDegrees"]
lat0 = geo["latitudeOfFirstGridPointInDegrees"]
dx = geo["DxInMetres"]
dy = geo["DyInMetres"]
proj4_string = "+proj=lcc +lat_0=" + str(
latCenter) + " +lon_0=" + str(
lonCenter) + " +lat_1=" + str(
latRef) + " +lat_2=" + str(
latRef) + " +no_defs +units=m +R=6.371e+06"
proj4 = Proj(proj4_string)
x0, y0 = proj4(lon0, lat0)
x0 = int(round(x0))
y0 = int(round(y0))
field = np.empty([nx, ny])
lons = np.empty([nx, ny])
lats = np.empty([nx, ny])
X = np.arange(x0, x0 + (nx * dx), dx)
Y = np.arange(y0, y0 + (ny * dy), dy)
ii = 0
for i in range(0, nx):
for j in range(0, ny):
field[i, j] = values[ii]
lons[i, j], lats[i, j] = proj4(X[i],
Y[j],
inverse=True)
# print i,j,lons[i, j], lats[i, j]
ii = ii + 1
if mv is not None:
field[field == mv] = np.nan
ec.codes_release(gid)
f.close()
return (lons, lats, X, Y, dt, field)
else:
print(geo["gridType"] + " not implemented yet!")
ec.codes_release(gid)
f.close()
def main():
INPUT = "/home/trygveasp/tmp/build/fc2018010318+003grib_fp_mbr000"
OUTPUT = '/home/trygveasp/tmp/build/out.set.grib'
try:
from eccodes import codes_grib_new_from_file, codes_get, codes_get_size, codes_write, codes_release, codes_get_values, CodesInternalError
except:
print("Missing eccodes")
sys.exit(1)
fin = open(INPUT)
fout = open(OUTPUT, 'w')
keys = [
'Ni', 'Nj', 'latitudeOfFirstGridPointInDegrees',
'longitudeOfFirstGridPointInDegrees', 'indicatorOfParameter', 'level',
'timeRangeIndicator', 'indicatorOfTypeOfLevel', 'dataDate', 'dataTime'
]
geography = [
"bitmapPresent", "Nx", "Ny", "latitudeOfFirstGridPointInDegrees",
"longitudeOfFirstGridPointInDegrees", "LoVInDegrees", "DxInMetres",
"DyInMetres", "iScansNegatively", "jScansPositively",
"jPointsAreConsecutive", "Latin1InDegrees", "LaDInDegrees",
"Latin2InDegrees", "latitudeOfSouthernPoleInDegrees",
"longitudeOfSouthernPoleInDegrees", "gridType"
]
while 1:
gid = codes_grib_new_from_file(fin)
if gid is None:
print("Not found")
break
else:
w_par = 6
w_lev = 0
w_typ = "sfc"
w_tri = 0
par = codes_get(gid, "indicatorOfParameter")
lev = codes_get(gid, "level")
typ = codes_get(gid, "indicatorOfTypeOfLevel")
tri = codes_get(gid, "timeRangeIndicator")
if w_par == par and w_lev == lev and w_typ == typ and w_tri == tri:
print("Found:", par, lev, typ, tri)
geo = {}
for key in geography:
try:
geo.update({key: codes_get(gid, key)})
except CodesInternalError as err:
print('Error with key="%s" : %s' % (key, err.msg))
for key in geo:
print(' %s: %s' % (key, geo[key]))
print(
'There are %d values, average is %f, min is %f, max is %f'
%
(codes_get_size(gid, 'values'), codes_get(gid, 'average'),
codes_get(gid, 'min'), codes_get(gid, 'max')))
values = codes_get_values(gid)
nx = geo["Nx"]
ny = geo["Ny"]
print('%d values found in %s' % (len(values), INPUT))
field = np.empty([nx, ny])
ii = 0
for j in range(0, ny):
for i in range(0, nx):
#print i,j,ii
field[i, j] = values[ii]
ii = ii + 1
lonCenter = geo["LoVInDegrees"]
latCenter = geo["LaDInDegrees"]
latRef = geo["Latin2InDegrees"]
print(lonCenter, latCenter, latRef)
lon0 = geo["longitudeOfFirstGridPointInDegrees"]
lat0 = geo["latitudeOfFirstGridPointInDegrees"]
dx = geo["DxInMetres"]
dy = geo["DyInMetres"]
g0 = ccrs.Geodetic()
proj = ccrs.LambertConformal(central_longitude=lonCenter,
central_latitude=latCenter,
standard_parallels=[latRef])
x0, y0 = proj.transform_point(lon0, lat0, g0)
X = np.arange(x0, x0 + (nx * dx), dx)
Y = np.arange(y0, y0 + (ny * dy), dy)
print(values.shape, field.shape, x0, y0, X.shape, Y.shape)
print(X[0] + 1022485)
print("-1022485")
print(Y[0] + 1129331)
print("-1129331")
Z = np.transpose(field) / 9.81
N = [10, 50, 100, 250, 500, 750, 1250, 2000]
ax = plt.axes(projection=proj)
plt.contourf(X, Y, Z, N, transform=proj)
plt.show()
break
#codes_set_key_vals.
codes_write(gid, fout)
codes_release(gid)
fin.close()
fout.close()
