def empty_skewt(self):
#First create the figure and SkewT objects
fig = pp.figure(figsize=(9, 9))
skewt = SkewT(fig, rotation=45)
#Now set the limits
skewt.ax.set_xlim(-40, 60)
skewt.ax.set_ylim(1000, 100)
#Add the adiabats, etc
skewt.plot_dry_adiabats(t0=numpy.arange(-40, 200, 10) *
self.sounding_units["temp"])
skewt.plot_moist_adiabats()
try:
skewt.plot_mixing_lines(pressure=self.sounding["pres"])
except:
skewt.plot_mixing_lines(p=self.sounding["pres"])
#Adjust the axis labels
skewt.ax.set_xlabel("Temperature ('C)", fontsize=14, fontweight="bold")
skewt.ax.set_ylabel("Pressure (hPa)", fontsize=14, fontweight="bold")
#Returning
return fig, skewt
def create_skewt(self, rdat):
""" Create the SkewT plot inside the figure instance """
# Extract pressure from data
P = rdat['PRES'].values * units.hPa
# Extract temperature from data
T = rdat['TEMP'].values * units.degC
# Extract dewpt from data
Td = rdat['DWPT'].values * units.degC
skew = SkewT(self.fig, rotation=45)
# Change to read in min/max from data arrays??
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 80)
skew.ax.set_title(self.title)
skew.plot(P, T, 'r', linewidth=2)
skew.plot(P, Td, 'g', linewidth=2)
# Plot a zero degree isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
def plot_sounding(sndg_data, yr, day, mo, hr, diablo_sounding):
plt.rcParams['figure.figsize'] = (9, 9)
skew_evening = SkewT()
one_sounding = sndg_data.loc[sndg_data[' Hour'] == hr]
T = convert_temperature(one_sounding[' Temp'].values, 'F', 'C')
rh = one_sounding[' RH'].values
one_sounding[' Dewpt'] = calc_dewpt(T, rh)
one_sounding = one_sounding.dropna(subset=(' Temp', ' Dewpt'),
how='all').reset_index(drop=True)
T = convert_temperature(one_sounding[' Temp'].values, 'F',
'C') * units.degC
p = one_sounding[' Pres'].values * units.hPa
Td = one_sounding[' Dewpt'].values * units.degC
wind_speed = one_sounding[' Spd'].values * units.knots
wind_dir = one_sounding[' Dir '].values * units.degrees
u, v = mpcalc.get_wind_components(wind_speed, wind_dir)
skew_evening.plot(p, T, 'r')
skew_evening.plot(p, Td, 'g')
skew_evening.plot_barbs(p, u, v)
skew_evening.plot_dry_adiabats()
skew_evening.plot_moist_adiabats()
skew_evening.plot_mixing_lines()
skew_evening.ax.set_ylim(1000, 100)
plt.title('OAK Sounding: ' + str(int(mo)) + '/' + str(int(day)) + '/' +
str(int(yr)) + ': ' + str(int(hr)) + ' UTC')
plt.savefig('../Images/20180703/' + diablo_sounding +
'/OAK_sounding_eve_' + str(int(mo)) + '_' + str(int(day)) +
'_' + str(int(yr)) + '_' + str(int(hr)) + 'UTC.png')
plt.close()
return one_sounding
def test_skewt_api():
"""Test the SkewT API."""
with matplotlib.rc_context({'axes.autolimit_mode': 'data'}):
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig, aspect='auto')
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
p = np.linspace(1000, 100, 10)
t = np.linspace(20, -20, 10)
u = np.linspace(-10, 10, 10)
skew.plot(p, t, 'r')
skew.plot_barbs(p, u, u)
skew.ax.set_xlim(-20, 30)
skew.ax.set_ylim(1000, 100)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
# Call again to hit removal statements
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
return fig
def plot_sounding(P, T, Td, U, V, r_time, ID):
##need the metpy package
##from metpy.plots import SkewT
##from metpy.units import units
##import metpy.calc as mcalc
fig = plt.figure(figsize=(7, 6))
skew = SkewT(fig)
skew.plot(P, T, 'r')
skew.plot(P, Td, 'g')
idx = mcalc.resample_nn_1d(
P,
np.array([1000, 975, 950, 925, 900, 850, 800, 750, 700, 650, 600,
500]))
skew.plot_barbs(P[idx],
U[idx] * units('m/s'),
V[idx] * units('m/s'),
plot_units=units('m/s'))
##special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats(color='blue')
skew.plot_mixing_lines(p=np.linspace(1100, 300) * units.hPa)
##title etc.,
plt.title(str(ID) + '_' + str(r_time) + 'LST')
plt.xlim(-40, 40)
plt.ylim(1100, 300)
for i in range(-70, 40, 20):
plt.fill_between(range(i, i + 11), 1100, 300, color='#C4FF8C')
#plt.savefig('merged_data_plot/' + fname + '.png')
plt.show()
def plot_sounding(date, station):
p, T, Td, u, v, windspeed = get_sounding_data(date, station)
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
lfc_pressure, lfc_temperature = mpcalc.lfc(p, T, Td)
parcel_path = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
# Create a new figure. The dimensions here give a good aspect ratio
fig = plt.figure(figsize=(8, 8))
skew = SkewT(fig)
# Plot the data
temperature_line, = skew.plot(p, T, color='tab:red')
dewpoint_line, = skew.plot(p, Td, color='blue')
cursor = mplcursors.cursor([temperature_line, dewpoint_line])
# Plot thermodynamic parameters and parcel path
skew.plot(p, parcel_path, color='black')
if lcl_pressure:
skew.ax.axhline(lcl_pressure, color='black')
if lfc_pressure:
skew.ax.axhline(lfc_pressure, color='0.7')
# Add the relevant special lines
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
# Shade areas representing CAPE and CIN
skew.shade_cin(p, T, parcel_path)
skew.shade_cape(p, T, parcel_path)
# Add wind barbs
skew.plot_barbs(p, u, v)
# Add an axes to the plot
ax_hod = inset_axes(skew.ax, '30%', '30%', loc=1, borderpad=3)
# Plot the hodograph
h = Hodograph(ax_hod, component_range=100.)
# Grid the hodograph
h.add_grid(increment=20)
# Plot the data on the hodograph
mask = (p >= 100 * units.mbar)
h.plot_colormapped(u[mask], v[mask],
windspeed[mask]) # Plot a line colored by wind speed
# Set some sensible axis limits
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 60)
return fig, skew
def test_skewt_default_aspect_empty():
"""Test SkewT with default aspect and no plots, only special lines."""
# With this rotation and the default aspect, this matches exactly the NWS SkewT PDF
fig = plt.figure(figsize=(12, 9))
skew = SkewT(fig, rotation=43)
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
return fig
def plot_sounding(date, station):
p, T, Td, u, v, windspeed = get_sounding_data(date, station)
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
lfc_pressure, lfc_temperature = mpcalc.lfc(p, T, Td)
parcel_path = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
# Create a new figure. The dimensions here give a good aspect ratio
fig = plt.figure(figsize=(8, 8))
skew = SkewT(fig)
# Plot the data
temperature_line, = skew.plot(p, T, color='tab:red')
dewpoint_line, = skew.plot(p, Td, color='blue')
cursor = mplcursors.cursor([temperature_line, dewpoint_line])
# Plot thermodynamic parameters and parcel path
skew.plot(p, parcel_path, color='black')
if lcl_pressure:
skew.ax.axhline(lcl_pressure, color='black')
if lfc_pressure:
skew.ax.axhline(lfc_pressure, color='0.7')
# Add the relevant special lines
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
# Shade areas representing CAPE and CIN
skew.shade_cin(p, T, parcel_path)
skew.shade_cape(p, T, parcel_path)
# Add wind barbs
skew.plot_barbs(p, u, v)
# Add an axes to the plot
ax_hod = inset_axes(skew.ax, '30%', '30%', loc=1, borderpad=3)
# Plot the hodograph
h = Hodograph(ax_hod, component_range=100.)
# Grid the hodograph
h.add_grid(increment=20)
# Plot the data on the hodograph
mask = (p >= 100 * units.mbar)
h.plot_colormapped(u[mask], v[mask], windspeed[mask]) # Plot a line colored by wind speed
# Set some sensible axis limits
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 60)
return fig, skew
def plot_skewt_icon(sounding, parcel=None, base=1000, top=100, skew=45):
model_time = np.datetime_as_string(sounding.metadata.model_time, unit='m')
valid_time = np.datetime_as_string(sounding.metadata.valid_time, unit='m')
top_idx = find_closest_model_level(sounding.p * units.Pa, top * units("hPa"))
fig = plt.figure(figsize=(11, 11), constrained_layout=True)
skew = SkewT(fig, rotation=skew)
skew.plot(sounding.p * units.Pa, sounding.T * units.K, 'r')
skew.plot(sounding.p * units.Pa, sounding.Td, 'b')
skew.plot_barbs(sounding.p[:top_idx] * units.Pa, sounding.U[:top_idx] * units.mps,
sounding.V[:top_idx] * units.mps, plot_units=units.knot, alpha=0.6, xloc=1.13, x_clip_radius=0.3)
if parcel == "surface-based":
prof = mpcalc.parcel_profile(sounding.p * units.Pa, sounding.T[0] * units.K, sounding.Td[0]).to('degC')
skew.plot(sounding.p * units.Pa, prof, 'y', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.plot(sounding.p * units.Pa, np.zeros(len(sounding.p)) * units.degC, "#03d3fc", linewidth=1)
skew.ax.set_ylim(base, top)
plt.title(f"Model run: {model_time}Z", loc='left')
plt.title(f"Valid time: {valid_time}Z", fontweight='bold', loc='right')
plt.xlabel("Temperature [°C]")
plt.ylabel("Pressure [hPa]")
fig.suptitle(f"ICON-EU Model for {sounding.latitude_pretty}, {sounding.longitude_pretty}", fontsize=14)
ax1 = plt.gca()
ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis
color = '#333333'
ax2.set_ylabel('Geometric Altitude [kft]', color=color) # we already handled the x-label with ax1
ax2_data = (sounding.p * units.Pa).to('hPa')
ax2.plot(np.zeros(len(ax2_data)), ax2_data, color=color, alpha=0.0)
ax2.tick_params(axis='y', labelcolor=color)
ax2.set_yscale('log')
ax2.set_ylim((base, top))
ticks = np.linspace(base, top, num=10)
ideal_ticks = np.geomspace(base, top, 20)
real_tick_idxs = [find_closest_model_level(sounding.p * units.Pa, p_level * units("hPa")) for p_level in
ideal_ticks]
ticks = (sounding.p * units.Pa).to("hPa")[real_tick_idxs]
full_levels = [full_level_height(sounding.HHL, idx) for idx in real_tick_idxs]
tick_labels = np.around((full_levels * units.m).m_as("kft"), decimals=1)
ax2.set_yticks(ticks)
ax2.set_yticklabels(tick_labels)
ax2.minorticks_off()
return fig
def make_skewt():
# Get the data
date = request.args.get('date')
time = request.args.get('time')
region = request.args.get('region')
station = request.args.get('station')
date = datetime.strptime(date, '%Y%m%d')
date = datetime(date.year, date.month, date.day, int(time))
df = get_sounding_data(date, region, station)
p = df['pressure'].values * units(df.units['pressure'])
T = df['temperature'].values * units(df.units['temperature'])
Td = df['dewpoint'].values * units(df.units['dewpoint'])
u = df['u_wind'].values * units(df.units['u_wind'])
v = df['v_wind'].values * units(df.units['v_wind'])
# Make the Skew-T
fig = plt.figure(figsize=(9, 9))
add_metpy_logo(fig, 115, 100)
skew = SkewT(fig, rotation=45)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'tab:red')
skew.plot(p, Td, 'tab:green')
skew.plot_barbs(p, u, v)
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 60)
# Calculate LCL height and plot as black dot
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
skew.plot(p, prof, 'k', linewidth=2)
# Shade areas of CAPE and CIN
skew.shade_cin(p, T, prof)
skew.shade_cape(p, T, prof)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
canvas = FigureCanvas(fig)
img = BytesIO()
fig.savefig(img)
img.seek(0)
return send_file(img, mimetype='image/png')
def plot_skewt(self, station_data):
"""
:param adjusted_data: receives the post processed dataframe
:param valid:
:return:
"""
# We will pull the data out of the example dataset into individual variables
# and assign units.
p = station_data['pressure'].values * units.hPa
T = station_data['Temperature_isobaric'].values * units.degC
Td = station_data['Dewpoint'].replace(np.nan,
0.0000001).values * units.degC
u = station_data['u-component_of_wind_isobaric'].values * \
units('meters / second').to('knots')
v = station_data['v-component_of_wind_isobaric'].values * \
units('meters / second').to('knots')
# Create a new figure. The dimensions here give a good aspect ratio.
fig = plt.figure(figsize=(12, 9))
skew = SkewT(fig, rotation=45)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
skew.plot_barbs(p, u, v)
skew.ax.set_ylim(1020, 100)
skew.ax.set_xlim(-40, 60)
# Calculate LCL height and plot as black dot
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = mpcalc.parcel_profile(p, T[0], Td[0])
skew.plot(p, prof, 'k', linewidth=2)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.shade_cape(p, T, prof)
skew.shade_cin(p, T, prof)
return skew
def core(p, T, Td, u, v, **kwargs):
# Calculate the LCL
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
#print('LCL p, t:', int(lcl_pressure), int(lcl_temperature))
# Calculate the parcel profile.
parcel_prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
# Create a new figure. The dimensions here give a good aspect ratio
fig = plt.figure(figsize=(8, 8))
skew = SkewT(fig, rotation=45)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
#skew.plot(p, T, 'k-')
skew.plot(p, T, 'r.-', ms=5, lw=2, label='mean T')
skew.plot(p, Td, 'g.-', ms=5, lw=2, label='mean Td')
skew.plot_barbs(p, u, v)
skew.ax.set_ylim(1000, 180)
skew.ax.set_xlim(-20, 40)
# Plot LCL temperature as black dot
skew.plot(lcl_pressure, lcl_temperature, 'k.', markerfacecolor='black')
# Plot the parcel profile as a black line
skew.plot(p, parcel_prof, 'k', linewidth=2)
# Shade areas of CAPE and CIN
skew.shade_cin(p, T, parcel_prof)
skew.shade_cape(p, T, parcel_prof)
# Plot a zero degree isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats(lw=.5)
skew.plot_moist_adiabats(lw=.5)
skew.plot_mixing_lines(lw=.5)
# Show the plot
#plt.show()
#skew.ax.set_title(time_str)
plt.legend(loc='lower left')
plt.title(kwargs.get('title'))
fname = kwargs.get('saveto', 'profile.png')
fig.savefig(fname)
print(fname, 'saved.')
plt.close()
def plot_skewt(df):
# We will pull the data out of the example dataset into individual variables
# and assign units.
hght = df['height'].values * units.hPa
p = df['pressure'].values * units.hPa
T = df['temperature'].values * units.degC
Td = df['dewpoint'].values * units.degC
wind_speed = df['speed'].values * units.knots
wind_dir = df['direction'].values * units.degrees
u, v = mpcalc.wind_components(wind_speed, wind_dir)
# Create a new figure. The dimensions here give a good aspect ratio.
fig = plt.figure(figsize=(9, 12))
skew = SkewT(fig, rotation=45)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
skew.plot_barbs(p, u, v)
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 60)
# Calculate LCL height and plot as black dot
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
skew.plot(p, prof, 'k', linewidth=2)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
# Create a hodograph
ax_hod = inset_axes(skew.ax, '40%', '40%', loc=2)
h = Hodograph(ax_hod, component_range=80.)
h.add_grid(increment=20)
h.plot_colormapped(u, v, hght)
return skew
def plot_skewt(p, t, td, puv=None, u=None, v=None, title=None, outfile=None):
# Create a new figure. The dimensions here give a good aspect ratio
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig, rotation=30)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, t, 'r', linewidth=2)
skew.plot(p, td, 'g', linewidth=2)
if u is not None and v is not None:
skew.plot_barbs(puv, u, v)
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 60)
# Calculate the LCL
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], t[0], td[0])
# Calculate the parcel profile.
parcel_prof = mpcalc.parcel_profile(p, t[0], td[0]).to('degC')
# Plot LCL temperature as black dot
skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Plot the parcel profile as a black line
skew.plot(p, parcel_prof, 'k--', linewidth=1)
# Shade areas of CAPE and CIN
skew.shade_cin(p, t, parcel_prof)
skew.shade_cape(p, t, parcel_prof)
# Plot a zero degree isotherm
#skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
if title is not None:
plt.title(title)
# Show the plot
#plt.show()
if outfile is None: outfile = 'skewt.png'
fig.savefig(outfile, format='png')
def skewt(p, T, Td, u, v):
"""
Adapted from the Metpy advanced sounding example
(https://unidata.github.io/MetPy/latest/examples/Advanced_Sounding.html#sphx-glr-examples-advanced-sounding-py)
"""
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot.
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
skew.plot_barbs(p, u, v)
# Calculate LCL height and plot as black dot. Because `p`'s first value is
# ~1000 mb and its last value is ~250 mb, the `0` index is selected for
# `p`, `T`, and `Td` to lift the parcel from the surface. If `p` was inverted,
# i.e. start from low value, 250 mb, to a high value, 1000 mb, the `-1` index
# should be selected.
#lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
#skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
#prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
#skew.plot(p, prof, 'k', linewidth=2)
# Shade areas of CAPE and CIN
#skew.shade_cin(p, T, prof, Td)
#skew.shade_cape(p, T, prof)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
#skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.ax.set_ylim(1000, 600)
skew.ax.set_xlim(0, 60)
return
def test_skewt_api_units():
"""#Test the SkewT API when units are provided."""
with matplotlib.rc_context({'axes.autolimit_mode': 'data'}):
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
p = (np.linspace(950, 100, 10) * units.hPa).to(units.Pa)
t = (np.linspace(18, -20, 10) * units.degC).to(units.kelvin)
u = np.linspace(-20, 20, 10) * units.knots
skew.plot(p, t, 'r')
skew.plot_barbs(p, u, u)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
return fig
def test_skewt_api():
"""Test the SkewT API."""
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
p = np.linspace(1000, 100, 10)
t = np.linspace(20, -20, 10)
u = np.linspace(-10, 10, 10)
skew.plot(p, t, 'r')
skew.plot_barbs(p, u, u)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
return fig
def test_skewt_adiabat_units():
"""Test adiabats and mixing lines can handle different units."""
with matplotlib.rc_context({'axes.autolimit_mode': 'data'}):
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
p = np.linspace(950, 100, 10) * units.hPa
t = np.linspace(18, -20, 10) * units.degC
skew.plot(p, t, 'r')
# Add lines with units different to the xaxis
t0 = (np.linspace(-20, 20, 5) * units.degC).to(units.degK)
skew.plot_dry_adiabats(t0=t0)
# add lines with no units
t0 = np.linspace(-20, 20, 5)
skew.plot_moist_adiabats(t0=t0)
skew.plot_mixing_lines()
return fig
def test_skewt_api():
"""Test the SkewT API."""
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
p = np.linspace(1000, 100, 10)
t = np.linspace(20, -20, 10)
u = np.linspace(-10, 10, 10)
skew.plot(p, t, 'r')
skew.plot_barbs(p, u, u)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
return fig
def Skew_T_diagram(T, z, wv):
""" Plot a Skew-T diagram. Credits @ MetPy: https://unidata.github.io/MetPy/latest/index.html """
from metpy.plots import SkewT
P = P_env(z) / 100
wvs = wv_sat(T, z)
Td = T_dew(wv, z)
env = T_env(z)
zLCL = np.argmin(abs(T - Td))
P_LCL = P[:zLCL]
Td = Td[:zLCL]
fig = plt.figure(figsize=(11, 11))
skew = SkewT(fig, rotation=45)
skew.plot(P_LCL, Td, 'b', linewidth=3, label='T_dew')
skew.plot(P, T, 'r', linewidth=3, label='T_parc')
skew.plot(P, env, 'g', linewidth=3, label='T_env')
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.ax.set_ylim(1010, 100)
skew.plot(P[zLCL],
T[zLCL],
'.k',
markersize=15,
label='LCL = %.1f km' % np.round(z[zLCL] / 1000, 1))
skew.shade_cin(P[zLCL:], env[zLCL:], T[zLCL:], label='Level above LFC')
skew.shade_cape(P[zLCL:], env[zLCL:], T[zLCL:], label='CAPE')
plt.legend()
skew.ax.set_xlim(-30, 40)
skew.ax.set_xlabel('Temperature [C]')
skew.ax.set_ylabel('Pressure [hPa]')
skew.ax.set_title('Skew-T diagram Essen Sounding')
return plt.show()
def test_skewt_adiabat_kelvin_base():
"""Test adiabats and mixing lines can handle different units."""
with matplotlib.rc_context({'axes.autolimit_mode': 'data'}):
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig, rotation=45)
p = np.linspace(950, 100, 10) * units.hPa
t = (np.linspace(18, -30, 10) * units.degC).to(units.degK)
skew.plot(p, t, 'r')
# At this point the xaxis is actually degC
# Add lines using kelvin base
t0 = (np.linspace(-20, 40, 5) * units.degC).to(units.degK)
skew.plot_dry_adiabats(t0=t0)
# add lines with no units (but using kelvin)
t0 = np.linspace(253.15, 313.15, 5)
skew.plot_moist_adiabats(t0=t0)
skew.plot_mixing_lines()
return fig
def test_skewt_api_units():
"""#Test the SkewT API when units are provided."""
with matplotlib.rc_context({'axes.autolimit_mode': 'data'}):
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
p = (np.linspace(950, 100, 10) * units.hPa).to(units.Pa)
t = (np.linspace(18, -20, 10) * units.degC).to(units.kelvin)
u = np.linspace(-20, 20, 10) * units.knots
skew.plot(p, t, 'r')
skew.plot_barbs(p, u, u)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
# This works around the fact that newer pint versions default to degrees_Celsius
skew.ax.set_xlabel('degC')
return fig
def plot(self, savename=None):
# p in hPa, T and Td in K, qv in kg/kg.
# u and v (optional) in m/s.
# All inputs are 1-D arrays.
from matplotlib import pyplot as plt
from metpy.units import units
from metpy.plots import SkewT
import numpy as np
plt.rcParams['figure.figsize'] = (6, 8)
# Set lower limit for plotting on p-axis.
maxp = np.max(self.p)
skew = SkewT()
# Plot data.
skew.plot(self.p * units.hPa, self.T * units.K, 'r')
skew.plot(self.p * units.hPa, self.Td * units.K, 'g')
if self.u is not None and self.v is not None:
skew.plot_barbs((self.p * units.hPa)[::100],
(self.u * units.meters / units.seconds)[::100],
(self.v * units.meters / units.seconds)[::100])
# Add some lines and labels.
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.ax.set_ylabel('Pressure (hPa)')
skew.ax.set_xlabel(
r'Temperature ($^{\circ}$C), Mixing Ratio (g kg$^{-1}$)')
# Set lower limit for plotting on p-axis.
skew.ax.set_ylim(max(maxp, 1000), 100)
# Save plot to a file based on input name.
if savename is not None:
fig = plt.gcf()
fig.savefig(savename)
def test_skewt_api():
"""Test the SkewT API."""
with matplotlib.rc_context({'axes.autolimit_mode': 'data'}):
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
p = np.linspace(1000, 100, 10)
t = np.linspace(20, -20, 10)
u = np.linspace(-10, 10, 10)
skew.plot(p, t, 'r')
skew.plot_barbs(p, u, u)
skew.ax.set_xlim(-20, 30)
skew.ax.set_ylim(1000, 100)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
return fig
# Create a new figure. The dimensions here give a good aspect ratio fig = plt.figure(figsize=(9, 9)) add_metpy_logo(fig, 115, 100) # Grid for plots skew = SkewT(fig, rotation=45) # Plot the data using normal plotting functions, in this case using # log scaling in Y, as dictated by the typical meteorological plot skew.plot(p, T, 'r') skew.plot(p, Td, 'g') skew.plot_barbs(p, u, v) skew.ax.set_ylim(1000, 100) # Add the relevant special lines skew.plot_dry_adiabats() skew.plot_moist_adiabats() skew.plot_mixing_lines() # Good bounds for aspect ratio skew.ax.set_xlim(-50, 60) # Create a hodograph ax_hod = inset_axes(skew.ax, '40%', '40%', loc=1) h = Hodograph(ax_hod, component_range=80.) h.add_grid(increment=20) h.plot_colormapped(u, v, np.hypot(u, v)) # Show the plot plt.show()
class Window(QtGui.QMainWindow):
r""" A mainwindow object for the GUI display. Inherits from QMainWindow."""
def __init__(self):
super(Window, self).__init__()
self.interface()
def interface(self):
r""" Contains the main window interface generation functionality. Commented where needed."""
# Get the screen width and height and set the main window to that size
screen = QtGui.QDesktopWidget().screenGeometry()
self.setGeometry(0, 0, 800, screen.height())
self.setMaximumSize(QtCore.QSize(800, 2000))
# Set the window title and icon
self.setWindowTitle("WAVE: Weather Analysis and Visualization Environment")
self.setWindowIcon(QtGui.QIcon('./img/wave_64px.png'))
# Import the stylesheet for this window and set it to the window
stylesheet = "css/MainWindow.css"
with open(stylesheet, "r") as ssh:
self.setStyleSheet(ssh.read())
self.setAutoFillBackground(True)
self.setBackgroundRole(QtGui.QPalette.Highlight)
# Create actions for menus and toolbar
exit_action = QtGui.QAction(QtGui.QIcon('./img/exit_64px.png'), 'Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
clear_action = QtGui.QAction(QtGui.QIcon('./img/clear_64px.png'), 'Clear the display', self)
clear_action.setShortcut('Ctrl+C')
clear_action.setStatusTip('Clear the display')
clear_action.triggered.connect(self.clear_canvas)
skewt_action = QtGui.QAction(QtGui.QIcon('./img/skewt_64px.png'), 'Open the skew-T dialog', self)
skewt_action.setShortcut('Ctrl+S')
skewt_action.setStatusTip('Open the skew-T dialog')
skewt_action.triggered.connect(self.skewt_dialog)
radar_action = QtGui.QAction(QtGui.QIcon('./img/radar_64px.png'), 'Radar', self)
radar_action.setShortcut('Ctrl+R')
radar_action.setStatusTip('Open Radar Dialog Box')
radar_action.triggered.connect(self.radar_dialog)
# Create the top menubar, setting native to false (for OS) and add actions to the menus
menubar = self.menuBar()
menubar.setNativeMenuBar(False)
filemenu = menubar.addMenu('&File')
editmenu = menubar.addMenu('&Edit')
helpmenu = menubar.addMenu('&Help')
filemenu.addAction(exit_action)
# Create the toolbar, place it on the left of the GUI and add actions to toolbar
left_tb = QtGui.QToolBar()
self.addToolBar(QtCore.Qt.LeftToolBarArea, left_tb)
left_tb.setMovable(False)
left_tb.addAction(clear_action)
left_tb.addAction(skewt_action)
left_tb.addAction(radar_action)
self.setIconSize(QtCore.QSize(30, 30))
# Create the toolbar, place it on the left of the GUI and add actions to toolbar
right_tb = QtGui.QToolBar()
self.addToolBar(QtCore.Qt.RightToolBarArea, right_tb)
right_tb.setMovable(False)
right_tb.addAction(clear_action)
right_tb.addAction(skewt_action)
right_tb.addAction(radar_action)
# Create the status bar with a default display
self.statusBar().showMessage('Ready')
# Figure and canvas widgets that display the figure in the GUI
self.figure = plt.figure(facecolor='#2B2B2B')
self.canvas = FigureCanvas(self.figure)
# Add subclassed matplotlib navbar to GUI
# spacer widgets for left and right of buttons
left_spacer = QtGui.QWidget()
left_spacer.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
right_spacer = QtGui.QWidget()
right_spacer.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
self.mpltb = QtGui.QToolBar()
self.mpltb.addWidget(left_spacer)
self.mpltb.addWidget(MplToolbar(self.canvas, self))
self.mpltb.addWidget(right_spacer)
self.mpltb.setMovable(False)
self.addToolBar(QtCore.Qt.TopToolBarArea, self.mpltb)
# Set the figure as the central widget and show the GUI
self.setCentralWidget(self.canvas)
self.show()
def skewt_dialog(self):
r""" When the toolbar icon for the Skew-T dialog is clicked, this function is executed. Creates an instance of
the SkewTDialog object which is the dialog box. If the submit button on the dialog is clicked, get the user
inputted values and pass them into the sounding retrieval call (DataAccessor.get_sounding) to fetch the data.
Finally, plot the returned data via self.plot.
Args:
None.
Returns:
None.
Raises:
None.
"""
dialog = SkewTDialog()
if dialog.exec_():
source, lat, long = dialog.get_values()
t, td, p, u, v, lat, long, time = DataAccessor.get_sounding(source, lat, long)
self.plot(t, td, p, u, v, lat, long, time)
def plot(self, t, td, p, u, v, lat, long, time):
r"""Displays the Skew-T data on a matplotlib figure.
Args:
t (array-like): A list of temperature values.
td (array-like): A list of dewpoint values.
p (array-like): A list of pressure values.
u (array-like): A list of u-wind component values.
v (array-like): A list of v-wind component values.
lat (string): A string containing the requested latitude value.
long (string): A string containing the requested longitude value.
time (string): A string containing the UTC time requested with seconds truncated.
Returns:
None.
Raises:
None.
"""
# Create a new figure. The dimensions here give a good aspect ratio
self.skew = SkewT(self.figure, rotation=40)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
self.skew.plot(p, t, 'r')
self.skew.plot(p, td, 'g')
self.skew.plot_barbs(p, u, v, barbcolor='#FF0000', flagcolor='#FF0000')
self.skew.ax.set_ylim(1000, 100)
self.skew.ax.set_xlim(-40, 60)
# Axis colors
self.skew.ax.tick_params(axis='x', colors='#A3A3A4')
self.skew.ax.tick_params(axis='y', colors='#A3A3A4')
# Calculate LCL height and plot as black dot
l = lcl(p[0], t[0], td[0])
lcl_temp = dry_lapse(concatenate((p[0], l)), t[0])[-1].to('degC')
self.skew.plot(l, lcl_temp, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = parcel_profile(p, t[0], td[0]).to('degC')
self.skew.plot(p, prof, 'k', linewidth=2)
# Color shade areas between profiles
self.skew.ax.fill_betweenx(p, t, prof, where=t >= prof, facecolor='#5D8C53', alpha=0.7)
self.skew.ax.fill_betweenx(p, t, prof, where=t < prof, facecolor='#CD6659', alpha=0.7)
# Add the relevant special lines
self.skew.plot_dry_adiabats()
self.skew.plot_moist_adiabats()
self.skew.plot_mixing_lines()
# Set title
deg = u'\N{DEGREE SIGN}'
self.skew.ax.set_title('Sounding for ' + lat + deg + ', ' + long + deg + ' at ' + time + 'z', y=1.02,
color='#A3A3A4')
# Discards old graph, works poorly though
# skew.ax.hold(False)
# Figure and canvas widgets that display the figure in the GUI
# set canvas size to display Skew-T appropriately
self.canvas.setMaximumSize(QtCore.QSize(800, 2000))
# refresh canvas
self.canvas.draw()
def radar_dialog(self):
r""" When the toolbar icon for the Skew-T dialog is clicked, this function is executed. Creates an instance of
the SkewTDialog object which is the dialog box. If the submit button on the dialog is clicked, get the user
inputted values and pass them into the sounding retrieval call (DataAccessor.get_sounding) to fetch the data.
Finally, plot the returned data via self.plot.
Args:
None.
Returns:
None.
Raises:
None.
"""
radar_dialog = RadarDialog()
if radar_dialog.exec_():
station, product = radar_dialog.get_radarvals()
x, y, ref = DataAccessor.get_radar(station, product)
self.plot_radar(x, y, ref)
def plot_radar(self, x, y, ref):
r"""Displays the Skew-T data on a matplotlib figure.
Args:
t (array-like): A list of temperature values.
td (array-like): A list of dewpoint values.
p (array-like): A list of pressure values.
u (array-like): A list of u-wind component values.
v (array-like): A list of v-wind component values.
lat (string): A string containing the requested latitude value.
long (string): A string containing the requested longitude value.
time (string): A string containing the UTC time requested with seconds truncated.
Returns:
None.
Raises:
None.
"""
self.ax = self.figure.add_subplot(111)
self.ax.pcolormesh(x, y, ref)
self.ax.set_aspect('equal', 'datalim')
self.ax.set_xlim(-460, 460)
self.ax.set_ylim(-460, 460)
self.ax.tick_params(axis='x', colors='#A3A3A4')
self.ax.tick_params(axis='y', colors='#A3A3A4')
# set canvas size to display Skew-T appropriately
self.canvas.setMaximumSize(QtCore.QSize(800, 2000))
# refresh canvas
self.canvas.draw()
def clear_canvas(self):
self.canvas.close()
self.figure = plt.figure(facecolor='#2B2B2B')
self.canvas = FigureCanvas(self.figure)
self.setCentralWidget(self.canvas)
s = []
bot=2000.
# Space out wind barbs evenly on log axis.
for ind, i in enumerate(prof.pres):
if i < 100: break
if np.log(bot/i) > 0.04:
s.append(ind)
bot = i
b = skew.plot_barbs(prof.pres[s], prof.u[s], prof.v[s], linewidth=0.4, length=6)
# 'knots' label under wind barb stack
kts = ax.text(1.0, 0, 'knots', clip_on=False, ha='center',va='bottom',size=7,zorder=2)
# Tried drawing adiabats and mixing lines right after creating SkewT object but got errors.
draw_adiabats = skew.plot_dry_adiabats(color='r', alpha=0.2, linestyle="solid")
moist_adiabats = skew.plot_moist_adiabats(linewidth=0.5, color='black', alpha=0.2)
mixing_lines = skew.plot_mixing_lines(color='g', alpha=0.35, linestyle="dotted")
string = "created "+str(datetime.datetime.now(tz=None)).split('.')[0]
plt.annotate(s=string, xy=(10,2), xycoords='figure pixels', fontsize=5)
res = plt.savefig(ofile,dpi=125)
skew.ax.clear()
ax.clear()
if verbose:
print 'created', os.path.realpath(ofile)
mapax.clear()
hodo_ax.clear()
# Copy to web server
if '.snd' in sfile:
skew.plot(p, T_max, 'r:', alpha=0.8)
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-30, 60)
if stationid == "FIM00002963" or stationid == "FIM00002836":
title = station + " " + time + "UTC month=" + month + " (NOAA)"
else:
title = stationid + " " + time + "UTC month=" + month + " (NOAA)"
plt.title(title, fontdict=font_title)
plt.xlabel("T (C)", fontdict=font_axis)
plt.ylabel("P (hPa)", fontdict=font_axis)
skew.plot_dry_adiabats(alpha=0.3)
skew.plot_moist_adiabats(alpha=0.3)
skew.plot_mixing_lines(alpha=0.3)
skew.ax.set_ylim(1000, 100)
label1 = year1 + ' air temperature'
label2 = year1 + ' dew point temperature'
label3 = year2 + "-" + year3 + " air temperature"
label4 = year2 + "-" + year3 + " dew point temperature"
label5 = year2 + "-" + year3 + " air temperature $\pm$ SD"
line1, = plt.plot([1, 2, 3], label=label1, color="black", linestyle="-")
line2, = plt.plot([3, 2, 1], label=label2, color="black", linestyle="-.")
line3, = plt.plot([3, 2, 1], label=label3, color="red")
line4, = plt.plot([3, 2, 1], label=label4, color="red", linestyle="-.")
line5, = plt.plot([3, 2, 1], label=label5, color="red", linestyle=":")
plt.legend(handles=[line1, line2, line3, line4, line5], loc=5)
outfile_name = "./graphs/" + station + "_" + time + "utc.png"
plt.savefig(outfile_name)
plt.savefig("skewt.pdf")
def plotUAVskewT(filenamecsv):
'''
Input filepath of post-processed uav data
Outputs Skew-T log-p plot of UAV data, includes hodograph and some
convective parameters
'''
copdata = csvread_copter(filenamecsv)
lat = copdata[0]
lon = copdata[1]
alt = copdata[2]
pressure = copdata[3]
temperature = copdata[4]
dewpoint = copdata[5]
speed = copdata[9]
speed_kts = speed * 1.94
direction = copdata[10]
site = findSite(lat[0], lon[0])
sitename, sitelong = site.split('/')
fname = filenamecsv.split('\\')[-1]
timeTakeoff = datetime.strptime(fname[:15], '%Y%m%d_%H%M%S')
copterNum = fname[-10]
u,v = mcalc.get_wind_components(speed_kts*units.kts, direction * units.deg)
u = u.to(units.kts)
v = v.to(units.kts)
# Wind shear
bulkshear = speed_kts[-3] - speed_kts[0]
print '0-%d m Bulk Shear: %.0f kts' % (alt[-3], bulkshear)
if np.isnan(dewpoint).all():
moist = 0
else:
moist = 1
print 'Plotting...'
fignum = plt.figure(figsize=(12,9))
gs = gridspec.GridSpec(4, 4)
skew = SkewT(fignum, rotation=20, subplot=gs[:, :2])
skew.plot(pressure, temperature, 'r', linewidth = 2)
skew.plot(pressure, dewpoint, 'g', linewidth = 2)
skew.plot_barbs(pressure[0::4], u[0::4], v[0::4], x_clip_radius = 0.12, \
y_clip_radius = 0.12)
# Plot convective parameters
if moist:
plcl, Tlcl, isbelowlcl, profile = parcelUAV(temperature,
dewpoint, pressure)
SBCAPE = uavCAPE(temperature * units.degC, profile,
pressure * units.hPa)
skew.plot(plcl, Tlcl, 'ko', markerfacecolor='black')
skew.plot(pressure, profile, 'k', linewidth=2)
else:
isbelowlcl = 0
# set up plot limits and labels - use LCL as max if higher than profile
# if moist:
# xmin = math.floor(np.nanmin(dewpoint)) + 2
# else:
# xmin = math.floor(np.nanmin(temperature))
# xmax = math.floor(np.nanmax(temperature)) + 20
xmin = 0.
xmax = 50.
if isbelowlcl:
ymin = round((plcl / units.mbar), -1) - 10
else:
ymin = round(np.nanmin(pressure),-1) - 10
ymax = round(np.nanmax(pressure),-1) + 10
skew.ax.set_ylim(ymax, ymin)
skew.ax.set_xlim(xmin, xmax)
skew.ax.set_yticks(np.arange(ymin, ymax+10, 10))
skew.ax.set_xlabel('Temperature ($^\circ$C)')
skew.ax.set_ylabel('Pressure (hPa)')
titleName = 'Coptersonde-%s %s UTC - %s' % (copterNum,
timeTakeoff.strftime('%d-%b-%Y %H:%M:%S'), sitename)
skew.ax.set_title(titleName)
skew.plot_dry_adiabats(linewidth=0.75)
skew.plot_moist_adiabats(linewidth=0.75)
skew.plot_mixing_lines(linewidth=0.75)
# Hodograph
ax_hod = fignum.add_subplot(gs[:2,2:])
#gs.tight_layout(fig5)
if np.nanmax(speed_kts) > 18:
comprange = 35
else:
comprange = 20
h = Hodograph(ax_hod, component_range=comprange)
h.add_grid(increment=5)
h.plot_colormapped(u, v, pressure, cmap=cmocean.cm.deep_r)
ax_hod.set_title('Hodograph (kts)')
ax_hod.yaxis.set_ticklabels([])
#ax_hod.set_xlabel('Wind Speed (kts)')
# Map - Oklahoma
llcrnrlat = 33.6
urcrnrlat = 37.2
llcrnrlon = -103.2
urcrnrlon = -94.2
ax_map = fignum.add_subplot(gs[2, 2:])
m = Basemap(projection='merc', llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat,
llcrnrlon=llcrnrlon,urcrnrlon=urcrnrlon, lat_ts=20, resolution='l',
ax=ax_map)
print 'Basemap...'
m.drawcounties()
m.drawstates()
x,y = m(lon[0], lat[0])
plt.plot(x,y,'b.')
plt.text(x+40000, y-5000, sitelong,
bbox=dict(facecolor='yellow', alpha=0.5))
if moist:
# Convective parameter values
ax_data = fignum.add_subplot(gs[3, 2])
plt.axis('off')
datastr = 'LCL = %.0f hPa\nSBCAPE = %.0f J kg$^{-1}$\n0-%.0f m bulk shear\n\
= %.0f kts' % \
(plcl.magnitude, SBCAPE.magnitude, alt[-3], bulkshear)
boxprops = dict(boxstyle='round', facecolor='none')
ax_data.text(0.05, 0.95, datastr, transform=ax_data.transAxes,
fontsize=14, verticalalignment='top', bbox=boxprops)
# Logos
ax_png = fignum.add_subplot(gs[3, 3])
img = mpimg.imread(logoName)
plt.axis('off')
plt.imshow(img)
else:
# Logos
ax_png = fignum.add_subplot(gs[3, 2:])
img = mpimg.imread(logoName)
plt.axis('off')
plt.imshow(img)
plt.show(block=False)
return
# Initiate the skew-T plot type from MetPy class loaded earlier
skew = SkewT(fig, rotation=45)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
skew.plot_barbs(p[::3], u[::3], v[::3], y_clip_radius=0.03)
# Set some appropriate axes limits for x and y
skew.ax.set_xlim(-30, 40)
skew.ax.set_ylim(1020, 100)
# Add the relevant special lines to plot throughout the figure
skew.plot_dry_adiabats(t0=np.arange(233, 533, 10) * units.K,
alpha=0.25,
color='orangered')
skew.plot_moist_adiabats(t0=np.arange(233, 400, 5) * units.K,
alpha=0.25,
color='tab:green')
skew.plot_mixing_lines(p=np.arange(1000, 99, -20) * units.hPa,
linestyle='dotted',
color='tab:blue')
# Add some descriptive titles
plt.title('{} Sounding'.format(station), loc='left')
plt.title('Valid Time: {}'.format(dt), loc='right')
plt.show()
# Calculate LCL height and plot as black dot
#lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
#skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
skew.plot(p, prof, 'k', linewidth=2)
# Shade areas of CAPE and CIN
#skew.shade_cin(p, T, prof)
#skew.shade_cape(p, T, prof)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
for i in range(19):
for j in range(2, 9, 2):
skew.ax.axvline(i * 10 - 140 + j,
color='c',
linestyle='--',
linewidth=0.3)
#print (i*10-40+j)
# Add the relevant special lines
skew.plot_dry_adiabats(color='green')
skew.plot_moist_adiabats(color='brown')
skew.plot_mixing_lines(color='blue', linestyle='--', linewidth=0.3)
# Show the plot
plt.show()
skew.ax.set_ylabel('pressure ($hPa$)', linespacing=4, fontsize=24.)
skew.ax.set_title('Skew-T Log-P Diagram' + '\n' + '$_{station:}$ $_{' +
station + '}$'
' $_{local}$ $_{time:}$ $_{' + file[i][29:33] + '/' +
file[i][33:35] + '/' + file[i][35:37] + '}$' + ' $_{' +
file[i][37:39] + ':00}$',
verticalalignment='bottom',
fontsize=30.)
'''
# Plot LCL temperature as black dot
skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Plot the parcel profile as a black line
skew.plot(p, parcel_prof, 'k', linewidth=3)
# Shade areas of CAPE and CIN
skew.shade_cin(p, T, parcel_prof, Td)
skew.shade_cape(p, T, parcel_prof)
'''
# Plot a zero degree isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=3)
# Add the relevant special lines
skew.plot_dry_adiabats(linewidth=2.5)
skew.plot_moist_adiabats(linewidth=2.5)
skew.plot_mixing_lines(linewidth=2.5)
# Show the plot
plt.savefig(f'skewT_{file[i][29:39]}.png', dpi=300)
plt.show()
def main():
img_dir = Path("hail_plots/soundings/")
if not img_dir.exists():
img_dir.mkdir(parents=True)
data_dir = Path("/HOME/huziy/skynet3_rech1/hail/soundings_from_erai/")
# dates = [datetime(1991, 9, 7), datetime(1991, 9, 7, 6), datetime(1991, 9, 7, 12), datetime(1991, 9, 7, 18),
# datetime(1991, 9, 8, 0), datetime(1991, 9, 8, 18)]
#
# dates.extend([datetime(1991, 9, 6, 0), datetime(1991, 9, 6, 6), datetime(1991, 9, 6, 12), datetime(1991, 9, 6, 18)])
#
# dates = [datetime(1990, 7, 7), datetime(2010, 7, 12), datetime(1991, 9, 8, 0)]
dates_s = """
- 07/09/1991 12:00
- 07/09/1991 18:00
- 08/09/1991 00:00
- 08/09/1991 06:00
- 08/09/1991 12:00
- 13/09/1991 12:00
- 13/09/1991 18:00
- 14/09/1991 00:00
- 14/09/1991 06:00
- 14/09/1991 12:00
"""
dates = [datetime.strptime(line.strip()[1:].strip(), "%d/%m/%Y %H:%M") for line in dates_s.split("\n") if line.strip() != ""]
def __date_parser(s):
return pd.datetime.strptime(s, '%Y-%m-%d %H:%M:%S')
tt = pd.read_csv(data_dir.joinpath("TT.csv"), index_col=0, parse_dates=['Time'])
uu = pd.read_csv(data_dir.joinpath("UU.csv"), index_col=0, parse_dates=['Time'])
vv = pd.read_csv(data_dir.joinpath("VV.csv"), index_col=0, parse_dates=['Time'])
hu = pd.read_csv(data_dir.joinpath("HU.csv"), index_col=0, parse_dates=['Time'])
print(tt.head())
print([c for c in tt])
print(list(tt.columns.values))
temp_perturbation_degc = 0
for the_date in dates:
p = np.array([float(c) for c in tt])
fig = plt.figure(figsize=(9, 9))
skew = SkewT(fig)
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-40, 60)
tsel = tt.select(lambda d: d == the_date)
usel = uu.select(lambda d: d == the_date)
vsel = vv.select(lambda d: d == the_date)
husel = hu.select(lambda d: d == the_date)
tvals = tsel.values.mean(axis=0)
uvals = usel.values.mean(axis=0) * mul_mpers_per_knot
vvals = vsel.values.mean(axis=0) * mul_mpers_per_knot
huvals = husel.values.mean(axis=0) * units("g/kg")
# ignore the lowest level
all_vars = [p, tvals, uvals, vvals, huvals]
for i in range(len(all_vars)):
all_vars[i] = all_vars[i][:-5]
p, tvals, uvals, vvals, huvals = all_vars
assert len(p) == len(huvals)
tdvals = calc.dewpoint(calc.vapor_pressure(p * units.mbar, huvals).to(units.mbar))
print(tvals, tdvals)
# Calculate full parcel profile and add to plot as black line
parcel_profile = calc.parcel_profile(p[::-1] * units.mbar, (tvals[-1] + temp_perturbation_degc) * units.degC, tdvals[-1]).to('degC')
parcel_profile = parcel_profile[::-1]
skew.plot(p, parcel_profile, 'k', linewidth=2)
# Example of coloring area between profiles
greater = tvals * units.degC >= parcel_profile
skew.ax.fill_betweenx(p, tvals, parcel_profile, where=greater, facecolor='blue', alpha=0.4)
skew.ax.fill_betweenx(p, tvals, parcel_profile, where=~greater, facecolor='red', alpha=0.4)
skew.plot(p, tvals, "r")
skew.plot(p, tdvals, "g")
skew.plot_barbs(p, uvals, vvals)
# Plot a zero degree isotherm
l = skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
plt.title("{} (dT={})".format(the_date, temp_perturbation_degc))
img_path = "{}_dT={}.png".format(the_date.strftime("%Y%m%d_%H%M%S"), temp_perturbation_degc)
img_path = img_dir.joinpath(img_path)
fig.savefig(str(img_path), bbox_inches="tight")
plt.close(fig)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
skew.ax.axvline(0, color='orange', linestyle='-', linewidth=1, label='isothermal')
for i in range(23) :
for j in range(2,11,2) :
skew.ax.axvline(i*10-160+j, color='orange', linestyle='-', linewidth=0.3)
skew.ax.axvline(i*10-160, color='orange', linestyle='-', linewidth=1)
#print (i*10-40+j)
# Add the relevant special lines
skew.plot_dry_adiabats(t0=np.arange(-50, 160, 2) * units.degC, color='green', linestyle='-', linewidth=0.3)
skew.plot_dry_adiabats(t0=np.arange(-50, 160, 10) * units.degC, color='green', linestyle='-', linewidth=1.5, label='dry adiabat')
skew.plot_moist_adiabats(t0=np.arange(-50, 160, 2) * units.degC, color='brown', linestyle='-', linewidth=0.3)
skew.plot_moist_adiabats(t0=np.arange(-50, 160, 10) * units.degC, color='brown', linestyle='-', linewidth=1.5, label='saturation adiabat')
mixing_ratio_ticks = np.array([0.0001, 0.0005, 0.001, 0.015, 0.002, 0.003, 0.005, 0.007, 0.010, 0.015, 0.020, 0.030, 0.040, 0.050]).reshape(-1, 1)
skew.plot_mixing_lines(w=mixing_ratio_ticks, color='blue', linestyle='--', linewidth=1.0, label='mixing ratio')
#0.0001, 0.0005, 0.001, 0.015, 0.002, 0.003, 0.005, 0.007, 0.010, 0.015, 0.020, 0.030, 0.040, 0.050
plt.text(-55.5, 1071, 'saturation mixing ratio', horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(-41.5, 1071, '{0}'.format(mixing_ratio_ticks[0][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(-26, 1071, '{0}'.format(mixing_ratio_ticks[1][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(-17.5, 1071, '{0}'.format(mixing_ratio_ticks[2][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(-8.7, 1071, '{0}'.format(mixing_ratio_ticks[3][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(-3.2, 1071, '{0}'.format(mixing_ratio_ticks[4][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(3.5, 1071, '{0}'.format(mixing_ratio_ticks[5][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(8.5, 1071, '{0}'.format(mixing_ratio_ticks[6][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(13.5, 1071, '{0}'.format(mixing_ratio_ticks[7][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(20.2, 1071, '{0}'.format(mixing_ratio_ticks[8][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(24.7, 1071, '{0}'.format(mixing_ratio_ticks[9][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(32, 1071, '{0}'.format(mixing_ratio_ticks[10][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
plt.text(36.8, 1071, '{0}'.format(mixing_ratio_ticks[11][0]), horizontalalignment='left', verticalalignment='center', fontsize=9, color='blue')
u = dataset.variables['u_wind'][:]
v = dataset.variables['v_wind'][:]
###########################################
skew = SkewT()
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
skew.plot_barbs(p, u, v)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.ax.set_ylim(1000, 100)
###########################################
# Example of defining your own vertical barb spacing
skew = SkewT()
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
# Set spacing interval--Every 50 mb from 1000 to 100 mb
my_interval = np.arange(100, 1000, 50) * units('mbar')
def plot_upper_air(station='11035', date=False):
'''
-----------------------------
Default use of plot_upper_air:
This will plot a SkewT sounding for station '11035' (Wien Hohe Warte)
plot_upper_air(station='11035', date=False)
'''
# sns.set(rc={'axes.facecolor':'#343837', 'figure.facecolor':'#343837',
# 'grid.linestyle':'','axes.labelcolor':'#04d8b2','text.color':'#04d8b2',
# 'xtick.color':'#04d8b2','ytick.color':'#04d8b2'})
# Get time in UTC
station = str(station)
if date is False:
now = datetime.utcnow()
# If morning then 0z sounding, otherwise 12z
if now.hour < 12:
hour = 0
else:
hour = 12
date = datetime(now.year, now.month, now.day, hour)
datestr = date.strftime('%Hz %Y-%m-%d')
print('{}'.format(date))
else:
year = int(input('Please specify the year: '))
month = int(input('Please specify the month: '))
day = int(input('Please specify the day: '))
hour = int(input('Please specify the hour: '))
if hour < 12:
hour = 0
else:
hour = 12
date = datetime(year, month, day, hour)
datestr = date.strftime('%Hz %Y-%m-%d')
print('You entered {}'.format(date))
# This requests the data 11035 is
df = WyomingUpperAir.request_data(date, station)
# Create single variables wih the right units
p = df['pressure'].values * units.hPa
T = df['temperature'].values * units.degC
Td = df['dewpoint'].values * units.degC
wind_speed = df['speed'].values * units.knots
wind_dir = df['direction'].values * units.degrees
wind_speed_6k = df['speed'][df.height <= 6000].values * units.knots
wind_dir_6k = df['direction'][df.height <= 6000].values * units.degrees
u, v = mpcalc.get_wind_components(wind_speed, wind_dir)
u6, v6 = mpcalc.get_wind_components(wind_speed_6k, wind_dir_6k)
# Calculate the LCL
lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0])
print(lcl_pressure, lcl_temperature)
# Calculate the parcel profile.
parcel_prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC')
cape, cin = mpcalc.cape_cin(p, T, Td, parcel_prof)
#############################
# Create a new figure. The dimensions here give a good aspect ratio
fig = plt.figure(figsize=(9, 9))
gs = gridspec.GridSpec(3, 3)
skew = SkewT(fig, rotation=45, subplot=gs[:, :2])
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(p, T, 'r')
skew.plot(p, Td, 'g')
skew.plot_barbs(p, u, v)
skew.ax.set_ylim(1000, 100)
skew.ax.set_xlim(-45, 40)
# Plot LCL as black dot
skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black')
# Plot the parcel profile as a black line
skew.plot(p, parcel_prof, 'k', linewidth=2)
# Shade areas of CAPE and CIN
skew.shade_cin(p, T, parcel_prof)
skew.shade_cape(p, T, parcel_prof)
# Plot a zero degree isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
skew.ax.set_title('Station: ' + str(station) + '\n' + datestr) # set title
skew.ax.set_xlabel('Temperature (C)')
skew.ax.set_ylabel('Pressure (hPa)')
# Add the relevant special lines
skew.plot_dry_adiabats(linewidth=0.7)
skew.plot_moist_adiabats(linewidth=0.7)
skew.plot_mixing_lines(linewidth=0.7)
# Create a hodograph
# Create an inset axes object that is 40% width and height of the
# figure and put it in the upper right hand corner.
# ax_hod = inset_axes(skew.ax, '40%', '40%', loc=1)
ax = fig.add_subplot(gs[0, -1])
h = Hodograph(ax, component_range=60.)
h.add_grid(increment=20)
# Plot a line colored by windspeed
h.plot_colormapped(u6, v6, wind_speed_6k)
# add another subplot for the text of the indices
# ax_t = fig.add_subplot(gs[1:,2])
skew2 = SkewT(fig, rotation=0, subplot=gs[1:, 2])
skew2.plot(p, T, 'r')
skew2.plot(p, Td, 'g')
# skew2.plot_barbs(p, u, v)
skew2.ax.set_ylim(1000, 700)
skew2.ax.set_xlim(-30, 10)
# Show the plot
plt.show()
return cape
def plot_skewt(self):
"""
:param adjusted_data: receives the post processed dataframe
:param valid:
:return:
"""
for area in self.airports:
for airport in self.airports[area]:
lon = self.airports[area][airport]['lon']
lat = self.airports[area][airport]['lat']
pressure_levels = self.levels * units.hPa
tair = list(
self.create_profile_variable(self.tair, lat,
lon).values()) * units.degC
dewp = list(
self.create_profile_variable(self.dewp, lat,
lon).values()) * units.degC
u_wnd = list(self.create_profile_variable(self.u_wnd, lat, lon).values()) * \
units('meters / second').to('knots')
v_wnd = list(self.create_profile_variable(self.v_wnd, lat, lon).values()) * \
units('meters / second').to('knots')
# Create a new figure. The dimensions here give a good aspect ratio.
fig = plt.figure(figsize=(12, 9))
skew = SkewT(fig, rotation=45)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
skew.plot(pressure_levels, tair, 'r')
skew.plot(pressure_levels, dewp, 'g')
skew.plot_barbs(pressure_levels, u_wnd, v_wnd)
skew.ax.set_ylim(1020, 100)
skew.ax.set_xlim(-40, 60)
# Calculate LCL height and plot as black dot
lcl_pressure, lcl_temperature = mpcalc.lcl(
pressure_levels[0], tair[0], dewp[0])
skew.plot(lcl_pressure,
lcl_temperature,
'ko',
markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = mpcalc.parcel_profile(pressure_levels, tair[0], dewp[0])
skew.plot(pressure_levels, prof, 'k', linewidth=2)
# An example of a slanted line at constant T -- in this case the 0
# isotherm
skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)
# Add the relevant special lines
skew.plot_dry_adiabats()
skew.plot_moist_adiabats()
skew.plot_mixing_lines()
skew.shade_cape(pressure_levels, tair, prof)
skew.shade_cin(pressure_levels, tair, prof)
plt.title(
f'Perfil vertical (GFS) de {airport} valido para {self.time_stamp}',
fontsize=16,
ha='center')
sounding_output_path = f'{self.output_path}/{area}/{airport}'
Path(sounding_output_path).mkdir(parents=True, exist_ok=True)
plt.savefig(
f'{sounding_output_path}/sounding_{airport}_{self.time_step:02d}.jpg'
)
return skew
