def test(self):
from netCDF4 import Dataset as NetCDF
timeidx = 0
in_wrfnc = NetCDF(wrf_in)
if (varname == "interplevel"):
ref_ht_850 = _get_refvals(referent, "interplevel", repeat, multi)
hts = getvar(in_wrfnc, "z", timeidx=timeidx)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
hts_850 = interplevel(hts, p, 850)
nt.assert_allclose(to_np(hts_850), ref_ht_850)
elif (varname == "vertcross"):
ref_ht_cross = _get_refvals(referent, "vertcross", repeat, multi)
hts = getvar(in_wrfnc, "z", timeidx=timeidx)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
pivot_point = CoordPair(hts.shape[-1] // 2, hts.shape[-2] // 2)
ht_cross = vertcross(hts, p, pivot_point=pivot_point, angle=90.)
nt.assert_allclose(to_np(ht_cross), ref_ht_cross, rtol=.01)
elif (varname == "interpline"):
ref_t2_line = _get_refvals(referent, "interpline", repeat, multi)
t2 = getvar(in_wrfnc, "T2", timeidx=timeidx)
pivot_point = CoordPair(t2.shape[-1] // 2, t2.shape[-2] // 2)
t2_line1 = interpline(t2, pivot_point=pivot_point, angle=90.0)
nt.assert_allclose(to_np(t2_line1), ref_t2_line)
elif (varname == "vinterp"):
# Tk to theta
fld_tk_theta = _get_refvals(referent, "vinterp", repeat, multi)
fld_tk_theta = np.squeeze(fld_tk_theta)
tk = getvar(in_wrfnc, "temp", timeidx=timeidx, units="k")
interp_levels = [200, 300, 500, 1000]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
tol = 5 / 100.
atol = 0.0001
field = np.squeeze(field)
nt.assert_allclose(to_np(field), fld_tk_theta, tol, atol)
def fix_ice_categories(storage_path,
log_path='../coarse_1975-1980.log',
cpu_count=4):
ice_files = ice_cat_errors_files(log_path)
for file in tqdm(ice_files):
print(f'File to fix: {file}')
date_raw = extracted_date_by_pattern(file)
date = datetime.datetime.strptime(date_raw, '%Y%m%d')
file_path = f'{storage_path}/{date.year}/{file}'
tmp_path = f'../tmp_fixed/{date.year}'
if not os.path.exists(tmp_path):
os.mkdir(tmp_path)
copyfile(f'{storage_path}/1976/{correct_ice_file}',
f'{tmp_path}/{file}')
fixed_file = NetCDF(f'{tmp_path}/{file}', mode='r+')
file_with_errors = NetCDF(file_path, mode='r')
for var_name in file_with_errors.variables:
if var_name not in ['siconcat', 'sithicat', 'ncatice']:
fixed_file[var_name][:] = file_with_errors[var_name][:]
print(f'Variable: {var_name} was copied')
file_with_errors.close()
conc_fixed, thic_fixed = ice_with_8_categories(file_path=file_path,
cpu_count=cpu_count)
fixed_file['siconcat'][:] = conc_fixed
fixed_file['sithicat'][:] = thic_fixed
fixed_file.close()
def test(self):
from netCDF4 import Dataset as NetCDF
timeidx = 0
in_wrfnc = NetCDF(wrf_in)
refnc = NetCDF(referent)
if testid == "xy":
# Since this domain is not moving, the reference values are the
# same whether there are multiple or single files
ref_vals = refnc.variables["xy"][:]
# Lats/Lons taken from NCL script, just hard-coding for now
lats = [22.0, 25.0, 27.0]
lons = [-90.0, -87.5, -83.75]
xy = ll_to_xy(in_wrfnc, lats[0], lons[0])
nt.assert_allclose(to_np(xy), ref_vals)
else:
# Since this domain is not moving, the reference values are the
# same whether there are multiple or single files
ref_vals = refnc.variables["ll"][:]
# i_s, j_s taken from NCL script, just hard-coding for now
# NCL uses 1-based indexing for this, so need to subtract 1
x_s = np.asarray([10, 50, 90], int)
y_s = np.asarray([10, 50, 90], int)
ll = xy_to_ll(in_wrfnc, x_s[0], y_s[0])
nt.assert_allclose(to_np(ll), ref_vals)
def test_files_time_dif_correct(directory, first_file, second_file):
first = NetCDF(f'{directory}/{first_file}')
second = NetCDF(f'{directory}/{second_file}')
time_var = 'time_counter'
print(second[time_var][:][0] - first[time_var][:][0])
def test(self):
from netCDF4 import Dataset as NetCDF
timeidx = 0
in_wrfnc = NetCDF(wrf_in)
refnc = NetCDF(referent)
# These have a left index that defines the product type
multiproduct = varname in ("uvmet", "uvmet10", "cape_2d", "cape_3d",
"cfrac")
ref_vals = refnc.variables[varname][:]
if (varname == "tc"):
my_vals = getvar(in_wrfnc, "temp", timeidx=timeidx, units="c")
tol = 1 / 100.
atol = .1 # Note: NCL uses 273.16 as conversion for some reason
nt.assert_allclose(to_np(my_vals), ref_vals, tol, atol)
elif (varname == "pw"):
my_vals = getvar(in_wrfnc, "pw", timeidx=timeidx)
tol = .5 / 100.0
atol = 0 # NCL uses different constants and doesn't use same
# handrolled virtual temp in method
nt.assert_allclose(to_np(my_vals), ref_vals, tol, atol)
elif (varname == "cape_2d"):
cape_2d = getvar(in_wrfnc, varname, timeidx=timeidx)
tol = 0 / 100.
atol = 200.0
# Let's only compare CAPE values until the F90 changes are
# merged back in to NCL. The modifications to the R and CP
# changes TK enough that non-lifting parcels could lift, thus
# causing wildly different values in LCL
nt.assert_allclose(to_np(cape_2d[0, :]), ref_vals[0, :], tol, atol)
elif (varname == "cape_3d"):
cape_3d = getvar(in_wrfnc, varname, timeidx=timeidx)
# Changing the R and CP constants, while keeping TK within
# 2%, can lead to some big changes in CAPE. Tolerances
# have been set wide when comparing the with the original
# NCL. Change back when the F90 code is merged back with
# NCL
tol = 0 / 100.
atol = 200.0
#print np.amax(np.abs(to_np(cape_3d[0,:]) - ref_vals[0,:]))
nt.assert_allclose(to_np(cape_3d), ref_vals, tol, atol)
else:
my_vals = getvar(in_wrfnc, varname, timeidx=timeidx)
tol = 2 / 100.
atol = 0.1
#print (np.amax(np.abs(to_np(my_vals) - ref_vals)))
nt.assert_allclose(to_np(my_vals), ref_vals, tol, atol)
def test_era_misses():
nc_file = NetCDF('../reanalysis/era_2016-2017/era-prec-y2016.nc')
station_coords = [171, 75]
prec_at_point = nc_file.variables['var228'][:][75, 171, :]
print(prec_at_point)
nc_file.close()
def check_variables(self, file_format):
errors = []
if self.path is "":
errors.append("%s is absent, can't be opened" % self.name)
else:
nc_file = NetCDF(self.path)
for correct_var in file_format.variables(self.type):
try:
var = nc_file.variables[correct_var.name]
error = self.check_shape(var, correct_var, self.name)
if error is not "":
errors.append(error)
# TODO: change magic constants with more smart calculations
if self.check_for_nan(var, 200, 200):
error = f"{var.name} variable has NaN-value at (200,200) point in {self.name}"
errors.append(error)
except KeyError:
error = "%s variable is not presented in %s" % (
correct_var.name, self.name)
errors.append(error)
return errors
def _get_refvals(referent, varname, repeat, multi):
try:
from netCDF4 import Dataset as NetCDF
except:
pass
refnc = NetCDF(referent)
if not multi:
ref_vals = refnc.variables[varname][:]
else:
data = refnc.variables[varname][:]
new_dims = [repeat] + [x for x in data.shape]
masked = False
if (isinstance(data, ma.core.MaskedArray)):
masked = True
if not masked:
ref_vals = np.zeros(new_dims, data.dtype)
else:
ref_vals = ma.asarray(np.zeros(new_dims, data.dtype))
for i in xrange(repeat):
ref_vals[i, :] = data[:]
if masked:
ref_vals.mask[i, :] = data.mask[:]
return ref_vals
def _get_refvals(referent, varname, multi):
try:
from netCDF4 import Dataset as NetCDF
except ImportError:
pass
refnc = NetCDF(referent)
try:
pass
except ImportError:
pass
multi2d = ("uvmet10", "wspd_wdir10", "uvmet10_wspd_wdir", "cape_2d",
"cfrac")
multi3d = ("uvmet", "wspd_wdir", "uvmet_wspd_wdir", "cape_3d")
interpline = ("t2_line", "t2_line2", "t2_line3")
if not multi:
if varname in multi2d:
ref_vals = refnc.variables[varname][..., 0, :, :]
elif varname in multi3d:
ref_vals = refnc.variables[varname][..., 0, :, :, :]
else:
v = refnc.variables[varname][:]
if v.ndim == 2:
if varname in interpline:
ref_vals = v[0, :]
else:
ref_vals = v
else:
ref_vals = v[0, :]
else:
ref_vals = refnc.variables[varname][:]
return ref_vals
def _get_refvals(referent, varname, repeat, multi):
from netCDF4 import Dataset as NetCDF
refnc = NetCDF(referent)
ref_vals = refnc.variables[varname][:]
return ref_vals
def save_interp_precip(prev_file_path, fixed_file_path, rea_name, interp_precip, time):
copyfile(prev_file_path, fixed_file_path)
nc_file = NetCDF(fixed_file_path, mode='r+')
var_name = FIELDS_BY_REA_NAME[rea_name]
nc_file[var_name][:] = interp_precip
nc_file['time'][:] = time
nc_file.close()
def hourly_time(path_to_rea, year):
nc_file = NetCDF(path_to_rea, mode='r')
first_hour = int(nc_file['time'][:][0])
last_hour = first_hour + days_in_year(year) * 24
nc_file.close()
time = [time_step for time_step in range(first_hour, last_hour)]
return np.asarray(time)
def check_for_integrity(self):
error = ""
try:
nc_file = NetCDF(self.path)
nc_file.close()
except OSError:
error = "%s can't be opened" % self.name
return error
def extracted_precip(path_to_rea, rea_name):
nc_file = NetCDF(path_to_rea, mode='r')
var_name = FIELDS_BY_REA_NAME[rea_name]
precip = nc_file[var_name][:]
if rea_name is 'era':
precip[precip < 0.0] = 0.0
return precip
def fix_missed_variables(directory, file_to_fix, previous_file):
copyfile(f'{directory}/{previous_file}',
f'{directory}/fixed_{file_to_fix}')
file_with_errors = NetCDF(f'{directory}/{file_to_fix}', mode='r')
fixed_file = NetCDF(f'{directory}/fixed_{file_to_fix}', mode='r+')
for var_name in file_with_errors.variables:
if var_name not in fixed_file.variables:
print(f'Variable {var_name} not in previous file')
elif fixed_file[var_name].shape != fixed_file[var_name].shape:
print(
f'Variable {var_name} with incompatible shape:'
f' expected - {fixed_file[var_name].shape}, actual - {file_with_errors[var_name].shape}'
)
else:
fixed_file[var_name][:] = file_with_errors[var_name][:]
file_with_errors.close()
fixed_file.close()
def daily_average(path_to_interp_files):
for year in range(2016, 2018):
file_path = os.path.join(path_to_interp_files, f'precip_interp_y{year}.nc')
nc_file = NetCDF(file_path)
prec_at_point = nc_file.variables['precip'][:][75, 171, :]
nc_file.close()
avg_precip = np.average(prec_at_point)
total_precip = np.sum(prec_at_point)
del prec_at_point
print(f'year: {year}; avg_precip: {avg_precip}; total: {total_precip}')
def fix_precip_attributes(path):
nc_file = NetCDF(path, mode='r+')
nc_file.history = ''
nc_file.variables['precip'].long_name = 'Daily Precipitation Rate at surface'
if 'Identification' in nc_file.ncattrs():
nc_file.Identification = ''
if 'Documentation' in nc_file.ncattrs():
nc_file.Documentation = ''
if 'About' in nc_file.ncattrs():
nc_file.About = ''
nc_file.close()
def fix_time_variables(directory,
file_to_fix,
previous_file,
time_dif=86400.0):
copyfile(f'{directory}/{previous_file}', f'{directory}/{file_to_fix}')
fixed_file = NetCDF(f'{directory}/{file_to_fix}', mode='r+')
for time_var in [
'time_counter', 'time_instant', 'time_counter_bounds',
'time_counter_bounds'
]:
if time_var not in fixed_file.variables:
print(f'Variable {time_var} is not in {file_to_fix}')
else:
fixed_file[time_var][:] += time_dif
fixed_file.close()
def variable(self, name):
nc_file = NetCDF(self.path)
var = nc_file.variables[name][:]
nc_file.close()
return self.handle_sat_field(var)
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except ImportError:
pass
try:
import Nio
except ImportError:
pass
timeidx = 0 if not multi else None
pat = os.path.join(dir, pattern)
wrf_files = glob.glob(pat)
wrf_files.sort()
wrfin = []
for fname in wrf_files:
if not pynio:
f = NetCDF(fname)
try:
f.set_always_mask(False)
except AttributeError:
pass
wrfin.append(f)
else:
if not fname.endswith(".nc"):
_fname = fname + ".nc"
else:
_fname = fname
f = Nio.open_file(_fname)
wrfin.append(f)
refnc = NetCDF(referent)
try:
refnc.set_auto_mask(False)
except AttributeError:
pass
# These have a left index that defines the product type
multiproduct = varname in ("uvmet", "uvmet10", "wspd_wdir",
"wspd_wdir10", "uvmet_wspd_wdir",
"uvmet10_wspd_wdir", "cape_2d", "cape_3d",
"cfrac")
multi2d = ("uvmet10", "wspd_wdir10", "uvmet10_wspd_wdir", "cape_2d",
"cfrac")
multi3d = ("uvmet", "wspd_wdir", "uvmet_wspd_wdir", "cape_3d")
# These varnames don't have NCL functions to test against
ignore_referent = ("zstag", "geopt_stag")
if varname not in ignore_referent:
if not multi:
if varname in multi2d:
ref_vals = refnc.variables[varname][..., 0, :, :]
elif varname in multi3d:
ref_vals = refnc.variables[varname][..., 0, :, :, :]
else:
ref_vals = refnc.variables[varname][0, :]
else:
ref_vals = refnc.variables[varname][:]
if (varname == "zstag" or varname == "geopt_stag"):
v = getvar(wrfin, varname, timeidx=timeidx)
# For now, only make sure it runs without crashing since no NCL
# to compare with yet.0
else:
if varname == "cape_2d" or varname == "cape_3d":
# Cape still has a small floating point issue that
# hasn't been completely resolved, so for now check
# that cape is within 50.
my_vals = getvar(wrfin, varname, timeidx=timeidx)
rtol = 0
atol = 50.
else:
# All other tests should be within .001 of each other
my_vals = getvar(wrfin, varname, timeidx=timeidx)
rtol = 0
atol = 1.0E-3
try:
nt.assert_allclose(to_np(my_vals), ref_vals, rtol, atol)
except AssertionError:
absdiff = np.abs(to_np(my_vals) - ref_vals)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except ImportError:
pass
try:
import Nio
except ImportError:
pass
timeidx = 0 if not multi else None
pat = os.path.join(dir, pattern)
wrf_files = glob.glob(pat)
wrf_files.sort()
refnc = NetCDF(referent)
try:
refnc.set_always_mask(False)
except AttributeError:
pass
wrfin = []
for fname in wrf_files:
if not pynio:
f = NetCDF(fname)
try:
f.set_auto_mask(False)
except AttributeError:
pass
wrfin.append(f)
else:
if not fname.endswith(".nc"):
_fname = fname + ".nc"
else:
_fname = fname
f = Nio.open_file(_fname)
wrfin.append(f)
if testid == "xy":
# Lats/Lons taken from NCL script, just hard-coding for now
lats = [22.0, 25.0, 27.0]
lons = [-90.0, -87.5, -83.75]
# Just call with a single lat/lon
if single:
timeidx = 8
ref_vals = refnc.variables["xy2"][:]
xy = ll_to_xy(wrfin,
lats[0],
lons[0],
timeidx=timeidx,
as_int=True)
ref = ref_vals[:, 0]
nt.assert_allclose(to_np(xy), ref)
# Next make sure the 'proj' version works
projparams = extract_proj_params(wrfin, timeidx=timeidx)
xy_proj = ll_to_xy_proj(lats[0],
lons[0],
as_int=True,
**projparams)
nt.assert_allclose(to_np(xy_proj), to_np(xy))
else:
ref_vals = refnc.variables["xy1"][:]
xy = ll_to_xy(wrfin, lats, lons, timeidx=None, as_int=False)
ref = ref_vals[:]
nt.assert_allclose(to_np(xy), ref)
if xy.ndim > 2:
# Moving nest
is_moving = True
numtimes = xy.shape[-2]
else:
is_moving = False
numtimes = 1
for tidx in range(9):
# Next make sure the 'proj' version works
projparams = extract_proj_params(wrfin, timeidx=tidx)
xy_proj = ll_to_xy_proj(lats,
lons,
as_int=False,
**projparams)
if is_moving:
idxs = (slice(None), tidx, slice(None))
else:
idxs = (slice(None), )
nt.assert_allclose(to_np(xy_proj), to_np(xy[idxs]))
else:
# i_s, j_s taken from NCL script, just hard-coding for now
# NCL uses 1-based indexing for this, so need to subtract 1
x_s = np.asarray([10, 50, 90], int)
y_s = np.asarray([10, 50, 90], int)
if single:
timeidx = 8
ref_vals = refnc.variables["ll2"][:]
ll = xy_to_ll(wrfin, x_s[0], y_s[0], timeidx=timeidx)
ref = ref_vals[::-1, 0]
nt.assert_allclose(to_np(ll), ref)
# Next make sure the 'proj' version works
projparams = extract_proj_params(wrfin, timeidx=8)
ll_proj = xy_to_ll_proj(x_s[0], y_s[0], **projparams)
nt.assert_allclose(to_np(ll_proj), to_np(ll))
else:
ref_vals = refnc.variables["ll1"][:]
ll = xy_to_ll(wrfin, x_s, y_s, timeidx=None)
ref = ref_vals[::-1, :]
nt.assert_allclose(to_np(ll), ref)
if ll.ndim > 2:
# Moving nest
is_moving = True
numtimes = ll.shape[-2]
else:
is_moving = False
numtimes = 1
for tidx in range(numtimes):
# Next make sure the 'proj' version works
projparams = extract_proj_params(wrfin, timeidx=tidx)
ll_proj = xy_to_ll_proj(x_s, y_s, **projparams)
if is_moving:
idxs = (slice(None), tidx, slice(None))
else:
idxs = (slice(None), )
nt.assert_allclose(to_np(ll_proj), to_np(ll[idxs]))
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except ImportError:
pass
try:
import Nio
except ImportError:
pass
timeidx = 0 if not multi else None
pat = os.path.join(dir, pattern)
wrf_files = glob.glob(pat)
wrf_files.sort()
wrfin = []
for fname in wrf_files:
if not pynio:
f = NetCDF(fname)
try:
f.set_always_mask(False)
except AttributeError:
pass
wrfin.append(f)
else:
if not fname.endswith(".nc"):
_fname = fname + ".nc"
else:
_fname = fname
f = Nio.open_file(_fname)
wrfin.append(f)
if (varname == "interplevel"):
ref_ht_500 = _get_refvals(referent, "z_500", multi)
ref_p_5000 = _get_refvals(referent, "p_5000", multi)
ref_ht_multi = _get_refvals(referent, "z_multi", multi)
ref_p_multi = _get_refvals(referent, "p_multi", multi)
ref_ht2_500 = _get_refvals(referent, "z2_500", multi)
ref_p2_5000 = _get_refvals(referent, "p2_5000", multi)
ref_ht2_multi = _get_refvals(referent, "z2_multi", multi)
ref_p2_multi = _get_refvals(referent, "p2_multi", multi)
ref_p_lev2d = _get_refvals(referent, "p_lev2d", multi)
hts = getvar(wrfin, "z", timeidx=timeidx)
p = getvar(wrfin, "pressure", timeidx=timeidx)
wspd_wdir = getvar(wrfin, "wspd_wdir", timeidx=timeidx)
# Make sure the numpy versions work first
hts_500 = interplevel(to_np(hts), to_np(p), 500)
hts_500 = interplevel(hts, p, 500)
# Note: the '*2*' versions in the reference are testing
# against the new version of interplevel in NCL
nt.assert_allclose(to_np(hts_500), ref_ht_500)
nt.assert_allclose(to_np(hts_500), ref_ht2_500)
# Make sure the numpy versions work first
p_5000 = interplevel(to_np(p), to_np(hts), 5000)
p_5000 = interplevel(p, hts, 5000)
nt.assert_allclose(to_np(p_5000), ref_p_5000)
nt.assert_allclose(to_np(p_5000), ref_p2_5000)
hts_multi = interplevel(to_np(hts), to_np(p),
[1000., 850., 500., 250.])
hts_multi = interplevel(hts, p, [1000., 850., 500., 250.])
nt.assert_allclose(to_np(hts_multi), ref_ht_multi)
nt.assert_allclose(to_np(hts_multi), ref_ht2_multi)
p_multi = interplevel(to_np(p), to_np(hts),
[500., 2500., 5000., 10000.])
p_multi = interplevel(p, hts, [500., 2500., 5000., 10000.])
nt.assert_allclose(to_np(p_multi), ref_p_multi)
nt.assert_allclose(to_np(p_multi), ref_p2_multi)
pblh = getvar(wrfin, "PBLH", timeidx=timeidx)
p_lev2d = interplevel(to_np(p), to_np(hts), to_np(pblh))
p_lev2d = interplevel(p, hts, pblh)
nt.assert_allclose(to_np(p_lev2d), ref_p_lev2d)
# Just make sure these run below
wspd_wdir_500 = interplevel(to_np(wspd_wdir), to_np(p), 500)
wspd_wdir_500 = interplevel(wspd_wdir, p, 500)
wspd_wdir_multi = interplevel(to_np(wspd_wdir), to_np(p),
[1000, 500, 250])
wdpd_wdir_multi = interplevel(wspd_wdir, p, [1000, 500, 250])
wspd_wdir_pblh = interplevel(to_np(wspd_wdir), to_np(hts), pblh)
wspd_wdir_pblh = interplevel(wspd_wdir, hts, pblh)
if multi:
wspd_wdir_pblh_2 = interplevel(to_np(wspd_wdir), to_np(hts),
pblh[0, :])
wspd_wdir_pblh_2 = interplevel(wspd_wdir, hts, pblh[0, :])
# Since PBLH doesn't change in this case, it should match
# the 0 time from previous computation. Note that this
# only works when the data has 1 time step that is repeated.
# If you use a different case with multiple times,
# this will probably fail.
nt.assert_allclose(to_np(wspd_wdir_pblh_2[:, 0, :]),
to_np(wspd_wdir_pblh[:, 0, :]))
nt.assert_allclose(to_np(wspd_wdir_pblh_2[:, -1, :]),
to_np(wspd_wdir_pblh[:, 0, :]))
elif (varname == "vertcross"):
ref_ht_cross = _get_refvals(referent, "ht_cross", multi)
ref_p_cross = _get_refvals(referent, "p_cross", multi)
ref_ht_vertcross1 = _get_refvals(referent, "ht_vertcross1", multi)
ref_ht_vertcross2 = _get_refvals(referent, "ht_vertcross2", multi)
ref_ht_vertcross3 = _get_refvals(referent, "ht_vertcross3", multi)
hts = getvar(wrfin, "z", timeidx=timeidx)
p = getvar(wrfin, "pressure", timeidx=timeidx)
pivot_point = CoordPair(hts.shape[-1] / 2, hts.shape[-2] / 2)
# Beginning in wrf-python 1.3, users can select number of levels.
# Originally, for pressure, dz was 10, so let's back calculate
# the number of levels.
p_max = np.floor(np.amax(p) / 10) * 10 # bottom value
p_min = np.ceil(np.amin(p) / 10) * 10 # top value
p_autolevels = int((p_max - p_min) / 10)
# Make sure the numpy versions work first
ht_cross = vertcross(to_np(hts),
to_np(p),
pivot_point=pivot_point,
angle=90.,
autolevels=p_autolevels)
ht_cross = vertcross(hts,
p,
pivot_point=pivot_point,
angle=90.,
autolevels=p_autolevels)
try:
nt.assert_allclose(to_np(ht_cross), ref_ht_cross, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(ht_cross) - ref_ht_cross)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
lats = hts.coords["XLAT"]
lons = hts.coords["XLONG"]
# Test the manual projection method with lat/lon
# Only do this for the non-multi case, since the domain
# might be moving
if not multi:
if lats.ndim > 2: # moving nest
lats = lats[0, :]
lons = lons[0, :]
ll_point = ll_points(lats, lons)
pivot = CoordPair(lat=lats[int(lats.shape[-2] / 2),
int(lats.shape[-1] / 2)],
lon=lons[int(lons.shape[-2] / 2),
int(lons.shape[-1] / 2)])
v1 = vertcross(hts,
p,
wrfin=wrfin,
pivot_point=pivot_point,
angle=90.0)
v2 = vertcross(hts,
p,
projection=hts.attrs["projection"],
ll_point=ll_point,
pivot_point=pivot_point,
angle=90.)
try:
nt.assert_allclose(to_np(v1), to_np(v2), atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(v1) - to_np(v2))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Test opposite
p_cross1 = vertcross(p, hts, pivot_point=pivot_point, angle=90.0)
try:
nt.assert_allclose(to_np(p_cross1), ref_p_cross, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(p_cross1) - ref_p_cross)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Test point to point
start_point = CoordPair(0, hts.shape[-2] / 2)
end_point = CoordPair(-1, hts.shape[-2] / 2)
p_cross2 = vertcross(p,
hts,
start_point=start_point,
end_point=end_point)
try:
nt.assert_allclose(to_np(p_cross1),
to_np(p_cross2),
atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(p_cross1) - to_np(p_cross2))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Check the new vertcross routine
pivot_point = CoordPair(hts.shape[-1] / 2, hts.shape[-2] / 2)
ht_cross = vertcross(hts,
p,
pivot_point=pivot_point,
angle=90.,
latlon=True)
try:
nt.assert_allclose(to_np(ht_cross),
to_np(ref_ht_vertcross1),
atol=.005)
except AssertionError:
absdiff = np.abs(to_np(ht_cross) - to_np(ref_ht_vertcross1))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
levels = [1000., 850., 700., 500., 250.]
ht_cross = vertcross(hts,
p,
pivot_point=pivot_point,
angle=90.,
levels=levels,
latlon=True)
try:
nt.assert_allclose(to_np(ht_cross),
to_np(ref_ht_vertcross2),
atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(ht_cross) - to_np(ref_ht_vertcross2))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
idxs = (0, slice(None)) if lats.ndim > 2 else (slice(None), )
start_lat = np.amin(
lats[idxs]) + .25 * (np.amax(lats[idxs]) - np.amin(lats[idxs]))
end_lat = np.amin(
lats[idxs]) + .65 * (np.amax(lats[idxs]) - np.amin(lats[idxs]))
start_lon = np.amin(
lons[idxs]) + .25 * (np.amax(lons[idxs]) - np.amin(lons[idxs]))
end_lon = np.amin(
lons[idxs]) + .65 * (np.amax(lons[idxs]) - np.amin(lons[idxs]))
start_point = CoordPair(lat=start_lat, lon=start_lon)
end_point = CoordPair(lat=end_lat, lon=end_lon)
ll_point = ll_points(lats[idxs], lons[idxs])
ht_cross = vertcross(hts,
p,
start_point=start_point,
end_point=end_point,
projection=hts.attrs["projection"],
ll_point=ll_point,
latlon=True,
autolevels=1000)
try:
nt.assert_allclose(to_np(ht_cross),
to_np(ref_ht_vertcross3),
atol=.01)
except AssertionError:
absdiff = np.abs(to_np(ht_cross) - to_np(ref_ht_vertcross3))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
if multi:
ntimes = hts.shape[0]
for t in range(ntimes):
hts = getvar(wrfin, "z", timeidx=t)
p = getvar(wrfin, "pressure", timeidx=t)
ht_cross = vertcross(hts,
p,
start_point=start_point,
end_point=end_point,
wrfin=wrfin,
timeidx=t,
latlon=True,
autolevels=1000)
refname = "ht_vertcross_t{}".format(t)
ref_ht_vertcross = _get_refvals(referent, refname, False)
try:
nt.assert_allclose(to_np(ht_cross),
to_np(ref_ht_vertcross),
atol=.01)
except AssertionError:
absdiff = np.abs(
to_np(ht_cross) - to_np(ref_ht_vertcross))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
elif (varname == "interpline"):
ref_t2_line = _get_refvals(referent, "t2_line", multi)
ref_t2_line2 = _get_refvals(referent, "t2_line2", multi)
ref_t2_line3 = _get_refvals(referent, "t2_line3", multi)
t2 = getvar(wrfin, "T2", timeidx=timeidx)
pivot_point = CoordPair(t2.shape[-1] / 2, t2.shape[-2] / 2)
# Make sure the numpy version works
t2_line1 = interpline(to_np(t2),
pivot_point=pivot_point,
angle=90.0)
t2_line1 = interpline(t2, pivot_point=pivot_point, angle=90.0)
nt.assert_allclose(to_np(t2_line1), ref_t2_line)
# Test the new NCL wrf_user_interplevel result
try:
nt.assert_allclose(to_np(t2_line1), ref_t2_line2)
except AssertionError:
absdiff = np.abs(to_np(t2_line1) - ref_t2_line2)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Test the manual projection method with lat/lon
lats = t2.coords["XLAT"]
lons = t2.coords["XLONG"]
if multi:
if lats.ndim > 2: # moving nest
lats = lats[0, :]
lons = lons[0, :]
ll_point = ll_points(lats, lons)
pivot = CoordPair(lat=lats[int(lats.shape[-2] / 2),
int(lats.shape[-1] / 2)],
lon=lons[int(lons.shape[-2] / 2),
int(lons.shape[-1] / 2)])
l1 = interpline(t2,
wrfin=wrfin,
pivot_point=pivot_point,
angle=90.0)
l2 = interpline(t2,
projection=t2.attrs["projection"],
ll_point=ll_point,
pivot_point=pivot_point,
angle=90.)
try:
nt.assert_allclose(to_np(l1), to_np(l2))
except AssertionError:
absdiff = np.abs(to_np(l1) - to_np(l2))
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Test point to point
start_point = CoordPair(0, t2.shape[-2] / 2)
end_point = CoordPair(-1, t2.shape[-2] / 2)
t2_line2 = interpline(t2,
start_point=start_point,
end_point=end_point)
try:
nt.assert_allclose(to_np(t2_line1), to_np(t2_line2))
except AssertionError:
absdiff = np.abs(to_np(t2_line1) - t2_line2)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Now test the start/end with lat/lon points
start_lat = float(
np.amin(lats) + .25 * (np.amax(lats) - np.amin(lats)))
end_lat = float(
np.amin(lats) + .65 * (np.amax(lats) - np.amin(lats)))
start_lon = float(
np.amin(lons) + .25 * (np.amax(lons) - np.amin(lons)))
end_lon = float(
np.amin(lons) + .65 * (np.amax(lons) - np.amin(lons)))
start_point = CoordPair(lat=start_lat, lon=start_lon)
end_point = CoordPair(lat=end_lat, lon=end_lon)
t2_line3 = interpline(t2,
wrfin=wrfin,
timeidx=0,
start_point=start_point,
end_point=end_point,
latlon=True)
try:
nt.assert_allclose(to_np(t2_line3), ref_t2_line3, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(t2_line3) - ref_t2_line3)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Test all time steps
if multi:
refnc = NetCDF(referent)
ntimes = t2.shape[0]
for t in range(ntimes):
t2 = getvar(wrfin, "T2", timeidx=t)
line = interpline(t2,
wrfin=wrfin,
timeidx=t,
start_point=start_point,
end_point=end_point,
latlon=True)
refname = "t2_line_t{}".format(t)
refline = refnc.variables[refname][:]
try:
nt.assert_allclose(to_np(line),
to_np(refline),
atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(line) - refline)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
refnc.close()
# Test NCLs single time case
if not multi:
refnc = NetCDF(referent)
ref_t2_line4 = refnc.variables["t2_line4"][:]
t2 = getvar(wrfin, "T2", timeidx=0)
line = interpline(t2,
wrfin=wrfin,
timeidx=0,
start_point=start_point,
end_point=end_point,
latlon=True)
try:
nt.assert_allclose(to_np(line),
to_np(ref_t2_line4),
atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(line) - ref_t2_line4)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
finally:
refnc.close()
elif (varname == "vinterp"):
# Tk to theta
fld_tk_theta = _get_refvals(referent, "fld_tk_theta", multi)
fld_tk_theta = np.squeeze(fld_tk_theta)
tk = getvar(wrfin, "temp", timeidx=timeidx, units="k")
interp_levels = [200, 300, 500, 1000]
# Make sure the numpy version works
field = vinterp(wrfin,
field=to_np(tk),
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = vinterp(wrfin,
field=tk,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
tol = 0 / 100.
atol = 0.0001
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_tk_theta)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_tk_theta)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Tk to theta-e
fld_tk_theta_e = _get_refvals(referent, "fld_tk_theta_e", multi)
fld_tk_theta_e = np.squeeze(fld_tk_theta_e)
interp_levels = [200, 300, 500, 1000]
field = vinterp(wrfin,
field=tk,
vert_coord="theta-e",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_tk_theta_e, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_tk_theta_e)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Tk to pressure
fld_tk_pres = _get_refvals(referent, "fld_tk_pres", multi)
fld_tk_pres = np.squeeze(fld_tk_pres)
interp_levels = [850, 500]
field = vinterp(wrfin,
field=tk,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_tk_pres, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_tk_pres)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Tk to geoht_msl
fld_tk_ght_msl = _get_refvals(referent, "fld_tk_ght_msl", multi)
fld_tk_ght_msl = np.squeeze(fld_tk_ght_msl)
interp_levels = [1, 2]
field = vinterp(wrfin,
field=tk,
vert_coord="ght_msl",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_tk_ght_msl, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_tk_ght_msl)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Tk to geoht_agl
fld_tk_ght_agl = _get_refvals(referent, "fld_tk_ght_agl", multi)
fld_tk_ght_agl = np.squeeze(fld_tk_ght_agl)
interp_levels = [1, 2]
field = vinterp(wrfin,
field=tk,
vert_coord="ght_agl",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_tk_ght_agl, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_tk_ght_agl)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Hgt to pressure
fld_ht_pres = _get_refvals(referent, "fld_ht_pres", multi)
fld_ht_pres = np.squeeze(fld_ht_pres)
z = getvar(wrfin, "height", timeidx=timeidx, units="m")
interp_levels = [500, 50]
field = vinterp(wrfin,
field=z,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="ght",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_ht_pres, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_ht_pres)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Pressure to theta
fld_pres_theta = _get_refvals(referent, "fld_pres_theta", multi)
fld_pres_theta = np.squeeze(fld_pres_theta)
p = getvar(wrfin, "pressure", timeidx=timeidx)
interp_levels = [200, 300, 500, 1000]
field = vinterp(wrfin,
field=p,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="pressure",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_pres_theta, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_pres_theta)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
# Theta-e to pres
fld_thetae_pres = _get_refvals(referent, "fld_thetae_pres", multi)
fld_thetae_pres = np.squeeze(fld_thetae_pres)
eth = getvar(wrfin, "eth", timeidx=timeidx)
interp_levels = [850, 500, 5]
field = vinterp(wrfin,
field=eth,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="theta-e",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
try:
nt.assert_allclose(to_np(field), fld_thetae_pres, atol=.0001)
except AssertionError:
absdiff = np.abs(to_np(field) - fld_thetae_pres)
maxdiff = np.amax(absdiff)
print(maxdiff)
print(np.argwhere(absdiff == maxdiff))
raise
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except:
pass
try:
from PyNIO import Nio
except:
pass
if not multi:
timeidx = 0
if not pynio:
in_wrfnc = NetCDF(wrf_in)
else:
# Note: Python doesn't like it if you reassign an outer scoped
# variable (wrf_in in this case)
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
in_wrfnc = Nio.open_file(wrf_file)
else:
timeidx = None
if not pynio:
nc = NetCDF(wrf_in)
in_wrfnc = [nc for i in xrange(repeat)]
else:
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
nc = Nio.open_file(wrf_file)
in_wrfnc = [nc for i in xrange(repeat)]
if (varname == "interplevel"):
ref_ht_500 = _get_refvals(referent, "z_500", repeat, multi)
hts = getvar(in_wrfnc, "z", timeidx=timeidx)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
hts_500 = interplevel(hts, p, 500)
nt.assert_allclose(to_np(hts_500), ref_ht_500)
elif (varname == "vertcross"):
ref_ht_cross = _get_refvals(referent, "ht_cross", repeat, multi)
ref_p_cross = _get_refvals(referent, "p_cross", repeat, multi)
hts = getvar(in_wrfnc, "z", timeidx=timeidx)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
pivot_point = CoordPair(hts.shape[-1] / 2, hts.shape[-2] / 2)
ht_cross = vertcross(hts, p, pivot_point=pivot_point, angle=90.)
nt.assert_allclose(to_np(ht_cross), ref_ht_cross, rtol=.01)
# Test opposite
p_cross1 = vertcross(p, hts, pivot_point=pivot_point, angle=90.0)
nt.assert_allclose(to_np(p_cross1), ref_p_cross, rtol=.01)
# Test point to point
start_point = CoordPair(0, hts.shape[-2] / 2)
end_point = CoordPair(-1, hts.shape[-2] / 2)
p_cross2 = vertcross(p,
hts,
start_point=start_point,
end_point=end_point)
nt.assert_allclose(to_np(p_cross1), to_np(p_cross2))
elif (varname == "interpline"):
ref_t2_line = _get_refvals(referent, "t2_line", repeat, multi)
t2 = getvar(in_wrfnc, "T2", timeidx=timeidx)
pivot_point = CoordPair(t2.shape[-1] / 2, t2.shape[-2] / 2)
t2_line1 = interpline(t2, pivot_point=pivot_point, angle=90.0)
nt.assert_allclose(to_np(t2_line1), ref_t2_line)
# Test point to point
start_point = CoordPair(0, t2.shape[-2] / 2)
end_point = CoordPair(-1, t2.shape[-2] / 2)
t2_line2 = interpline(t2,
start_point=start_point,
end_point=end_point)
nt.assert_allclose(to_np(t2_line1), to_np(t2_line2))
elif (varname == "vinterp"):
# Tk to theta
fld_tk_theta = _get_refvals(referent, "fld_tk_theta", repeat,
multi)
fld_tk_theta = np.squeeze(fld_tk_theta)
tk = getvar(in_wrfnc, "temp", timeidx=timeidx, units="k")
interp_levels = [200, 300, 500, 1000]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
tol = 5 / 100.
atol = 0.0001
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_theta)))
nt.assert_allclose(to_np(field), fld_tk_theta, tol, atol)
# Tk to theta-e
fld_tk_theta_e = _get_refvals(referent, "fld_tk_theta_e", repeat,
multi)
fld_tk_theta_e = np.squeeze(fld_tk_theta_e)
interp_levels = [200, 300, 500, 1000]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="theta-e",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
tol = 3 / 100.
atol = 50.0001
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_theta_e)/fld_tk_theta_e)*100)
nt.assert_allclose(to_np(field), fld_tk_theta_e, tol, atol)
# Tk to pressure
fld_tk_pres = _get_refvals(referent, "fld_tk_pres", repeat, multi)
fld_tk_pres = np.squeeze(fld_tk_pres)
interp_levels = [850, 500]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_pres)))
nt.assert_allclose(to_np(field), fld_tk_pres, tol, atol)
# Tk to geoht_msl
fld_tk_ght_msl = _get_refvals(referent, "fld_tk_ght_msl", repeat,
multi)
fld_tk_ght_msl = np.squeeze(fld_tk_ght_msl)
interp_levels = [1, 2]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="ght_msl",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_ght_msl)))
nt.assert_allclose(to_np(field), fld_tk_ght_msl, tol, atol)
# Tk to geoht_agl
fld_tk_ght_agl = _get_refvals(referent, "fld_tk_ght_agl", repeat,
multi)
fld_tk_ght_agl = np.squeeze(fld_tk_ght_agl)
interp_levels = [1, 2]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="ght_agl",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_ght_agl)))
nt.assert_allclose(to_np(field), fld_tk_ght_agl, tol, atol)
# Hgt to pressure
fld_ht_pres = _get_refvals(referent, "fld_ht_pres", repeat, multi)
fld_ht_pres = np.squeeze(fld_ht_pres)
z = getvar(in_wrfnc, "height", timeidx=timeidx, units="m")
interp_levels = [500, 50]
field = vinterp(in_wrfnc,
field=z,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="ght",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_ht_pres)))
nt.assert_allclose(to_np(field), fld_ht_pres, tol, atol)
# Pressure to theta
fld_pres_theta = _get_refvals(referent, "fld_pres_theta", repeat,
multi)
fld_pres_theta = np.squeeze(fld_pres_theta)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
interp_levels = [200, 300, 500, 1000]
field = vinterp(in_wrfnc,
field=p,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="pressure",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_pres_theta)))
nt.assert_allclose(to_np(field), fld_pres_theta, tol, atol)
# Theta-e to pres
fld_thetae_pres = _get_refvals(referent, "fld_thetae_pres", repeat,
multi)
fld_thetae_pres = np.squeeze(fld_thetae_pres)
eth = getvar(in_wrfnc, "eth", timeidx=timeidx)
interp_levels = [850, 500, 5]
field = vinterp(in_wrfnc,
field=eth,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="theta-e",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_thetae_pres)))
nt.assert_allclose(to_np(field), fld_thetae_pres, tol, atol)
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except:
pass
try:
from PyNIO import Nio
except:
pass
if not multi:
timeidx = 0
if not pynio:
in_wrfnc = NetCDF(wrf_in)
else:
# Note: Python doesn't like it if you reassign an outer scoped
# variable (wrf_in in this case)
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
in_wrfnc = Nio.open_file(wrf_file)
else:
timeidx = None
if not pynio:
nc = NetCDF(wrf_in)
in_wrfnc = [nc for i in xrange(repeat)]
else:
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
nc = Nio.open_file(wrf_file)
in_wrfnc = [nc for i in xrange(repeat)]
refnc = NetCDF(referent)
if testid == "xy":
# Since this domain is not moving, the reference values are the
# same whether there are multiple or single files
ref_vals = refnc.variables["ij"][:]
# Lats/Lons taken from NCL script, just hard-coding for now
lats = [-55, -60, -65]
lons = [25, 30, 35]
# Just call with a single lat/lon
if single:
xy = ll_to_xy(in_wrfnc, lats[0], lons[0])
xy = xy + 1 # NCL uses fortran indexing
ref = ref_vals[:, 0]
nt.assert_allclose(to_np(xy), ref)
# Next make sure the 'proj' version works
projparams = extract_proj_params(in_wrfnc)
xy_proj = ll_to_xy_proj(lats[0], lons[0], **projparams)
nt.assert_allclose(to_np(xy_proj), to_np(xy - 1))
else:
xy = ll_to_xy(in_wrfnc, lats, lons)
xy = xy + 1 # NCL uses fortran indexing
ref = ref_vals[:]
nt.assert_allclose(to_np(xy), ref)
# Next make sure the 'proj' version works
projparams = extract_proj_params(in_wrfnc)
xy_proj = ll_to_xy_proj(lats, lons, **projparams)
nt.assert_allclose(to_np(xy_proj), to_np(xy - 1))
else:
# Since this domain is not moving, the reference values are the
# same whether there are multiple or single files
ref_vals = refnc.variables["ll"][:]
# i_s, j_s taken from NCL script, just hard-coding for now
# NCL uses 1-based indexing for this, so need to subtract 1
i_s = np.asarray([10, 100, 150], int) - 1
j_s = np.asarray([10, 100, 150], int) - 1
if single:
ll = xy_to_ll(in_wrfnc, i_s[0], j_s[0])
ref = ref_vals[::-1, 0]
nt.assert_allclose(to_np(ll), ref)
# Next make sure the 'proj' version works
projparams = extract_proj_params(in_wrfnc)
ll_proj = xy_to_ll_proj(i_s[0], j_s[0], **projparams)
nt.assert_allclose(to_np(ll_proj), to_np(ll))
else:
ll = xy_to_ll(in_wrfnc, i_s, j_s)
ref = ref_vals[::-1, :]
nt.assert_allclose(to_np(ll), ref)
# Next make sure the 'proj' version works
projparams = extract_proj_params(in_wrfnc)
ll_proj = xy_to_ll_proj(i_s, j_s, **projparams)
nt.assert_allclose(to_np(ll_proj), to_np(ll))
def make_test(wrf_file=None, fixed_case=None):
if wrf_file is not None:
ncfile = NetCDF(wrf_file)
lats, lons, proj_params = get_proj_params(ncfile)
proj = getproj(lats=lats, lons=lons, **proj_params)
name_suffix = basename(wrf_file)
elif fixed_case is not None:
name_suffix = fixed_case
if fixed_case == "south_rot":
lats, lons, proj = nz_proj()
elif fixed_case == "arg_rot":
lats, lons, proj = argentina_proj()
elif fixed_case == "south_polar":
lats, lons, proj = south_polar_proj()
elif fixed_case == "north_polar":
lats, lons, proj = north_polar_proj()
elif fixed_case == "dateline_rot":
lats, lons, proj = dateline_rot_proj()
print("wrf proj4: {}".format(proj.proj4()))
if PYNGL:
# PyNGL plotting
wks_type = bytes("png")
wks = Ngl.open_wks(wks_type, bytes("pyngl_{}".format(name_suffix)))
mpres = proj.pyngl()
map = Ngl.map(wks, mpres)
Ngl.delete_wks(wks)
if BASEMAP:
# Basemap plotting
fig = plt.figure(figsize=(10, 10))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
# Define and plot the meridians and parallels
min_lat = np.amin(lats)
max_lat = np.amax(lats)
min_lon = np.amin(lons)
max_lon = np.amax(lons)
parallels = np.arange(np.floor(min_lat), np.ceil(max_lat),
(max_lat - min_lat) / 5.0)
meridians = np.arange(np.floor(min_lon), np.ceil(max_lon),
(max_lon - min_lon) / 5.0)
bm = proj.basemap()
bm.drawcoastlines(linewidth=.5)
#bm.drawparallels(parallels,labels=[1,1,1,1],fontsize=10)
#bm.drawmeridians(meridians,labels=[1,1,1,1],fontsize=10)
print("basemap proj4: {}".format(bm.proj4string))
plt.savefig("basemap_{}.png".format(name_suffix))
plt.close(fig)
if CARTOPY:
# Cartopy plotting
fig = plt.figure(figsize=(10, 10))
ax = plt.axes([0.1, 0.1, 0.8, 0.8], projection=proj.cartopy())
print("cartopy proj4: {}".format(proj.cartopy().proj4_params))
ax.coastlines('50m', linewidth=0.8)
#print proj.x_extents()
#print proj.y_extents()
ax.set_xlim(proj.cartopy_xlim())
ax.set_ylim(proj.cartopy_ylim())
ax.gridlines()
plt.savefig("cartopy_{}.png".format(name_suffix))
plt.close(fig)
def __loaded_mask(self):
# TODO: clear this somehow
nc_file = NetCDF('../bathy_meter_mask.nc')
mask = nc_file.variables['Bathymetry'][:]
nc_file.close()
return mask
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except:
pass
try:
from PyNIO import Nio
except:
pass
if not multi:
timeidx = 0
if not pynio:
in_wrfnc = NetCDF(wrf_in)
else:
# Note: Python doesn't like it if you reassign an outer scoped
# variable (wrf_in in this case)
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
in_wrfnc = Nio.open_file(wrf_file)
else:
timeidx = None
if not pynio:
nc = NetCDF(wrf_in)
in_wrfnc = [nc for i in xrange(repeat)]
else:
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
nc = Nio.open_file(wrf_file)
in_wrfnc = [nc for i in xrange(repeat)]
refnc = NetCDF(referent)
# These have a left index that defines the product type
multiproduct = varname in ("uvmet", "uvmet10", "cape_2d", "cape_3d",
"cfrac")
if not multi:
ref_vals = refnc.variables[varname][:]
else:
data = refnc.variables[varname][:]
if (varname != "uvmet" and varname != "uvmet10"
and varname != "cape_2d" and varname != "cape_3d"):
new_dims = [repeat] + [x for x in data.shape]
elif (varname == "uvmet" or varname == "uvmet10"
or varname == "cape_3d"):
new_dims = [2] + [repeat] + [x for x in data.shape[1:]]
elif (varname == "cape_2d"):
new_dims = [4] + [repeat] + [x for x in data.shape[1:]]
elif (varname == "cfrac"):
new_dims = [3] + [repeat] + [x for x in data.shape[1:]]
masked = False
if (isinstance(data, ma.core.MaskedArray)):
masked = True
if not masked:
ref_vals = np.zeros(new_dims, data.dtype)
else:
ref_vals = ma.asarray(np.zeros(new_dims, data.dtype))
for i in xrange(repeat):
if not multiproduct:
ref_vals[i, :] = data[:]
if masked:
ref_vals.mask[i, :] = data.mask[:]
else:
for prod in xrange(ref_vals.shape[0]):
ref_vals[prod, i, :] = data[prod, :]
if masked:
ref_vals.mask[prod, i, :] = data.mask[prod, :]
if (varname == "tc"):
my_vals = getvar(in_wrfnc, "temp", timeidx=timeidx, units="c")
tol = 1 / 100.
atol = .1 # Note: NCL uses 273.16 as conversion for some reason
nt.assert_allclose(to_np(my_vals), ref_vals, tol, atol)
elif (varname == "pw"):
my_vals = getvar(in_wrfnc, "pw", timeidx=timeidx)
tol = .5 / 100.0
atol = 0 # NCL uses different constants and doesn't use same
# handrolled virtual temp in method
nt.assert_allclose(to_np(my_vals), ref_vals, tol, atol)
elif (varname == "cape_2d"):
cape_2d = getvar(in_wrfnc, varname, timeidx=timeidx)
tol = 0 / 100.
atol = 200.0
# Let's only compare CAPE values until the F90 changes are
# merged back in to NCL. The modifications to the R and CP
# changes TK enough that non-lifting parcels could lift, thus
# causing wildly different values in LCL
nt.assert_allclose(to_np(cape_2d[0, :]), ref_vals[0, :], tol, atol)
elif (varname == "cape_3d"):
cape_3d = getvar(in_wrfnc, varname, timeidx=timeidx)
# Changing the R and CP constants, while keeping TK within
# 2%, can lead to some big changes in CAPE. Tolerances
# have been set wide when comparing the with the original
# NCL. Change back when the F90 code is merged back with
# NCL
tol = 0 / 100.
atol = 200.0
#print np.amax(np.abs(to_np(cape_3d[0,:]) - ref_vals[0,:]))
nt.assert_allclose(to_np(cape_3d), ref_vals, tol, atol)
else:
my_vals = getvar(in_wrfnc, varname, timeidx=timeidx)
tol = 2 / 100.
atol = 0.1
#print (np.amax(np.abs(to_np(my_vals) - ref_vals)))
nt.assert_allclose(to_np(my_vals), ref_vals, tol, atol)
def join_csv_files(dir_list,
output_file_path,
extract_rainfall=True,
forecast_date=None,
station_data=None):
# def join_csv_files(dir_list, output_file_path, extract_rainfall=True):
"""
Joins a list of CSV files into one NetCDF file that's compatible with pSIMS' format.
:param dir_list: The list of paths
:param output_file_path: Output file path, should be absolute.
:param extract_rainfall: Wether to extract rainfall data from weather series or not.
:param forecast_date: Only used it extract_rainfall is True.
:return: A dictionary if extract_rainfall is True, None otherwise.
"""
proc_start_time = time.time()
necdf_file_name = "%s_%s.psims.nc" % (station_data['grid_row'],
station_data['grid_column'])
nectdf_file_path = os.path.join(output_file_path, necdf_file_name)
output_file = NetCDF(nectdf_file_path, 'w')
csv_files = dir_list
# If there's only one scenario, we call it '0' internally. Though the NetCDF output file won't have the
# 'scen' dimension defined. This is needed when we extract rainfall data.
scen_names = [0]
if len(csv_files) > 1:
# If there's more than one file, we extract the scenario name (the year of the climate series).
scen_names = [
CSVDatabaseWeatherSeries.__scen_name__(i) for i in csv_files
]
expected_variables = {'fecha', 'rad', 'tmax', 'tmin', 'prcp'}
var_units = {"rad": "MJm-2", "tmax": "C", "tmin": "C", "prcp": "mm"}
# Define base dimensions, it's contents and units.
dims = ['latitude', 'longitude', 'time']
dim_var_contents = [[0], [0], []]
dims_units = [
'degrees_east', 'degrees_north',
'days since %s 00:00:00' % WeatherNetCDFWriter.reference_date
]
rainfall_data = None
# Add scen dimension in case there is more than one weather file.
if len(csv_files) > 1:
dims = dims + ['scen']
dim_var_contents += [scen_names]
dims_units += ['Scenarios']
# Create dimensions.
for index, dim in enumerate(dims):
output_file.createDimension(dim)
dim_var = output_file.createVariable(dim, 'int32', (dim, ))
dim_var.units = dims_units[index]
dim_var[:] = dim_var_contents[index]
variables_contents = {}
time_var_content = []
# Parse reference_date (str) to date.
ref_date = datetime.strptime(WeatherNetCDFWriter.reference_date,
'%Y-%m-%d')
# Calculate forecast date as time difference (in days).
if forecast_date:
forecast_date = datetime.strptime(forecast_date, '%Y-%m-%d')
forecast_date = forecast_date - ref_date
forecast_date = forecast_date.days
# Loop through CSV weather files.
for scen_index, f in enumerate(csv_files):
# Unpack dictionary entry: (key, value).
scen_name = scen_names[scen_index]
csv_file = csv.reader(open(f), delimiter='\t')
csv_variables = []
csv_content = dict()
for r_index, row in enumerate(csv_file):
if r_index == 0:
# Header
csv_variables = row
# Check that the header variables match the expected variables.
if len(expected_variables.intersection(
csv_variables)) != len(expected_variables):
raise RuntimeError(
"The variables in the CSV file \"%s\" don't match the expected ones (%s)."
% (csv_files[scen_index], expected_variables))
for column in row:
csv_content[column] = []
else:
for i, value in enumerate(row):
var_name = csv_variables[i]
csv_content[var_name].append(value)
csv_content['time'] = csv_content['fecha']
del csv_content['fecha']
# Calculate time diff in days for each date.
for i, day in enumerate(csv_content['time']):
day = datetime.strptime(day, '%Y-%m-%d')
delta = day - ref_date
csv_content['time'][i] = delta.days
# Initialize the content of the time variable for it to be written once we finish
# writting the other variables.
if len(time_var_content) == 0:
time_var_content = copy.deepcopy(csv_content['time'])
else:
# If it's already initialized, check that every CSV file has data for the same days.
if time_var_content != csv_content['time']:
raise RuntimeError("Dates do not match between CSV files.")
# Delete this variable to avoid trying to write it to the NetCDF file.
del csv_content['time']
# Loop through each variable in the CSV header.
for var_name in list(csv_content.keys()):
if var_name not in expected_variables:
continue
if var_name in variables_contents:
var_array = variables_contents[var_name]
else:
# Initialize this variable.
shape = (len(csv_content[var_name]), 1, 1)
if len(csv_files) > 1:
shape = (len(csv_files), ) + shape
var_array = np.empty(shape=shape)
var_array.fill(-99)
variables_contents[var_name] = var_array
# Write variable content.
if len(csv_files) > 1:
# The file index will be the scenario number.
var_array[scen_index, 0:len(csv_content[var_name]), 0,
0] = csv_content[var_name]
else:
var_array[:, 0, 0] = csv_content[var_name]
# Create the dimensions tuple to create variables in the NetCDF file.
dims = ('time', 'latitude', 'longitude')
if len(csv_files) > 1:
dims = ('scen', ) + dims
start_time = time.time()
# Write variables to the NetCDF file.
for var_name in variables_contents:
netcdf_var = output_file.createVariable(var_name,
'float32',
dims,
fill_value=-99)
netcdf_var.units = var_units[var_name]
netcdf_var[:] = variables_contents[var_name]
# Check if we need to extract rainfall data.
if extract_rainfall:
rainfall_data = dict()
rain_variable = variables_contents['prcp']
# Convert time variable to Numpy array, otherwise we can't use array indexes.
time_var_content = np.array(time_var_content)
# Again, check if there's more than one climate serie.
if len(csv_files) > 1:
# Extract rainfall data until the date of forecast.
pre_forecast_time = time_var_content[
time_var_content <= forecast_date]
rain = rain_variable[0, 0:len(pre_forecast_time), 0, 0]
rainy_days = np.where(rain > 0)[0]
rainfall_data['0'] = {
'dates': pre_forecast_time[rainy_days].tolist(),
'values': rain[rainy_days].tolist()
}
# Extract rainfall data for each scenario after the forecast date.
for i, year in enumerate(scen_names):
post_forecast_time = time_var_content[
time_var_content > forecast_date]
post_forecast_start = len(time_var_content) - len(
post_forecast_time)
rain = rain_variable[i, post_forecast_start:, 0, 0]
rainy_days = np.where(rain > 0)[0]
rainfall_data[str(year)] = {
'dates': post_forecast_time[rainy_days].tolist(),
'values': rain[rainy_days].tolist()
}
else:
rain = rain_variable[:, 0, 0]
rainy_days = np.where(rain > 0)[0]
rainfall_data['0'] = {
'dates': time_var_content[rainy_days].tolist(),
'values': rain[rainy_days].tolist()
}
time_var = output_file.variables['time']
time_var[:] = time_var_content
output_file.close()
logging.getLogger().debug('Write NetCDF file: %f.' %
(time.time() - start_time))
logging.getLogger().debug("NetCDF file created: '%s'. Time: %s." %
(output_file_path,
(time.time() - proc_start_time)))
result = os.path.exists(nectdf_file_path)
return result, rainfall_data
def main():
wrfnc = NetCDF("/Users/bladwig/wrfout_d03_2003-05-07_09:00:00")
# Cape NO RESULTS FOR LCL OR LFC
cape, cin, lcl, lfc = w.getvar(wrfnc, "cape2d")
#cape, cin = w.getvar(wrfnc, "cape3d")
print n.amax(cape)
print n.amax(cin)
print n.amax(lcl)
print n.amax(lfc)
# DBZ
dbz = w.getvar(wrfnc, "dbz")
print n.amax(dbz)
# DP
dp = w.getvar(wrfnc, "dp", units="f")
print n.amax(dp)
dp2 = w.getvar(wrfnc, "dp2m", units="f")
print n.amax(dp2)
# Height
ht = w.getvar(wrfnc, "height", msl=False, units="m")
print n.amax(ht)
geopt = w.getvar(wrfnc, "geopt")
print n.amax(geopt)
# Helicity
srh = w.getvar(wrfnc, "srh")
print n.amax(srh)
uhel = w.getvar(wrfnc, "uhel")
print n.amax(uhel)
# Omega (Not sure if this is correct, and units aren't C)
omega = w.getvar(wrfnc, "omega")
print n.amax(omega)
# Precip Water (NOT SURE)
pw = w.getvar(wrfnc, "pw")
print n.amax(pw)
# RH
rh = w.getvar(wrfnc, "rh")
print n.amax(rh)
rh2 = w.getvar(wrfnc, "rh2m")
print n.amax(rh2)
# SLP
slp = w.getvar(wrfnc, "slp", units="hpa")
print n.amax(slp)
# TEMP
t = w.getvar(wrfnc, "temp", units="f")
print n.amax(t)
# ETH VALUES SEEM HIGH....
eth = w.getvar(wrfnc, "theta_e", units="k")
print n.amax(eth)
tv = w.getvar(wrfnc, "tv", units="k")
print n.amax(tv)
# Note: NCL says this is in 'C', but appears to be 'K'
tw = w.getvar(wrfnc, "tw", units="f")
print n.amax(tw)
# WIND
umet,vmet = w.getvar(wrfnc, "uvmet", units="kts")
print n.amax(umet)
print n.amax(vmet)
umet10,vmet10 = w.getvar(wrfnc, "uvmet10", units="kts")
print n.amax(umet10)
print n.amax(vmet10)
# TERRAIN
ter = w.getvar(wrfnc, "terrain", units="dm")
print n.amax(ter)
# VORTICITY
avo = w.getvar(wrfnc, "avo")
print n.amax(avo)
pvo = w.getvar(wrfnc, "pvo")
print n.amax(pvo)
# LAT/LON
lat = w.getvar(wrfnc, "lat")
print n.amax(lat)
print n.amin(lat)
lon = w.getvar(wrfnc, "lon")
print n.amax(lon)
print n.amin(lon)
i,j = w.get_ij(wrfnc, -97.516540, 35.467787)
print i,j
lon, lat = w.get_ll(wrfnc, 33.5, 33.5)
print lon, lat
#ETA -- Result somewhat different than geopt
z = w.convert_eta(wrfnc, msl=False, units="m")
print n.amax(z)
diff = n.abs(z - ht)/ht * 100.0
print n.amin(diff), n.amax(diff)
def test(self):
try:
from netCDF4 import Dataset as NetCDF
except:
pass
try:
from PyNIO import Nio
except:
pass
if not multi:
timeidx = 0
if not pynio:
in_wrfnc = NetCDF(wrf_in)
else:
# Note: Python doesn't like it if you reassign an outer scoped
# variable (wrf_in in this case)
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
in_wrfnc = Nio.open_file(wrf_file)
else:
timeidx = None
if not pynio:
nc = NetCDF(wrf_in)
in_wrfnc = [nc for i in xrange(repeat)]
else:
if not wrf_in.endswith(".nc"):
wrf_file = wrf_in + ".nc"
else:
wrf_file = wrf_in
nc = Nio.open_file(wrf_file)
in_wrfnc = [nc for i in xrange(repeat)]
if (varname == "interplevel"):
ref_ht_500 = _get_refvals(referent, "z_500", repeat, multi)
hts = getvar(in_wrfnc, "z", timeidx=timeidx)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
# Make sure the numpy versions work first
hts_500 = interplevel(to_np(hts), to_np(p), 500)
hts_500 = interplevel(hts, p, 500)
nt.assert_allclose(to_np(hts_500), ref_ht_500)
elif (varname == "vertcross"):
ref_ht_cross = _get_refvals(referent, "ht_cross", repeat, multi)
ref_p_cross = _get_refvals(referent, "p_cross", repeat, multi)
hts = getvar(in_wrfnc, "z", timeidx=timeidx)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
pivot_point = CoordPair(hts.shape[-1] / 2, hts.shape[-2] / 2)
#ht_cross = vertcross(to_np(hts), p, pivot_point=pivot_point,
# angle=90., latlon=True)
# Make sure the numpy versions work first
ht_cross = vertcross(to_np(hts),
to_np(p),
pivot_point=pivot_point,
angle=90.)
ht_cross = vertcross(hts, p, pivot_point=pivot_point, angle=90.)
# Note: Until the bug is fixed in NCL, the wrf-python cross
# sections will contain one extra point
nt.assert_allclose(to_np(ht_cross)[..., 0:-1],
ref_ht_cross,
rtol=.01)
# Test the manual projection method with lat/lon
lats = hts.coords["XLAT"]
lons = hts.coords["XLONG"]
ll_point = ll_points(lats, lons)
pivot = CoordPair(lat=lats[int(lats.shape[-2] / 2),
int(lats.shape[-1] / 2)],
lon=lons[int(lons.shape[-2] / 2),
int(lons.shape[-1] / 2)])
v1 = vertcross(hts,
p,
wrfin=in_wrfnc,
pivot_point=pivot_point,
angle=90.0)
v2 = vertcross(hts,
p,
projection=hts.attrs["projection"],
ll_point=ll_point,
pivot_point=pivot_point,
angle=90.)
nt.assert_allclose(to_np(v1), to_np(v2), rtol=.01)
# Test opposite
p_cross1 = vertcross(p, hts, pivot_point=pivot_point, angle=90.0)
nt.assert_allclose(to_np(p_cross1)[..., 0:-1],
ref_p_cross,
rtol=.01)
# Test point to point
start_point = CoordPair(0, hts.shape[-2] / 2)
end_point = CoordPair(-1, hts.shape[-2] / 2)
p_cross2 = vertcross(p,
hts,
start_point=start_point,
end_point=end_point)
nt.assert_allclose(to_np(p_cross1), to_np(p_cross2))
elif (varname == "interpline"):
ref_t2_line = _get_refvals(referent, "t2_line", repeat, multi)
t2 = getvar(in_wrfnc, "T2", timeidx=timeidx)
pivot_point = CoordPair(t2.shape[-1] / 2, t2.shape[-2] / 2)
#t2_line1 = interpline(to_np(t2), pivot_point=pivot_point,
# angle=90.0, latlon=True)
# Make sure the numpy version works
t2_line1 = interpline(to_np(t2),
pivot_point=pivot_point,
angle=90.0)
t2_line1 = interpline(t2, pivot_point=pivot_point, angle=90.0)
# Note: After NCL is fixed, remove the slice.
nt.assert_allclose(to_np(t2_line1)[..., 0:-1], ref_t2_line)
# Test the manual projection method with lat/lon
lats = t2.coords["XLAT"]
lons = t2.coords["XLONG"]
ll_point = ll_points(lats, lons)
pivot = CoordPair(lat=lats[int(lats.shape[-2] / 2),
int(lats.shape[-1] / 2)],
lon=lons[int(lons.shape[-2] / 2),
int(lons.shape[-1] / 2)])
l1 = interpline(t2,
wrfin=in_wrfnc,
pivot_point=pivot_point,
angle=90.0)
l2 = interpline(t2,
projection=t2.attrs["projection"],
ll_point=ll_point,
pivot_point=pivot_point,
angle=90.)
nt.assert_allclose(to_np(l1), to_np(l2), rtol=.01)
# Test point to point
start_point = CoordPair(0, t2.shape[-2] / 2)
end_point = CoordPair(-1, t2.shape[-2] / 2)
t2_line2 = interpline(t2,
start_point=start_point,
end_point=end_point)
nt.assert_allclose(to_np(t2_line1), to_np(t2_line2))
elif (varname == "vinterp"):
# Tk to theta
fld_tk_theta = _get_refvals(referent, "fld_tk_theta", repeat,
multi)
fld_tk_theta = np.squeeze(fld_tk_theta)
tk = getvar(in_wrfnc, "temp", timeidx=timeidx, units="k")
interp_levels = [200, 300, 500, 1000]
# Make sure the numpy version works
field = vinterp(in_wrfnc,
field=to_np(tk),
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = vinterp(in_wrfnc,
field=tk,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
tol = 5 / 100.
atol = 0.0001
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_theta)))
nt.assert_allclose(to_np(field), fld_tk_theta, tol, atol)
# Tk to theta-e
fld_tk_theta_e = _get_refvals(referent, "fld_tk_theta_e", repeat,
multi)
fld_tk_theta_e = np.squeeze(fld_tk_theta_e)
interp_levels = [200, 300, 500, 1000]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="theta-e",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
tol = 3 / 100.
atol = 50.0001
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_theta_e)/fld_tk_theta_e)*100)
nt.assert_allclose(to_np(field), fld_tk_theta_e, tol, atol)
# Tk to pressure
fld_tk_pres = _get_refvals(referent, "fld_tk_pres", repeat, multi)
fld_tk_pres = np.squeeze(fld_tk_pres)
interp_levels = [850, 500]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_pres)))
nt.assert_allclose(to_np(field), fld_tk_pres, tol, atol)
# Tk to geoht_msl
fld_tk_ght_msl = _get_refvals(referent, "fld_tk_ght_msl", repeat,
multi)
fld_tk_ght_msl = np.squeeze(fld_tk_ght_msl)
interp_levels = [1, 2]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="ght_msl",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_ght_msl)))
nt.assert_allclose(to_np(field), fld_tk_ght_msl, tol, atol)
# Tk to geoht_agl
fld_tk_ght_agl = _get_refvals(referent, "fld_tk_ght_agl", repeat,
multi)
fld_tk_ght_agl = np.squeeze(fld_tk_ght_agl)
interp_levels = [1, 2]
field = vinterp(in_wrfnc,
field=tk,
vert_coord="ght_agl",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_tk_ght_agl)))
nt.assert_allclose(to_np(field), fld_tk_ght_agl, tol, atol)
# Hgt to pressure
fld_ht_pres = _get_refvals(referent, "fld_ht_pres", repeat, multi)
fld_ht_pres = np.squeeze(fld_ht_pres)
z = getvar(in_wrfnc, "height", timeidx=timeidx, units="m")
interp_levels = [500, 50]
field = vinterp(in_wrfnc,
field=z,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="ght",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_ht_pres)))
nt.assert_allclose(to_np(field), fld_ht_pres, tol, atol)
# Pressure to theta
fld_pres_theta = _get_refvals(referent, "fld_pres_theta", repeat,
multi)
fld_pres_theta = np.squeeze(fld_pres_theta)
p = getvar(in_wrfnc, "pressure", timeidx=timeidx)
interp_levels = [200, 300, 500, 1000]
field = vinterp(in_wrfnc,
field=p,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="pressure",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_pres_theta)))
nt.assert_allclose(to_np(field), fld_pres_theta, tol, atol)
# Theta-e to pres
fld_thetae_pres = _get_refvals(referent, "fld_thetae_pres", repeat,
multi)
fld_thetae_pres = np.squeeze(fld_thetae_pres)
eth = getvar(in_wrfnc, "eth", timeidx=timeidx)
interp_levels = [850, 500, 5]
field = vinterp(in_wrfnc,
field=eth,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="theta-e",
timeidx=timeidx,
log_p=True)
field = np.squeeze(field)
#print (np.amax(np.abs(to_np(field) - fld_thetae_pres)))
nt.assert_allclose(to_np(field), fld_thetae_pres, tol, atol)
