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 zlevs_interp(path_in, path_out, path_geo, syear, eyear, smonth, emonth,
zlevs, patt, patt_wrf, dom, wrun, varn):
fullpathin = path_in + "/" + wrun + "/out"
fullpathout = path_out + "/" + wrun + "/" + str(syear) + "-" + str(eyear)
geofile = nc.Dataset("%s/geo_em.d01.Oned_32km_ERA5.nc" % (path_geo))
y = syear
m = smonth
d = 1
while (y < eyear or (y == eyear and m <= emonth)):
sdate = "%s-%s-%s" % (y, str(m).rjust(2, "0"), str(d).rjust(2, "0"))
filesin_wrf = sorted(
glob('%s/%s/out/%s_%s_%s*' %
(path_in, wrun, patt_wrf, dom, sdate)))
z = []
t = []
for thour in range(len(filesin_wrf)):
fwrf = nc.Dataset(filesin_wrf[thour])
fwrf.variables['F'] = geofile.variables['F']
tFragment = wrftime2date(filesin_wrf[thour].split())[:]
field, atts = cvars.compute_WRFvar(filesin_wrf[thour], varn)
zFragment = wrf.vinterp(fwrf,
np.squeeze(field),
vert_coord='ght_agl',
interp_levels=zlevs)
zFragment = np.expand_dims(zFragment, axis=0)
z.append(zFragment)
t.append(tFragment)
fieldint = np.concatenate(z, axis=0)
otimes = np.concatenate(t, axis=0)
varinfo = {
'values': fieldint,
'varname': varn,
'zlevs': zlevs,
'atts': atts,
'lat': fwrf.variables['XLAT'][0, :],
'lon': fwrf.variables['XLONG'][0, :],
'times': otimes
}
fileout = "%s/%s_ZLEVS_%s_%s.nc" % (fullpathout, patt, varn, sdate)
create_zlevs_netcdf(varinfo, fileout)
edate = otimes[-1] + dt.timedelta(days=1)
y = edate.year
m = edate.month
d = edate.day
def plevs_interp_byday(fullpathin, fullpathout, path_geo, date, plevs, patt,
patt_wrf, dom, wrun, varn):
# fullpathin = path_in + "/" + wrun + "/out"
# fullpathout = path_out + "/" + wrun + "/" + str(syear) + "-" + str(eyear)
geofile = nc.Dataset("%s/geo_em.d01.Oned_32km_ERA5.nc" % (path_geo))
y = date.year
m = date.month
d = date.day
print(y, m, d)
sdate = "%s-%s-%s" % (y, str(m).rjust(2, "0"), str(d).rjust(2, "0"))
filesin_wrf = sorted(
glob('%s/%s_%s_%s*' % (fullpathin, patt_wrf, dom, sdate)))
z = []
t = []
for thour in range(len(filesin_wrf)):
fwrf = nc.Dataset(filesin_wrf[thour])
fwrf.variables['F'] = geofile.variables['F']
tFragment = wrftime2date(filesin_wrf[thour].split())[:]
field, atts = cvars.compute_WRFvar(filesin_wrf[thour], varn)
zFragment = wrf.vinterp(fwrf,
np.squeeze(field),
vert_coord='pressure',
interp_levels=plevs)
zFragment = np.expand_dims(zFragment, axis=0)
z.append(zFragment)
t.append(tFragment)
fieldint = np.concatenate(z, axis=0)
otimes = np.concatenate(t, axis=0)
varinfo = {
'values': fieldint,
'varname': varn,
'plevs': plevs,
'atts': atts,
'lat': fwrf.variables['XLAT'][0, :],
'lon': fwrf.variables['XLONG'][0, :],
'times': otimes
}
fileout = "%s/%s_PLEVS_%s_%s.nc" % (fullpathout, patt, varn, sdate)
create_plevs_netcdf(varinfo, fileout)
def test(self):
# Only testing vinterp since other interpolation just use variables
if (varname == "vinterp"):
for timeidx in (0, None):
eth = getvar(wrf_in, "eth", timeidx=timeidx)
interp_levels = [850, 500, 5]
field = vinterp(wrf_in,
field=eth,
vert_coord="pressure",
interp_levels=interp_levels,
extrapolate=True,
field_type="theta-e",
timeidx=timeidx,
log_p=True)
else:
pass
def getdata(str_id, interp=False, height=1):
""" Reads in data and interoplates onto fixed horizontal levels """
files = [Dataset(datapath+f) for f in os.listdir(datapath) \
if f.startswith('wrfout_xhka')]
X = wrf.getvar(files,
str_id,
timeidx=wrf.ALL_TIMES,
method='join',
meta=False)
if str_id.startswith('wspd_wdir'):
X = X[0, ]
if interp:
z = wrf.getvar(files,
'z',
timeidx=wrf.ALL_TIMES,
method='join',
meta=False)
z = z / 1000 #convert to km
nz = z.shape[1]
zmin = np.min(np.max(z, axis=(2, 3)))
zmax = np.max(np.min(z, axis=(2, 3)))
if height < zmin or height > zmax:
print(
" Warning: Height not in appropriate range. \n Must be between "
+ str(zmin) + " and " + str(zmax))
print('Interpolating vertically.')
X = wrf.vinterp(files,
field=X,
vert_coord='ght_msl',
interp_levels=[height],
timeidx=wrf.ALL_TIMES)
X = X[:, 0,
] #The height coordinate should have dimension 1, so we remove it
nanwarning(X)
return X
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 main():
# Get files from command line or take hard-coded folder.
# Arguements are optional, but if one is specified, they all should be
# vertical_profile_plots.py [input_pattern] [output_directory] [num_threads]
# you can use a wildcard pattern:
# i.e., python vertical_profile_plots.py ../output_files/wrfout* ../plots/ 8
# or you can list the input files:
# i.e., python vertical_profile_plots.py ../output_files/wrfout_d01 ../output_files/wrfout_d02 ../plots/ 1
if len(sys.argv) > 1:
filenames = sys.argv[1:-2] #glob.glob(sys.argv[1])
print(filenames)
output_dir = sys.argv[-2]
wrf.omp_set_num_threads(int(sys.argv[-1]))
else:
filenames = glob.glob(
"/project/ssmith_uksr/WRF_ARW/cases/eclipse_2017/eclipse_model_on_5_dom_out/wrfout_d01*"
)
output_dir = ''
# Get data from published sensor data
ws_workbook = xlrd.open_workbook(
'/project/ssmith_uksr/WRF_ARW/DATA/2017_eclipse_observed/Weather_Station_data.xlsx'
)
ws_first_sheet = ws_workbook.sheet_by_index(0)
tower_workbook = xlrd.open_workbook(
'/project/ssmith_uksr/WRF_ARW/DATA/2017_eclipse_observed/Tower_data.xlsx'
)
tower_first_sheet = tower_workbook.sheet_by_index(0)
soil_workbook = xlrd.open_workbook(
'/project/ssmith_uksr/WRF_ARW/DATA/2017_eclipse_observed/Soil_data.xlsx'
)
soil_first_sheet = soil_workbook.sheet_by_index(0)
time_ws, temp_ws, rad_ws, wspd_ws, wdir_ws = get_observed_series(
ws_first_sheet)
time_tower, temp_tower, _, wspd_tower, wdir_tower = get_observed_series(
tower_first_sheet)
time_soil, temp_soil, _, _, _ = get_observed_series(soil_first_sheet)
# Coordinates to take sample from
center_lat = 36.797326
center_lon = -86.812341
for filename in sorted(filenames):
print(filename)
#Structure the WRF output file
ncfile = Dataset(filename)
#Extract data from WRF output files
tc = wrf.getvar(ncfile, "tc",
wrf.ALL_TIMES) # Atmospheric temperature in celsius
t2 = wrf.getvar(ncfile, "T2",
wrf.ALL_TIMES) # Temperature at 2 m, in Kelvin
# Convert T2 to degrees C
t2 = t2 - 273.15
t2.attrs["units"] = "degC"
theta = wrf.getvar(ncfile, "theta", wrf.ALL_TIMES, units="degC")
rh = wrf.getvar(ncfile, "rh", wrf.ALL_TIMES)
wspd_wdir = wrf.getvar(ncfile, "uvmet_wspd_wdir", wrf.ALL_TIMES)
# Split wind speed and direction
wspd = wspd_wdir[0, :, :, :, :]
wdir = wspd_wdir[1, :, :, :, :]
# These variables aren't included in getvar, so have to be extracted manually
swdown = wrf.extract_vars(ncfile, wrf.ALL_TIMES,
"SWDOWN").get('SWDOWN')
gnd_flx = wrf.extract_vars(ncfile, wrf.ALL_TIMES,
"GRDFLX").get('GRDFLX')
#Create Dictionary to associate quanitity names with the corresponding data
two_dim_vars = {'swdown': swdown, 'gnd_flx': gnd_flx, 'T2': t2}
three_dim_vars = {'tc': tc, 'theta': theta, 'rh': rh, 'wspd': wspd}
#Get the grid coordinates from our earth lat/long coordinates
center_x, center_y = wrf.ll_to_xy(ncfile, center_lat, center_lon)
# Plot all 3D variables over time
for var_name, var_data in three_dim_vars.items():
# Convert to Local Time
var_data = to_local_time(var_data)
# Get data frequency
freq = pd.Timedelta(var_data["Time"][1].values -
var_data["Time"][0].values)
# Interpolate to height above ground level
try:
var_data_agl = wrf.vinterp(ncfile,
var_data,
'ght_agl',
np.linspace(0, 0.1, 100),
field_type=var_name,
timeidx=wrf.ALL_TIMES)
except ValueError:
var_data_agl = wrf.vinterp(ncfile,
var_data,
'ght_agl',
np.linspace(0, 0.1, 100),
field_type='none',
timeidx=wrf.ALL_TIMES)
# Convert height to meters
var_data_agl["interp_level"] = var_data_agl["interp_level"] * 1000
# Time ranges
plot_time_ranges = []
plot_time_range1 = pd.date_range(start="2017-08-21T10:24:00",
end="2017-08-21T14:33:00",
freq=freq)
plot_time_range1 = plot_time_range1.floor(freq)
plot_time_range2 = pd.date_range(start="2017-08-21T13:09:00",
end="2017-08-21T14:33:00",
freq=freq)
plot_time_range2 = plot_time_range2.floor(freq)
plot_time_range3 = pd.date_range(start="2017-08-21T09:45:00",
end="2017-08-21T15:00:00",
freq=freq)
plot_time_range3 = plot_time_range3.floor(freq)
plot_time_ranges = [
plot_time_range1, plot_time_range2, plot_time_range3
]
# Vertical Profile Plots
for plot_time_range in [
rng for rng in plot_time_ranges if len(rng) > 1
]:
fig, ax = plt.subplots()
var_data_agl.isel(
south_north=center_y,
west_east=center_x).sel(Time=plot_time_range,
method="nearest").plot(ax=ax,
x="Time")
save_plot(ax=ax,
title='',
y_label="z (m)",
x_label="Local Time (CDT)",
var_name=var_name,
plot_type_name="vertical_profile",
plot_time_range=plot_time_range,
filename_in=filename,
output_dir=output_dir)
plt.close(fig)
# Line plots
fig, ax = plt.subplots()
if (var_name == 'tc'):
ax.plot(time_ws,
temp_ws,
'^k-',
label='2.5m',
markevery=500)
ax.plot(time_soil,
temp_soil,
'vb-',
label='-0.02m',
markevery=500)
if (var_name == 'wspd'):
y_label = "wind speed" + " (" + var_data.attrs[
"units"] + ")"
wspd_ws_rolling = pd.DataFrame(wspd_ws).rolling(
120).mean().values
wspd_tower_rolling = pd.DataFrame(wspd_tower).rolling(
120).mean().values
ax.plot(time_ws,
wspd_ws_rolling,
'c-',
label='3 m, 2 min avg',
linewidth=0.5)
ax.plot(time_tower,
wspd_tower_rolling,
'k-',
label='7 m, 2 min avg',
linewidth=0.5,
zorder=0)
var_data.isel(bottom_top=0,
south_north=center_y,
west_east=center_x).sel(Time=plot_time_range,
method="nearest").plot(
ax=ax,
x="Time",
label="WRF-Eclipse",
color="orange")
y_label = var_data.name + " (" + var_data.attrs["units"] + ")"
save_plot(ax=ax,
title='',
y_label=y_label,
x_label="Local Time (CDT)",
var_name=var_name,
plot_type_name="line_plot",
plot_time_range=plot_time_ranges[2],
filename_in=filename,
output_dir=output_dir)
plt.close(fig)
# Plot 2D values
for var_name, var_data in two_dim_vars.items():
# Convert to Local Time
var_data = to_local_time(var_data)
# Line plots
fig, ax = plt.subplots()
y_label = var_data.name + " (" + var_data.attrs["units"] + ")"
if (var_name == 'swdown'):
ax.plot(time_ws,
rad_ws,
'or-',
label='measured',
linewidth=0.5,
markevery=500)
y_label = "solar radiation" + " (" + var_data.attrs[
"units"] + ")"
if (var_name == 'T2'):
ax.plot(time_ws, temp_ws, '^k-', label='2.5m', markevery=500)
ax.plot(time_soil,
temp_soil,
'vb-',
label='-0.02m',
markevery=500)
y_label = "temperature" + " (" + var_data.attrs["units"] + ")"
var_data.isel(south_north=center_y,
west_east=center_x).sel(Time=plot_time_range,
method="nearest").plot(
ax=ax,
x="Time",
label="WRF-Eclipse",
color="orange")
save_plot(ax=ax,
title='',
y_label=y_label,
x_label="Local Time (CDT)",
var_name=var_name,
plot_type_name="line_plot",
plot_time_range=plot_time_range,
filename_in=filename,
output_dir=output_dir)
def interpy():
import sys, os
from netCDF4 import Dataset
from wrf import getvar, vinterp
from ast import literal_eval
import numpy as np
import xarray
interpnamelist = sys.argv[1]
if '/' in interpnamelist:
interpnamelistpath = interpnamelist.replace(interpnamelist.split('/')[-1],'')
listfilesnamelistpath = []
for (dirpath, dirnames, filenames) in os.walk(interpnamelistpath, topdown=True):
listfilesnamelistpath.extend(filenames)
del dirnames[:]
if '/' not in interpnamelist:
listfilesnamelistpath = []
pwdd=os.getcwd()
for (dirpath, dirnames, filenames) in os.walk(pwdd, topdown=True):
listfilesnamelistpath.extend(filenames)
del dirnames[:]
if (interpnamelist.split('/')[-1] not in listfilesnamelistpath):
print('Provided namelist could not be found. Please verify its location.')
return
cont=[]
with open(interpnamelist) as g:
for line in g:
cont.append(line.strip())
#input file
if sum(["ncinputfile" in aa for aa in cont]) == 1:
booleanvec = np.array(["ncinputfile" in aa for aa in cont])
inputfileline = str((np.array(cont)[booleanvec])[0])
ncinputfile = literal_eval(inputfileline.split('=')[-1])
if '/' in ncinputfile:
inputfilepath = ncinputfile.replace(ncinputfile.split('/')[-1],'')
listfilesinputpath = []
for (dirpath, dirnames, filenames) in os.walk(inputfilepath, topdown=True):
listfilesinputpath.extend(filenames)
del dirnames[:]
if '/' not in ncinputfile:
listfilesinputpath = []
pwdd=os.getcwd()
for (dirpath, dirnames, filenames) in os.walk(pwdd, topdown=True):
listfilesinputpath.extend(filenames)
del dirnames[:]
if (ncinputfile.split('/')[-1] not in listfilesinputpath):
print('Provided input file could not be found. Please verify its location.')
return
if sum(["ncinputfile" in aa for aa in cont]) == 0:
print("No input file was provided")
return
if sum(["ncinputfile" in aa for aa in cont]) > 1:
print("More than one input file was provided")
return
#plevels
if sum(["plevels" in aa for aa in cont]) == 1:
booleanvec = np.array(["plevels" in aa for aa in cont])
plevelsline = str((np.array(cont)[booleanvec])[0])
plevels = literal_eval(plevelsline.split('=',1)[-1])
if plevels == None:
plevels = [1000.0,900.0,800.0,700.0,600.0,500.0,400.0,300.0]
print("No pressure levels were given to interpolate. The next default levels will be used: ", plevels, "hPa")
if sum(["plevels" in aa for aa in cont]) == 0:
plevels = [1000.0,900.0,800.0,700.0,600.0,500.0,400.0,300.0]
print("No pressure levels were given to interpolate. The next default levels will be used: ", plevels, "hPa")
return
if sum(["plevels" in aa for aa in cont]) > 1:
plevels = [1000.0,900.0,800.0,700.0,600.0,500.0,400.0,300.0]
print("More than one pressure levels vector was provided. The next default levels will be used: ", plevels, " hPa")
return
#fields to interpolate
if sum(["getfield" in aa for aa in cont]) == 1:
booleanvec = np.array(["getfield" in aa for aa in cont])
interpfieldfileline = str((np.array(cont)[booleanvec])[0])
interpfield = literal_eval(interpfieldfileline.split('=')[-1])
if sum(["getfield" in aa for aa in cont]) == 0:
print("No field to interpolate was provided")
return
if sum(["getfield" in aa for aa in cont]) > 1:
print("More than one field to interpolate was provided")
return
if type(interpfield) == str:
interpfieldlist = interpfield.split()
if type(interpfield) == list:
interpfieldlist = interpfield
#units of the field to interpolate
if len(interpfieldlist) == 1:
if sum(["fieldunits" in aa for aa in cont]) == 1:
booleanvec = np.array(["fieldunits" in aa for aa in cont])
fieldunitsline = str((np.array(cont)[booleanvec])[0])
fieldunits = literal_eval(fieldunitsline.split('=')[-1])
if fieldunits == None:
print("No units were provided for the fields to interpolate. Default units will be used.")
fieldunitslist=[None]
else:
fieldunitslist=[fieldunits]
if sum(["fieldunits" in aa for aa in cont]) == 0:
fieldunitslist=[None]
print("No units were provided for the fields to interpolate. Default units will be used.")
if sum(["fieldunits" in aa for aa in cont]) > 1:
fieldunitslist=[None]
print("More than one units for the fields to interpolate were provided. Default units will be used.")
if len(interpfieldlist) > 1:
if sum(["fieldunits" in aa for aa in cont]) == 1:
booleanvec = np.array(["fieldunits" in aa for aa in cont])
fieldunitsline = str((np.array(cont)[booleanvec])[0])
fieldunits = literal_eval(fieldunitsline.split('=')[-1])
if fieldunits == None:
print("No units vector was provided for the fields to interpolate. Default units will be used.")
fieldunitslist=[None for aa in interpfieldlist]
else:
if type(fieldunits) is not list:
fieldunits = fieldunits.split()
if len(fieldunits) != len(interpfieldlist):
fieldunitslist = [None for aa in interpfieldlist]
if len(fieldunits) == len(interpfieldlist):
fieldunitslist = fieldunits
if sum(["fieldunits" in aa for aa in cont]) == 0:
fieldunitslist = [None for aa in interpfieldlist]
print("No units vector was provided for the fields to interpolate. Default units will be used.")
if sum(["fieldunits" in aa for aa in cont]) > 1:
fieldunitslist = [None for aa in interpfieldlist]
print("More than one units vector for the fields to interpolate was provided. Default units will be used.")
#output file
if len(interpfieldlist) == 1:
if sum(["ncoutputfile" in aa for aa in cont]) == 1:
booleanvec = np.array(["ncoutputfile" in aa for aa in cont])
outputfilenameline = str((np.array(cont)[booleanvec])[0])
ncoutputfile = literal_eval(outputfilenameline.split('=')[-1])
if ncoutputfile == None:
ncoutputfilelist = ncinputfile.split('/')[-1] + '-interp-' + interpfieldlist[0] + '.nc'
else:
if '/' in ncoutputfile:
outputfilepath = ncoutputfile.replace(ncinputfile.split('/')[-1],'')
listfilesoutputpath = []
for (dirpath, dirnames, filenames) in os.walk(outputfilepath, topdown=True):
listfilesoutputpath.extend(filenames)
del dirnames[:]
if '/' not in ncoutputfile:
listfilesoutputpath = []
pwdd=os.getcwd()
for (dirpath, dirnames, filenames) in os.walk(pwdd, topdown=True):
listfilesoutputpath.extend(filenames)
del dirnames[:]
if (ncoutputfile.split('/')[-1] in listfilesinputpath):
outputfileover=input('There already exists a file with the name provided for the output file. Please type whether the existing file should be overwritten [y] or not [n] here >>> ')
if outputfileover == 'n':
newoutputfilename=input('Press ENTER to use the default output name or type an alternate name for the output file >>> ')
if len(newoutputfilename) == 0:
ncoutputfile = (ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + interpfieldlist[0] + '.nc'
if len(newoutputfilename) > 0:
ncoutputfile=newoutputfilename
if sum(["ncoutputfile" in aa for aa in cont]) == 0:
print("No output file name was provided. Default name will be used for the output file.")
ncoutputfile = (ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + interpfieldlist[0] + '.nc'
if sum(["ncoutputfile" in aa for aa in cont]) > 1:
print("More than one output file name was provided. Default name will be used for the output file.")
ncoutputfile = (ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + interpfieldlist[0] + '.nc'
ncoutputfilelist = ncoutputfile.split()
if len(interpfieldlist) > 1:
if sum(["ncoutputfile" in aa for aa in cont]) == 1:
booleanvec = np.array(["ncoutputfile" in aa for aa in cont])
outputfilenameline = str((np.array(cont)[booleanvec])[0])
ncoutputfile = literal_eval(outputfilenameline.split('=')[-1])
if ncoutputfile == None:
ncoutputfilelist = [((ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + abc + '.nc') for abc in interpfieldlist]
else:
if type(ncoutputfile) is not list:
ncoutputfile = ncoutputfile.split()
if len(ncoutputfile) == 1:
print('Single output file name was provided for the requested multiple fields to interpolate. Given output name will be used as prefix for the multiple output files names.')
ncoutputfilelist = [(((ncoutputfile[0]).split('/')[-1]).replace('.nc','') + '-' + abc + '.nc') for abc in interpfieldlist]
if len(ncoutputfile) > 1:
if len(ncoutputfile) != len(interpfieldlist):
print('Not enough output file names were provided for the requested fields to interpolate. Default names will be used for the output files names.')
ncoutputfilelist = [((ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + abc + '.nc') for abc in interpfieldlist]
if len(ncoutputfile) == len(interpfieldlist):
ncoutputfilelist = ncoutputfile
if sum(["ncoutputfile" in aa for aa in cont]) == 0:
print("No output file name was provided. Default names will be used for the output files names.")
ncoutputfilelist = [((ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + abc + '.nc') for abc in interpfieldlist]
if sum(["ncoutputfile" in aa for aa in cont]) > 1:
print("More than one output file name was provided. Default name will be used for the output file.")
ncoutputfilelist = [((ncinputfile.split('/')[-1]).replace('.nc','') + '-interp-' + abc + '.nc') for abc in interpfieldlist]
#interpolate
if len(interpfieldlist) == 1:
if sum(["interpolate" in aa for aa in cont]) == 1:
booleanvec = np.array(["interpolate" in aa for aa in cont])
interppline = str((np.array(cont)[booleanvec])[0])
interppfield = literal_eval(interppline.split('=')[-1])
if interppfield == False:
print("No interpolation option was provided. Thus, no interpolation will be performed.")
interppfieldlist=[False]
if interppfield == True:
interppfieldlist=[True]
else:
interppfieldlist=[False]
if sum(["interpolate" in aa for aa in cont]) == 0:
print("No interpolation option was provided. Thus, no interpolation will be performed.")
interppfieldlist=[False]
if sum(["interpolate" in aa for aa in cont]) > 1:
print("More than one interpolation option was provided. Thus, no interpolation will be performed.")
interppfieldlist=[False]
if len(interpfieldlist) > 1:
if sum(["interpolate" in aa for aa in cont]) == 1:
booleanvec = np.array(["interpolate" in aa for aa in cont])
interppline = str((np.array(cont)[booleanvec])[0])
interppfield = literal_eval(interppline.split('=')[-1])
if type(interppfield) is not list:
if interppfield == False:
print("Single interpolation option was provided for multiple fields to interpolate. The specified 'False' option will be used for them all.")
interppfieldlist=[False for aa in interpfieldlist]
if interppfield == True:
print("Single interpolation option was provided for multiple fields to interpolate. The specified 'True' option will be used for them all.")
interppfieldlist=[True for aa in interpfieldlist]
else:
if len(interppfield) != len(interpfieldlist):
print("Less interpolation options than fields to interpolate were provided. The default 'False' option will be used for them all.")
interppfieldlist = [False for aa in interpfieldlist]
if len(interppfield) == len(interpfieldlist):
interppfieldlist = interppfield
if sum(["interpolate" in aa for aa in cont]) == 0:
print("No interpolation option was provided. Thus, no interpolation will be performed.")
interppfieldlist = [False for aa in interpfieldlist]
if sum(["interpolate" in aa for aa in cont]) > 1:
print("More than one interpolation option was provided. Thus, no interpolation will be performed.")
interppfieldlist = [False for aa in interpfieldlist]
#extrapolate
if len(interpfieldlist) == 1:
if sum(["extrapolate" in aa for aa in cont]) == 1:
booleanvec = np.array(["extrapolate" in aa for aa in cont])
extrapline = str((np.array(cont)[booleanvec])[0])
extrapfield = literal_eval(extrapline.split('=')[-1])
if extrapfield == False:
print("No extrapolation option was provided. Thus, no extrapolation will be performed.")
extrapfieldlist=[False]
if extrapfield == True:
extrapfieldlist=[True]
else:
extrapfieldlist=[False]
if sum(["extrapolate" in aa for aa in cont]) == 0:
print("No extrapolation option was provided. Thus, no extrapolation will be performed.")
extrapfieldlist=[False]
if sum(["extrapolate" in aa for aa in cont]) > 1:
print("More than one extrapolation option was provided. Thus, no extrapolation will be performed.")
extrapfieldlist=[False]
if len(interpfieldlist) > 1:
if sum(["extrapolate" in aa for aa in cont]) == 1:
booleanvec = np.array(["extrapolate" in aa for aa in cont])
extrapline = str((np.array(cont)[booleanvec])[0])
extrapfield = literal_eval(extrapline.split('=')[-1])
if type(extrapfield) is not list:
if extrapfield == False:
print("Single extrapolation option was provided for multiple fields to interpolate. The specified 'False' option will be used for them all.")
extrapfieldlist=[False for aa in interpfieldlist]
if extrapfield == True:
print("Single extrapolation option was provided for multiple fields to interpolate. The specified 'True' option will be used for them all.")
extrapfieldlist=[True for aa in interpfieldlist]
else:
if len(extrapfield) != len(interpfieldlist):
print("Less extrapolation options than fields to interpolate were provided. The default 'False' option will be used for them all.")
extrapfieldlist = [False for aa in interpfieldlist]
if len(extrapfield) == len(interpfieldlist):
extrapfieldlist = extrapfield
if sum(["extrapolate" in aa for aa in cont]) == 0:
print("No extrapolation option was provided. Thus, no extrapolation will be performed.")
extrapfieldlist = [False for aa in interpfieldlist]
if sum(["extrapolate" in aa for aa in cont]) > 1:
print("More than one extrapolation option was provided. Thus, no extrapolation will be performed.")
extrapfieldlist = [False for aa in interpfieldlist]
ncfile = Dataset(ncinputfile)
variables=[aa for aa in ncfile.variables]
print('Imported ', len(variables)-3, 'variables')
#yn = input('Do you want to see them all? [y/n] >>> ')
#if yn == 'y':
# print(ncfile.variables)
dimsnames = [aa for aa in ncfile.dimensions]
if 'Time' not in dimsnames:
print('Single time step was found in the input file')
for i in range(0,len(interpfieldlist)):
interpfield = interpfieldlist[i]
ncoutputfile = ncoutputfilelist[i]
fieldunits = fieldunitslist[i]
interpoption = interppfieldlist[i]
extrapfield = extrapfieldlist[i]
corrfields=['pressure','pres','p','pressure_hpa','pres_hpa','p_hpa','z','ght','z_km','ght_km','tc','tk','theta','th','theta_e','thetae','eth']
fieldtypes=['pressure','pres','p','pressure_hpa','pres_hpa','p_hpa','z','ght','z_km','ght_km','tc','tk','theta','th','theta-e','thetae','eth']
if interpfield not in corrfields:
fieldtype='none'
else:
fieldtype=fieldtypes[corrfields.index(interpfield)]
print('Calculating ', interpfield, ' ...')
if fieldunits == None:
interpvar = getvar(ncfile, interpfield, timeidx=None)
else:
interpvar = getvar(ncfile, interpfield, timeidx=None, units=fieldunits)
if ('bottom_top' in interpvar.dims) == False:
plevelsinterpolatedfield = interpvar
if ('u_v' in interpvar.dims) == True:
plevelsinterpolatedfieldU = interpvar.isel(u_v=0)
plevelsinterpolatedfieldV = interpvar.isel(u_v=1)
plevelsinterpolatedfieldMOD = np.sqrt(plevelsinterpolatedfieldU*plevelsinterpolatedfieldU + plevelsinterpolatedfieldV*plevelsinterpolatedfieldV)
if interpoption==True:
print('Warning: interpolation is not an appliable method for single-level fields, and hence it will not be performed.')
if ('bottom_top' in interpvar.dims) == True:
if interpoption==True:
print('Interpolating ', interpfield,' to ', len(plevels), ' pressure levels ...')
if ('u_v' in interpvar.dims) == True:
plevelsinterpolatedfieldU = vinterp(ncfile, field=interpvar.isel(u_v=0), vert_coord="pressure",
interp_levels=plevels, timeidx=None,extrapolate=extrapfield)
plevelsinterpolatedfieldV = vinterp(ncfile, field=interpvar.isel(u_v=1), vert_coord="pressure",
interp_levels=plevels, timeidx=None,extrapolate=extrapfield)
plevelsinterpolatedfieldMOD= np.sqrt(plevelsinterpolatedfieldU*plevelsinterpolatedfieldU + plevelsinterpolatedfieldV*plevelsinterpolatedfieldV)
else:
if interpfield=='z':
plevelsinterpolatedfield = vinterp(ncfile, field=interpvar, vert_coord="pressure", field_type='z',log_p=True,
interp_levels=plevels, timeidx=None,extrapolate=extrapfield)
else:
plevelsinterpolatedfield = vinterp(ncfile, field=interpvar, vert_coord="pressure", field_type=fieldtype,log_p=True,
interp_levels=plevels, timeidx=None,extrapolate=extrapfield)
print('Interpolation of ', interpfield,' to pressure levels completed successfully')
if interpoption==False:
plevelsinterpolatedfield = interpvar
#Export to netCDF:
if ('u_v' in interpvar.dims) == True:
ncoutputfileU = ncoutputfile.replace('.nc','') + '-U.nc'
del plevelsinterpolatedfieldU.attrs['coordinates']
plevelsinterpolatedfieldU.attrs['projection'] = str(plevelsinterpolatedfieldU.projection)
plevelsinterpolatedfieldU.XLONG.attrs['units'] = 'degrees_east'
plevelsinterpolatedfieldU.XLAT.attrs['units'] = 'degrees_north'
plevelsinterpolatedfieldU.to_netcdf(ncoutputfileU)
ncoutputfileV = ncoutputfile.replace('.nc','') + '-V.nc'
del plevelsinterpolatedfieldV.attrs['coordinates']
plevelsinterpolatedfieldV.attrs['projection'] = str(plevelsinterpolatedfieldV.projection)
plevelsinterpolatedfieldV.XLONG.attrs['units'] = 'degrees_east'
plevelsinterpolatedfieldV.XLAT.attrs['units'] = 'degrees_north'
plevelsinterpolatedfieldV.to_netcdf(ncoutputfileV)
ncoutputfileMOD = ncoutputfile.replace('.nc','') + '-MOD.nc'
plevelsinterpolatedfieldMOD.XLONG.attrs['units'] = 'degrees_east'
plevelsinterpolatedfieldMOD.XLAT.attrs['units'] = 'degrees_north'
plevelsinterpolatedfieldMOD.to_netcdf(ncoutputfileMOD)
else:
del plevelsinterpolatedfield.attrs['coordinates']
plevelsinterpolatedfield.attrs['projection'] = str(plevelsinterpolatedfield.projection)
plevelsinterpolatedfield.XLONG.attrs['units'] = 'degrees_east'
plevelsinterpolatedfield.XLAT.attrs['units'] = 'degrees_north'
plevelsinterpolatedfield.to_netcdf(ncoutputfile)
if 'Time' in dimsnames:
print(len(ncfile.dimensions['Time']), 'time steps were found in the input file')
for i in range(0,len(interpfieldlist)):
interpfield = interpfieldlist[i]
ncoutputfile = ncoutputfilelist[i]
fieldunits = fieldunitslist[i]
interpoption = interppfieldlist[i]
extrapfield = extrapfieldlist[i]
corrfields=['pressure','pres','p','pressure_hpa','pres_hpa','p_hpa','z','ght','z_km','ght_km','tc','tk','theta','th','theta_e','thetae','eth']
fieldtypes=['pressure','pres','p','pressure_hpa','pres_hpa','p_hpa','z','ght','z_km','ght_km','tc','tk','theta','th','theta-e','thetae','eth']
if interpfield not in corrfields:
fieldtype='none'
else:
fieldtype=fieldtypes[corrfields.index(interpfield)]
print(fieldtype)
print('Calculating ', interpfield, ' ...')
timeidxs=range(len(ncfile.dimensions['Time']))
for timestamp in timeidxs:
print(round((timestamp/timeidxs[-1])*100), '%', end='\r')
if fieldunits == None:
interpvar = getvar(ncfile, interpfield, timeidx=timestamp)
else:
interpvar = getvar(ncfile, interpfield, timeidx=timestamp, units=fieldunits)
if ('bottom_top' in interpvar.dims) == False:
plevelsinterpolatedfield = interpvar
if ('u_v' in interpvar.dims) == True:
plevelsinterpolatedfieldU = interpvar.isel(u_v=0)
plevelsinterpolatedfieldV = interpvar.isel(u_v=1)
plevelsinterpolatedfieldMOD = np.sqrt(plevelsinterpolatedfieldU*plevelsinterpolatedfieldU + plevelsinterpolatedfieldV*plevelsinterpolatedfieldV)
if interpoption==True:
if timestamp == 0:
print('Warning: interpolation is not an appliable method for single-level fields, and hence it will not be performed.')
if ('bottom_top' in interpvar.dims) == True:
if interpoption==False:
plevelsinterpolatedfield = interpvar
if interpoption==True:
if timestamp == 0:
print('Interpolating ', interpfield,' to ', len(plevels), ' pressure levels ...')
if ('u_v' in interpvar.dims) == True:
plevelsinterpolatedfieldU = vinterp(ncfile, field=interpvar.isel(u_v=0), vert_coord="pressure",
interp_levels=plevels, timeidx=timestamp,extrapolate=extrapfield)
plevelsinterpolatedfieldV = vinterp(ncfile, field=interpvar.isel(u_v=1), vert_coord="pressure",
interp_levels=plevels, timeidx=timestamp,extrapolate=extrapfield)
plevelsinterpolatedfieldMOD= np.sqrt(plevelsinterpolatedfieldU*plevelsinterpolatedfieldU + plevelsinterpolatedfieldV*plevelsinterpolatedfieldV)
if ('u_v' in interpvar.dims) == False:
if interpfield=='z':
plevelsinterpolatedfield = vinterp(ncfile, field=interpvar, vert_coord="pressure", field_type='z',log_p=True,
interp_levels=plevels, timeidx=timestamp,extrapolate=extrapfield)
else:
plevelsinterpolatedfield = vinterp(ncfile, field=interpvar, vert_coord="pressure", field_type=fieldtype, log_p=True,
interp_levels=plevels, timeidx=timestamp,extrapolate=extrapfield)
if timestamp == range(len(ncfile.dimensions['Time']))[-1]:
print('Interpolation of ', interpfield,' to pressure levels completed successfully')
#Export to netCDF:
if ('u_v' in interpvar.dims) == False:
if timestamp == 0:
merged=plevelsinterpolatedfield
else:
merged=xarray.concat([merged,plevelsinterpolatedfield], 'Time')
if timestamp == timeidxs[-1]:
del merged.attrs['coordinates']
merged.attrs['projection'] = str(merged.projection)
merged.XLONG.attrs['units'] = 'degrees_east'
merged.XLAT.attrs['units'] = 'degrees_north'
merged.to_netcdf(ncoutputfile)
if ('u_v' in interpvar.dims) == True:
if timestamp == 0:
mergedU=plevelsinterpolatedfieldU
mergedV=plevelsinterpolatedfieldV
mergedMOD=plevelsinterpolatedfieldMOD
else:
mergedU=xarray.concat([mergedU,plevelsinterpolatedfieldU], 'Time')
mergedV=xarray.concat([mergedV,plevelsinterpolatedfieldV], 'Time')
mergedMOD=xarray.concat([mergedMOD,plevelsinterpolatedfieldMOD], 'Time')
if timestamp == timeidxs[-1]:
ncoutputfileU = ncoutputfile.replace('.nc','') + '-U.nc'
del mergedU.attrs['coordinates']
mergedU.attrs['projection'] = str(mergedU.projection)
mergedU.XLONG.attrs['units'] = 'degrees_east'
mergedU.XLAT.attrs['units'] = 'degrees_north'
mergedU.to_netcdf(ncoutputfileU, mode='w')
ncoutputfileV = ncoutputfile.replace('.nc','') + '-V.nc'
del mergedV.attrs['coordinates']
mergedV.attrs['projection'] = str(mergedV.projection)
mergedV.XLONG.attrs['units'] = 'degrees_east'
mergedV.XLAT.attrs['units'] = 'degrees_north'
mergedV.to_netcdf(ncoutputfileV, mode='w')
ncoutputfileMOD = ncoutputfile.replace('.nc','') + '-MOD.nc'
mergedMOD.XLONG.attrs['units'] = 'degrees_east'
mergedMOD.XLAT.attrs['units'] = 'degrees_north'
mergedMOD.to_netcdf(ncoutputfileMOD, mode='w')
print('Execution completed without any errors')
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
import numpy as np
from wrf import getvar, vinterp
from netCDF4 import Dataset
import matplotlib.pyplot as plt
# берёт файл с готовыми результатами расчёта и интерполирует их на эквидистантную сетку - произвольную, мелкую - по высоте, строит график плотности от высоты, в файл не пишет
path = '/mnt/data-internal/newversion/2017092906/wrfout_d02_2017-09-29_06:00:00'
ncfile = Dataset(path)
name = 'QVAPOR'
start_level = 'ght_msl' # above_mean_sea_level ; 'ght_agl' - above ground level
m_density_array = getvar(ncfile, name, timeidx=100, meta=False)
z = getvar(ncfile, 'z',
meta=False) # высоты точек, в которых посчитано, в метрах
height_array_for_interp = np.arange(0.02, 6, 0.02) # in km
interpolated_m_dens = vinterp(ncfile, m_density_array, start_level,
height_array_for_interp)
plt.plot(m_density_array[:, 45, 45], z[:, 45, 45] / 1000)
plt.plot(interpolated_m_dens[:, 45, 45], height_array_for_interp)
plt.show()
def make_result_file(opts):
infilename = os.path.expanduser(
os.path.join(opts.outdir, "ci_test_file.nc"))
outfilename = os.path.expanduser(
os.path.join(opts.outdir, "ci_result_file.nc"))
with Dataset(infilename) as infile, Dataset(outfilename, "w") as outfile:
for varname in WRF_DIAGS:
var = getvar(infile, varname)
add_to_ncfile(outfile, var, varname)
for interptype in INTERP_METHS:
if interptype == "interpline":
hts = getvar(infile, "z")
p = getvar(infile, "pressure")
hts_850 = interplevel(hts, p, 850.)
add_to_ncfile(outfile, hts_850, "interplevel")
if interptype == "vertcross":
hts = getvar(infile, "z")
p = getvar(infile, "pressure")
pivot_point = CoordPair(hts.shape[-1] // 2, hts.shape[-2] // 2)
ht_cross = vertcross(hts,
p,
pivot_point=pivot_point,
angle=90.)
add_to_ncfile(outfile, ht_cross, "vertcross")
if interptype == "interpline":
t2 = getvar(infile, "T2")
pivot_point = CoordPair(t2.shape[-1] // 2, t2.shape[-2] // 2)
t2_line = interpline(t2, pivot_point=pivot_point, angle=90.0)
add_to_ncfile(outfile, t2_line, "interpline")
if interptype == "vinterp":
tk = getvar(infile, "temp", units="k")
interp_levels = [200, 300, 500, 1000]
field = vinterp(infile,
field=tk,
vert_coord="theta",
interp_levels=interp_levels,
extrapolate=True,
field_type="tk",
log_p=True)
add_to_ncfile(outfile, field, "vinterp")
for latlonmeth in LATLON_METHS:
if latlonmeth == "xy":
# Hardcoded values from other unit tests
lats = [-55, -60, -65]
lons = [25, 30, 35]
xy = ll_to_xy(infile, lats[0], lons[0])
add_to_ncfile(outfile, xy, "xy")
else:
# Hardcoded from other unit tests
i_s = np.asarray([10, 100, 150], int) - 1
j_s = np.asarray([10, 100, 150], int) - 1
ll = xy_to_ll(infile, i_s[0], j_s[0])
add_to_ncfile(outfile, ll, "ll")
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)
surf = mlab.surf(x.T, y.T, Z.values.T / 1000, color=(1, 1, 1))
surf.actor.enable_texture = True
surf.actor.tcoord_generator_mode = 'plane'
surf.actor.actor.texture = tex
mlab.view(-120, 60, 200, [55, 55, -9])
iz = np.arange(0, top, vspace)
ly, lx, nt = [
nc.dimensions[n].size for n in ['south_north', 'west_east', 'Time']
]
tr = lambda x: x.transpose(2, 1, 0)
z, y, x = np.mgrid[slice(0, top, vspace), :ly, :lx]
# NOTE: rendering the first timestep twice (and writing it to file!!!) seems to get around the issue with the lacking lighting in the first image
cld = wrf.vinterp(nc, wrf.getvar(nc, 'CLDFRA', timeidx=0), 'ght_msl', iz)
vol = mlab.pipeline.volume(mlab.pipeline.scalar_field(tr(x), tr(y), tr(z),
tr(cld.values)),
color=(1, 1, 1),
vmin=0,
vmax=.7)
mlab.savefig('{}_{}.png'.format(intermediate_images, i), size=(1200, 800))
for i in range(nt):
vol.remove()
cld = wrf.vinterp(nc, wrf.getvar(nc, 'CLDFRA', timeidx=i), 'ght_msl', iz)
vol = mlab.pipeline.volume(mlab.pipeline.scalar_field(
tr(x), tr(y), tr(z), tr(cld.values)),
color=(1, 1, 1),
vmin=0,
vmax=.7)
mlab.savefig('scene_{:03d}.png'.format(i), size=(1200, 800))
def main():
#
# http://www.meteo.unican.es/wiki/cordexwrf/OutputVariables
#
wrf_step_minutes = 5
model_period = datetime.timedelta(minutes=wrf_step_minutes)
# LET'S CONSIDER THE EVENT OF MARCH!!
# =============================================================================
# model_datetime = datetime.datetime(2018, 3, 4, 18, 0)
# model_period = datetime.timedelta(minutes = wrf_step_minutes)
# # set_model_datetime(model_datetime , wrf_step_minutes) # the second argument is the value of time step, in minutes
# event_datetime = datetime.datetime(2018, 3, 5, 1, 30)
# # here we have an automatical "numnber_of_time_points"-initialization z_array = np.zeros([40,z_index_max])
# event_finish_datetime = datetime.datetime(2018, 3, 5, 3, 30)
# =============================================================================
# set_model_datetime(model_datetime , wrf_step_minutes) # the second argument is the value of time step, in minutes
# =============================================================================
# model_datetime = datetime.datetime(2016, 5, 4, 0, 0)
# event_finish_datetime = datetime.datetime(2016, 5, 5, 0, 0)
#
# the_time_moment = datetime.datetime(2016, 5, 4, 11, 0)
# the_second_time_moment = datetime.datetime(2016, 5, 4, 15, 00)
# =============================================================================
# the_time_moment = datetime.datetime(2016, 5, 4, 19, 10)
# the_second_time_moment = datetime.datetime(2016, 5, 4, 18, 45)
# =============================================================================
# model_datetime = datetime.datetime(2016, 5, 11, 18, 0)
# event_finish_datetime = datetime.datetime(2016, 5, 13, 0, 00)
# the_time_moment = datetime.datetime(2016, 5, 12, 5, 30)
# the_second_time_moment = datetime.datetime(2016, 5, 12, 10, 50)
# the_third_time_moment = datetime.datetime(2016, 5, 12, 12, 25)
# the_fourth_time_moment = datetime.datetime(2016, 5, 12, 14, 0)
# the_fifth_time_moment = datetime.datetime(2016, 5, 12, 14, 45)
# =============================================================================
# =============================================================================
# model_datetime = datetime.datetime(2016, 4, 26, 12, 0)
# event_finish_datetime = datetime.datetime(2016, 4, 29, 0, 0)
#
# the_time_moment = datetime.datetime(2016, 4, 28, 2, 0)
# the_second_time_moment = datetime.datetime(2016, 4, 28, 2, 0)
# =============================================================================
# =============================================================================
# model_datetime = datetime.datetime(2016, 10, 29, 0)
# event_finish_datetime = datetime.datetime(2016, 10, 30, 12)
# the_time_moment = datetime.datetime(2016, 10, 29, 22, 10)
# the_second_time_moment = datetime.datetime(2016, 10, 29, 22, 10)
# =============================================================================
model_datetime = datetime.datetime(2016, 6, 11, 0, 0)
event_finish_datetime = datetime.datetime(2016, 6, 12, 0, 0)
the_time_moment = datetime.datetime(2016, 6, 11, 11, 10)
the_start_of_consideration = datetime.datetime(2016, 6, 11, 10, 0)
the_end_of_consideration = datetime.datetime(2016, 6, 11, 16, 0)
# =============================================================================
# model_datetime = datetime.datetime(2017, 9, 29, 6, 0)
# event_finish_datetime = datetime.datetime(2017, 9, 30, 0, 0)
# # the_time_moment = datetime.datetime(2017, 9, 29, 18, 50)
# the_time_moment = datetime.datetime(2017, 9, 29, 19, 35)
# the_second_time_moment = datetime.datetime(2017, 9, 29, 20, 10)array_loaded
# =============================================================================
# here we have an automatical "numnber_of_time_points"-initialization
# "event_datetime" could have any value from modelled time, or just be equal to "model_datetime"
event_datetime = model_datetime
number_of_time_points = int(
(the_end_of_consideration - the_start_of_consideration) /
datetime.timedelta(0, 0, 0, 0, wrf_step_minutes)) + 1
file = get_wrf_file(model_datetime)
variable = file.variables['T2'].data[:]
model_length = len(variable[:, y_lat, x_lon])
# INTERPOLATION parameters are defined here convert to a non-
path = os.path.join(current_folder) + '/'
path = os.path.join(path,
datetime.datetime.strftime(model_datetime, '%Y%m%d%H'))
file_name = path + '/wrfout_d02_' + datetime.datetime.strftime(
model_datetime, '%Y-%m-%d_%H:00:00')
ncfile = Dataset(file_name)
height = getvar(file, 'z', meta=False)
height_min = 0.12 #km
height_max = 8
mnt_from_msl = height[0, y_lat,
x_lon] / 1000. # высота станции над mean sea level
height_array_for_interp = np.arange(height_min + mnt_from_msl,
height_max + mnt_from_msl,
0.02) # in km
start_level = 'ght_msl' # above_mean_sea_level ; 'ght_agl' - above ground level
height_array_zero_on_the_ground = np.arange(
height_min, height_max,
0.02) # in kmdatetime.timedelta(0, 0, 0, 0, wrf_step_minutes))
# we write "z_array" in file just once - in assumption, that it is one and the same array for each "name" (type of hydrometeors)
# np.save('/home/kate-svch/Thunder/Aragats_measurements/py-codes/z_and_dens_arrays/z_array_' + datetime.datetime.strftime(the_time_moment, '%Y-%m-%d_%H:00:00') +'.npy', np.array(height_array_zero_on_the_ground))
z_index_max = 20
# it's the maximal index of height: 20 corresponds to approximately 10.2 km
z_vector = get_height(model_datetime, x_lon)[0:z_index_max] / 1000
time_vector = [
event_datetime + datetime.timedelta(minutes=wrf_step_minutes * i)
for i in range(number_of_time_points)
]
ground_height = height[0, y_lat, x_lon]
# np.save('/home/kate-svch/Thunder/Aragats_measurements/py-codes/z_and_dens_arrays/z_vector_' + datetime.datetime.strftime(the_time_moment, '%Y-%m-%d_%H:00:00') +'.npy', np.array(z_vector))
name_array = ["QSNOW", "QGRAUP"]
event_datetime = model_datetime
file = get_wrf_file(model_datetime)
variable = file.variables['T2'].data[:]
model_length = len(variable[:, y_lat, x_lon])
z_array = np.zeros([x_max - x_min, z_index_max
]) # it's for x-dependencies, for fixed y-value!
x_array = np.zeros([x_max - x_min, z_index_max])
y_array = np.zeros([x_max - x_min, z_index_max])
z_for_y_array = np.zeros([x_max - x_min, z_index_max])
for j_x in range(x_min, x_max):
# print (j_x)
x_array[j_x - x_min, :] = np.ones([z_index_max]) * j_x - 45
z_array[j_x - x_min, :] = get_height(model_datetime,
j_x)[:z_index_max] / 1000.
y_array[j_x - x_max, :] = np.ones([z_index_max]) * j_x - 45
z_for_y_array[j_x - x_min, :] = get_height_for_y(
model_datetime, j_x)[:z_index_max] / 1000.
for j_time in range(0, number_of_time_points):
the_time_moment = the_start_of_consideration + j_time * (
datetime.timedelta(0, 0, 0, 0, wrf_step_minutes))
for name in name_array:
# =============================================================================
# plt.figure(figsize=(18,8))
# picture_mass = plt.contourf(time_vector, z_vector, np.array(get_mass_density(z_index_max, model_datetime, model_period, model_length, event_datetime, name, number_of_time_points)).transpose())
# plt.colorbar(picture_mass, format = "%0.6f" )
# plt.title('Density: '+ name, fontsize=22)
# plt.xlabel('time', fontsize=20, horizontalalignment='right' )
# plt.ylabel('z, km', rotation='horizontal', fontsize=20, horizontalalignment='right', verticalalignment='top')
# # plt.axis('image')
# plt.axis('normal')
# plt.show()
# =============================================================================
figure_xz_raw = plt.figure(figsize=(18, 8))
picture2 = plt.contourf(
x_array, z_array,
np.array(
get_mass_density_xz(z_index_max, model_datetime,
model_period, model_length,
the_time_moment, name)))
plt.colorbar(picture2, format="%0.6f")
plt.title('Density: ' + name + ' ' + str(the_time_moment),
fontsize=22)
plt.xlabel('x, km', fontsize=20, horizontalalignment='right')
plt.ylabel('z, km',
rotation='horizontal',
fontsize=20,
horizontalalignment='right',
verticalalignment='top')
plt.axis('normal')
plt.show()
print(
'Integral quantity of ', name, ' is: ',
get_mass_density_integral(z_index_max, model_datetime,
model_period, model_length,
the_time_moment, name))
aux_year = event_datetime.year
aux_folder_for_fig = datetime.datetime.strftime(
the_time_moment, '%Y-%m-%d')
figure_xz_raw.savefig(
'/home/kate-svch/Thunder/Aragats_measurements/' +
str(aux_year) + '/' + aux_folder_for_fig +
'/dens_in_space_raw_' + name + '/raw_xz_' + name + '_' +
datetime.datetime.strftime(the_time_moment, '%Y-%m-%d_%H-%M') +
'.png')
m_density_array = getvar(ncfile,
name,
timeidx=get_index(model_datetime,
model_period,
model_length,
the_time_moment, 1),
meta=False)
interpolated_m_dens = vinterp(ncfile, m_density_array, start_level,
height_array_for_interp)
figure_xz_interp = plt.figure(figsize=(18, 8))
# picture2 = plt.contourf(height_array_for_interp, x_array, interpolated_m_dens[:, y_lat, x_min:x_max])
picture2 = plt.contourf(interpolated_m_dens[:, y_lat, x_min:x_max])
plt.colorbar(picture2, format="%0.6f")
plt.title('INTERPOLATED density: ' + name + ' ' +
str(the_time_moment),
fontsize=22)
plt.xlabel('x, ind', fontsize=20, horizontalalignment='right')
plt.ylabel('z, ind',
rotation='horizontal',
fontsize=20,
horizontalalignment='right',
verticalalignment='top')
plt.axis('normal')
plt.show()
figure_xz_interp.savefig(
'/home/kate-svch/Thunder/Aragats_measurements/' +
str(aux_year) + '/' + aux_folder_for_fig +
'/dens_in_space_interp_' + name + '/xz_interp' + name + '_' +
datetime.datetime.strftime(the_time_moment, '%Y-%m-%d_%H-%M') +
'.png')
