def test_rh_mixing_ratio():
"""Tests relative humidity from mixing ratio."""
p = 1013.25 * units.mbar
temperature = 20. * units.degC
w = 0.012
rh = relative_humidity_from_mixing_ratio(w, temperature, p)
assert_almost_equal(rh, 81.7219 * units.percent, 3)
def test(type):
"""Run a single benchmark test for computation of meteorological fields
across a forecast ensemble.
Parameters
----------
type : str
The type of array to test; either 'numpy' or 'dask'.
Returns
-------
tuple of floats
The total wall and process times.
"""
refpath = Path("/lustre/scratch/rmanser/wrfref/wrfoutREFd02")
mempath = Path("/lustre/scratch/rmanser/test_ens/2016052812/")
ref = xr.open_dataset(refpath)
# All members are loaded implicitly as dask arrays, regardless of `type`
members = xr.open_mfdataset(
mempath.glob("mem*/wrfout_d02_2016-05-30_12:00:00"),
concat_dim='members',
combine='nested',
)
# For dask arrays, we select the individual variable dask arrays
if type == 'dask':
pressure = (members.P + ref.PB).data * units(ref.PB.units)
theta = (members.T + ref.T00).data * units(ref.T00.units)
mixing_ratio = members.QVAPOR.data * units('dimensionless')
# For numpy arrays, we force variable arrays to be loaded into memory
elif type == 'numpy':
pressure = (members.P + ref.PB).values * units(ref.PB.units)
theta = (members.T + ref.T00).values * units(ref.T00.units)
mixing_ratio = members.QVAPOR.values * units('dimensionless')
start_wall = time.time()
start_proc = time.process_time()
temperature = mpcalc.temperature_from_potential_temperature(
pressure, theta)
relative_humidity = mpcalc.relative_humidity_from_mixing_ratio(
mixing_ratio, temperature, pressure)
# We don't call metpy's function here because it implicitly triggers
# a dask.compute() call
dewpoint = dewpoint_from_relative_humidity(temperature, relative_humidity)
if type == 'dask':
td = dewpoint.compute()
end_wall = time.time()
end_proc = time.process_time()
total_wall = end_wall - start_wall
total_proc = end_proc - start_proc
return total_wall, total_proc
def test_rh_mixing_ratio():
"""Test relative humidity from mixing ratio."""
p = 1013.25 * units.mbar
temperature = 20. * units.degC
w = 0.012 * units.dimensionless
rh = relative_humidity_from_mixing_ratio(w, temperature, p)
assert_almost_equal(rh, 81.7219 * units.percent, 3)
def get_relative_humidity(profiles):
profiles["play"].attrs['units'] = 'hPa'
profiles["tlay"].attrs['units'] = 'kelvin'
rh = mpcalc.relative_humidity_from_mixing_ratio(profiles["mr"],
profiles["tlay"],
profiles["play"])
profiles["rh"] = (["launch_time", "zlay"], rh.magnitude)
return profiles
def atmCalc(height, temp, humid):
print("ATMCALC", height, temp, humid, file=sys.stderr)
mtny = windh(MTNX, height, ratio=1,
yoffset=0)
windx = XVALUES
windy = windh(windx, height)
temp_ = temp * units.degC
initp = mc.height_to_pressure_std(windy[0] * units.meters)
dewpt = mc.dewpoint_from_relative_humidity(temp_, humid / 100.)
lcl_ = mc.lcl(initp, temp_, dewpt, max_iters=50, eps=1e-5)
LCL = mc.pressure_to_height_std(lcl_[0])
if (lcl_[0] > mc.height_to_pressure_std(max(windy) * units.meters)
and LCL > windy[0] * units.meters * 1.000009):
# add LCL to x
xlcl = windh(LCL.to('meters').magnitude, height, inv=True)
windx = np.sort(np.append(windx, xlcl))
windy = windh(windx, height)
pressures = mc.height_to_pressure_std(windy * units.meters)
wvmr0 = mc.mixing_ratio_from_relative_humidity(initp, temp_, humid / 100.)
# now calculate the air parcel temperatures and RH at each position
if (lcl_[0] <= min(pressures)):
T = mc.dry_lapse(pressures, temp_)
RH = [
mc.relative_humidity_from_mixing_ratio(
wvmr0, t, p) for t, p in zip(
T, pressures)]
else:
mini = np.argmin(pressures)
p1 = pressures[:mini + 1]
p2 = pressures[mini:] # with an overlap
p11 = p1[p1 >= lcl_[0] * .9999999] # lower (with tol) with lcl
p12 = p1[p1 < lcl_[0] * 1.000009] # upper (with tol) with lcl
T11 = mc.dry_lapse(p11, temp_)
T12 = mc.moist_lapse(p12, lcl_[1])
T1 = concatenate((T11[:-1], T12))
T2 = mc.dry_lapse(p2, T1[-1])
T = concatenate((T1, T2[1:]))
wvmrtop = mc.saturation_mixing_ratio(pressures[mini], T[mini])
RH=[]
for i in range(len(pressures)):
if pressures[i] > lcl_[0] and i <= mini:
v=mc.relative_humidity_from_mixing_ratio(pressures[i], T[i], wvmr0)
else:
if i < mini:
v=1
else:
v=mc.relative_humidity_from_mixing_ratio(pressures[i], T[i], wvmrtop)
RH.append(v)
#RH = [mc.relative_humidity_from_mixing_ratio(*tp, wvmr0) if tp[1] > lcl_[
#0] and i <= mini else 1.0 if i < mini else
#mc.relative_humidity_from_mixing_ratio(*tp, wvmrtop)
#for i, tp in enumerate(zip(pressures, T))]
RH = concatenate(RH)
return windx, mtny, windy, lcl_, LCL, T.to("degC"), RH
temp = ncid['T'][:, 1:].filled(np.NaN) # Kelvin
wvmr = 1e-3 * ncid['r'][:, 1:].filled(np.NaN) # convert to kg/kg
print('Time length: ', len(time))
# From dimension to variable.
press = np.zeros_like(temp)
for cnt in range(temp.shape[0]):
press[cnt, :] = lev
pressure = press * units.hPa
temperature = temp * units.K
mixing_ratio = wvmr * units('kg/kg')
# get dew point
relative_humidity = mpcalc.relative_humidity_from_mixing_ratio(
mixing_ratio, temperature, pressure)
e = mpcalc.vapor_pressure(pressure, mixing_ratio)
dew_point = mpcalc.dewpoint(e)
def get_cape(inargs, return_parcel_profile=False):
pres_prof, temp_prof, dp_prof = inargs
try:
prof = mpcalc.parcel_profile(pres_prof, temp_prof[0], dp_prof[0])
cape, cin = mpcalc.cape_cin(pres_prof, temp_prof, dp_prof, prof)
except Exception:
cape, cin, prof = np.NaN, np.NaN, np.NaN
print('Problem during CAPE-calculation. Likely NaN-related.')
if return_parcel_profile:
return cape, cin, prof
else:
df_selected_time[
'saturation_mixing_ratio'] = mpcalc.mixing_ratio(
VPS, p)
df_selected_time['mixing_ratio'] = mpcalc.mixing_ratio(
VP, p)
MRS = df_selected_time[
'saturation_mixing_ratio'].values * units('g/kg')
MR = df_selected_time['mixing_ratio'].values * units(
'g/kg')
# Calculate RH
#RH = mpcalc.relative_humidity_from_dewpoint(T[0], Td[0])
df_selected_time[
'RH'] = mpcalc.relative_humidity_from_dewpoint(T, Td)
df_selected_time[
'RH_MR'] = mpcalc.relative_humidity_from_mixing_ratio(
MR, T, p)
print('df_selected_time after drop nan.\n{0}'.format(
df_selected_time))
df_selected_time.to_csv(
r'{0}{1}{2}_{3}_solution.csv'.format(
dir_name, save_dir_name, filename_el[-5],
selected_time[:13]))
p = df_selected_time['pressure'].values * units.hPa
T = df_selected_time['temperature'].values * units.degC
Td = df_selected_time['dewpoint'].values * units.degC
wind_speed = df_selected_time['speed'].values * units.knots
wind_dir = df_selected_time[
'direction'].values * units.degrees
def f(fullname, selected_time):
fullname_el = fullname.split('/')
#fullname_el = fullname.split('\\')
filename = fullname_el[-1]
filename_el = filename.split('_')
save_base_dir_name = '../1data/'
save_dir_name = '{0}{1}/'.format(save_base_dir_name + dir_name, obs_year)
print('site : {0}'.format(dir_name))
if os.path.isfile('{0}{1}_{2}_student.csv'\
.format(save_dir_name, filename_el[-5], selected_time[:13]))\
and os.path.isfile('{0}{1}_{2}_solution.csv'\
.format(save_dir_name, filename_el[-5], selected_time[:13])):
write_log(log_file, '{3} ::: {0}{1}_{2} files are already exist'\
.format(save_dir_name, filename_el[-5], selected_time[:13], datetime.now()))
else:
try:
f = lambda s: selected_time in s
ids = df['time'].apply(f)
df_selected_time = df[ids]
df_selected_time = df_selected_time.sort_values('pressure',
ascending=False)
print('filename : {0}'.format(fullname))
print('df_selected_time.\n{0}'.format(df_selected_time))
df_selected_time.to_csv(r'{0}{1}_{2}_student.csv'\
.format(save_dir_name, filename_el[-5], selected_time[:13]))
#################################################################################
### We will pull the data out of the example dataset into individual variables and
### assign units.
#################################################################################
p = df_selected_time['pressure'].values * units.hPa
T = df_selected_time['temperature'].values * units.degC
Td = df_selected_time['dewpoint'].values * units.degC
wind_speed = df_selected_time['speed'].values * units.knots
wind_dir = df_selected_time['direction'].values * units.degrees
u, v = mpcalc.wind_components(wind_speed, wind_dir)
# Calculate web bulb temperature
df_selected_time['wet_bulb_T'] = mpcalc.wet_bulb_temperature(
p, T, Td)
# Calculate potential temperature
df_selected_time['potential_T'] = mpcalc.potential_temperature(
p, T)
df_selected_time['potential_T_C'] = df_selected_time[
'potential_T'].values - 273.15
# Calculate saturation vaper pressure
df_selected_time[
'saturation_vaper_pressure'] = mpcalc.saturation_vapor_pressure(
T)
df_selected_time[
'vaper_pressure'] = mpcalc.saturation_vapor_pressure(Td)
SVP = df_selected_time[
'saturation_vaper_pressure'].values * units.hPa
VP = df_selected_time['vaper_pressure'].values * units.hPa
# Calculate mixing ratio
df_selected_time['saturation_mixing_ratio'] = mpcalc.mixing_ratio(
SVP, p)
df_selected_time['mixing_ratio'] = mpcalc.mixing_ratio(VP, p)
SMR = df_selected_time['saturation_mixing_ratio'].values * units(
'g/kg')
MR = df_selected_time['mixing_ratio'].values * units('g/kg')
# Calculate relative humidity
df_selected_time['relative_humidity_from_dewpoint'] \
= mpcalc.relative_humidity_from_dewpoint(T, Td)
df_selected_time['relative_humidity_from_mixing_ratio'] \
= mpcalc.relative_humidity_from_mixing_ratio(MR, T, p)
# Calculate virtual temperature
df_selected_time['virtual_temperature'] \
= mpcalc.virtual_temperature(T, MR)
# Calculate virtual potential temperature
df_selected_time['virtual_potential_temperature'] \
= mpcalc.virtual_potential_temperature(p, T, MR)
print('df_selected_time after drop nan.\n{0}'.format(
df_selected_time))
df_selected_time.to_csv(r'{0}{1}_{2}_solution.csv'\
.format(save_dir_name, filename_el[-5], selected_time[:13]))
except Exception as err:
write_log(err_log_file, '{4} ::: {0} with {1}{2} on {3}'\
.format(err, dir_name, filename, selected_time[:13], datetime.now()))
print('Thread {0} is finished'.format(selected_time))
return 0 # Return a dummy value
