def test_temp_at_mixrat():
input_w = 14
input_p = 950
correct_t = 18.25602418045935
returned_t = thermo.temp_at_mixrat(input_w, input_p)
npt.assert_almost_equal(returned_t, correct_t)
input_w = np.asanyarray([14, 12, 10, 8])
input_p = np.asanyarray([1013, 925, 850, 700])
correct_t = [19.28487241829498, 15.451394956732088,
11.399344140651465, 5.290414578916341]
correct_t = np.asanyarray(correct_t)
returned_t = thermo.temp_at_mixrat(input_w, input_p)
npt.assert_almost_equal(returned_t, correct_t)
def get_parcels(self):
'''
Function to generate various parcels and parcel
traces.
Returns nothing, but sets the following
variables:
self.mupcl : Most Unstable Parcel
self.sfcpcl : Surface Based Parcel
self.mlpcl : Mixed Layer Parcel
self.fcstpcl : Forecast Surface Parcel
self.ebottom : The bottom pressure level of
the effective inflow layer
self.etop : the top pressure level of
the effective inflow layer
self.ebotm : The bottom, meters (agl), of the
effective inflow layer
self.etopm : The top, meters (agl), of the
effective inflow layer
Parameters
----------
None
Returns
-------
None
'''
self.mupcl = params.parcelx( self, flag=3 )
if self.mupcl.lplvals.pres == self.pres[self.sfc]:
self.sfcpcl = self.mupcl
else:
self.sfcpcl = params.parcelx( self, flag=1 )
self.fcstpcl = params.parcelx( self, flag=2 )
self.mlpcl = params.parcelx( self, flag=4 )
self.usrpcl = params.Parcel()
## get the effective inflow layer data
self.ebottom, self.etop = params.effective_inflow_layer( self, mupcl=self.mupcl )
## if there was no effective inflow layer, set the values to masked
if self.etop is ma.masked or self.ebottom is ma.masked:
self.ebotm = ma.masked; self.etopm = ma.masked
self.effpcl = self.sfcpcl # Default to surface parcel, as in params.DefineProfile().
## otherwise, interpolate the heights given to above ground level
else:
self.ebotm = interp.to_agl(self, interp.hght(self, self.ebottom))
self.etopm = interp.to_agl(self, interp.hght(self, self.etop))
# The below code was adapted from params.DefineProfile()
# Lifting one additional parcel probably won't slow the program too much.
# It's just one more lift compared to all the lifts in the params.effective_inflow_layer() call.
mtha = params.mean_theta(self, self.ebottom, self.etop)
mmr = params.mean_mixratio(self, self.ebottom, self.etop)
effpres = (self.ebottom+self.etop)/2.
efftmpc = thermo.theta(1000., mtha, effpres)
effdwpc = thermo.temp_at_mixrat(mmr, effpres)
self.effpcl = params.parcelx(self, flag=5, pres=effpres, tmpc=efftmpc, dwpc=effdwpc) #This is the effective parcel.
def get_parcels(self):
'''
Function to generate various parcels and parcel
traces.
Returns nothing, but sets the following
variables:
self.mupcl : Most Unstable Parcel
self.sfcpcl : Surface Based Parcel
self.mlpcl : Mixed Layer Parcel
self.fcstpcl : Forecast Surface Parcel
self.ebottom : The bottom pressure level of
the effective inflow layer
self.etop : the top pressure level of
the effective inflow layer
self.ebotm : The bottom, meters (agl), of the
effective inflow layer
self.etopm : The top, meters (agl), of the
effective inflow layer
Parameters
----------
None
Returns
-------
None
'''
self.mupcl = params.parcelx( self, flag=3 )
if self.mupcl.lplvals.pres == self.pres[self.sfc]:
self.sfcpcl = self.mupcl
else:
self.sfcpcl = params.parcelx( self, flag=1 )
self.fcstpcl = params.parcelx( self, flag=2 )
self.mlpcl = params.parcelx( self, flag=4 )
self.usrpcl = params.Parcel()
## get the effective inflow layer data
self.ebottom, self.etop = params.effective_inflow_layer( self, mupcl=self.mupcl )
## if there was no effective inflow layer, set the values to masked
if self.etop is ma.masked or self.ebottom is ma.masked:
self.ebotm = ma.masked; self.etopm = ma.masked
self.effpcl = self.sfcpcl # Default to surface parcel, as in params.DefineProfile().
## otherwise, interpolate the heights given to above ground level
else:
self.ebotm = interp.to_agl(self, interp.hght(self, self.ebottom))
self.etopm = interp.to_agl(self, interp.hght(self, self.etop))
# The below code was adapted from params.DefineProfile()
# Lifting one additional parcel probably won't slow the program too much.
# It's just one more lift compared to all the lifts in the params.effective_inflow_layer() call.
mtha = params.mean_theta(self, self.ebottom, self.etop)
mmr = params.mean_mixratio(self, self.ebottom, self.etop)
effpres = (self.ebottom+self.etop)/2.
efftmpc = thermo.theta(1000., mtha, effpres)
effdwpc = thermo.temp_at_mixrat(mmr, effpres)
self.effpcl = params.parcelx(self, flag=5, pres=effpres, tmpc=efftmpc, dwpc=effdwpc) #This is the effective parcel.
def __fcst(self, prof, **kwargs):
''' Create a parcel using forecast conditions '''
self.desc = 'Forecast Surface Parcel'
self.temp = max_temp(prof, -1)
mmr = mean_mixratio(prof, -1, -1)
self.dwpt = thermo.temp_at_mixrat(mmr, prof.gSndg[prof.sfc][prof.pind])
self.pres = prof.gSndg[prof.sfc][prof.pind]
return
def __fcst(self, prof, **kwargs):
''' Create a parcel using forecast conditions '''
self.desc = 'Forecast Surface Parcel'
self.temp = max_temp(prof, -1)
mmr = mean_mixratio(prof, -1, -1)
self.dwpt = thermo.temp_at_mixrat(mmr, prof.gSndg[prof.sfc][prof.pind])
self.pres = prof.gSndg[prof.sfc][prof.pind]
return
def __ml(self, prof, **kwargs):
''' Create the mixed-layer parcel; mixing over defined pressure '''
self.desc = '%.2f hPa Mixed Layer Parcel' % self.presval
self.pres = prof.gSndg[prof.sfc][prof.pind]
diff = prof.gSndg[prof.sfc][prof.pind] - self.presval
mtha = mean_theta(prof, -1, diff)
mmr = mean_mixratio(prof, -1, diff)
self.temp = thermo.theta(1000., mtha, self.pres)
self.dwpt = thermo.temp_at_mixrat(mmr, self.pres)
return
def __ml(self, prof, **kwargs):
''' Create the mixed-layer parcel; mixing over defined pressure '''
self.desc = '%.2f hPa Mixed Layer Parcel' % self.presval
self.pres = prof.gSndg[prof.sfc][prof.pind]
diff = prof.gSndg[prof.sfc][prof.pind] - self.presval
mtha = mean_theta(prof, -1, diff)
mmr = mean_mixratio(prof, -1, diff)
self.temp = thermo.theta(1000., mtha, self.pres)
self.dwpt = thermo.temp_at_mixrat(mmr, self.pres)
return
def draw_mixing_ratio_lines(ax,
spacing=[6, 10, 14, 18, 22, 26, 30, 34],
color='g',
lw=.7):
# def draw_mixing_ratio_lines(ax, spacing=[2,4,10,12,14,16,18,20], color='g', lw=.7):
# plot the mixing ratio lines
for w in spacing:
line = thermo.temp_at_mixrat(w, np.arange(1000, 600, -1))
ax.semilogy(line, np.arange(1000, 600, -1), '--', color=color, lw=lw)
x = line[-1]
y = 600
ax.annotate(str(w),
xy=(x, y),
color='g',
size=7,
xytext=(-2, 2),
textcoords="offset points")
return ax
def make_plot(index):
#index = (r,c)
r,c = index
print(r,c)
xlat = xlats[r,c]
xlon = xlons[r,c]
mean_hgt = np.nanmean(z_agl[:,:,r,c], axis=0)
mean_t = np.nanmean(t[:,:,r,c], axis=0)
mean_q = np.nanmean(q[:,:,r,c], axis=0)
mean_p = np.nanmean(p[:,:,r,c], axis=0)
mean_td = thermo.temp_at_mixrat(mean_q*1000., mean_p)
mean_u = np.nanmean(u[:,:,r,c], axis=0)
mean_v = np.nanmean(v[:,:,r,c], axis=0)
mean_omega = np.nanmean(omega[:,:,r,c], axis=0)
print("start prof")
prof = profile.create_profile(profile='convective', pres=mean_p, hght=mean_hgt, tmpc=mean_t, \
dwpc=mean_td, u=mean_u, v=mean_v, omeg=mean_omega, missing=-9999, strictQC=False, latitude=xlat,date=vdateobj)
print("end prof")
member_profs = np.empty(len(z_agl[:,1]), dtype=object)
print("start member profs")
# Loop over all of the members and create profile objects for each of them.
for m in range(len(z_agl[:,1,r,c])):
member_profs[m] = profile.create_profile(profile='convective', pres=p[m,:,r,c], hght=z_agl[m,:,r,c], tmpc=t[m,:,r,c], \
dwpc=td[m,:,r,c], u=u[m,:,r,c], v=v[m,:,r,c], missing=-9999, strictQC=False, latitude=xlat,date=vdateobj)
members = {'hght': z_agl[:,:,r,c], 'pres': p[:,:,r,c], 'tmpc': t[:,:,r,c], 'dwpc': td[:,:,r,c], 'u': u[:,:,r,c], 'v': v[:,:,r,c], 'member_profs': member_profs}
print("end member profs")
#find summary file lat/lons
wherelatlon = np.where((sumlats == xlat)&(sumlons == xlon))
latwhere = wherelatlon[0][0]
lonwhere = wherelatlon[1][0]
cape_ml = cape_ml_0[:,latwhere-3:latwhere+4,lonwhere-3:lonwhere+4]
srh_0to1 = srh_0to1_0[:,latwhere-3:latwhere+4,lonwhere-3:lonwhere+4]
figname = os.path.join(outdir,'wofs_snd_{:02d}_{:02d}_f{:03d}.png'.format(r+1,c+1,leadminute))
# pass the data to the plotting script.
print('rounded lat/lon',round(xlat,2), round(xlon,2))
plot_wof(prof, members, figname, str(round(xlat,2)), str(round(xlon,2)), idateobj, vdateobj, x_pts=cape_ml, y_pts=srh_0to1)
def __effective(self, prof):
''' Create the mean-effective layer parcel '''
pbot, ptop = effective_inflow_layer(100, -250, prof)
if pbot > 0:
self.desc = '%.2f hPa Mean Effective Layer Centered at %.2f' % (
pbot-ptop, (pbot+ptop)/2.)
mtha = mean_theta(prof, pbot, ptop)
mmr = mean_mixratio(prof, pbot, ptop)
self.pres = (ptop + pbot) / 2.
self.temp = thermo.theta(1000., mtha, self.pres)
self.dwpt = thermo.temp_at_mixrat(mmr, self.pres)
else:
self.desc = 'Defaulting to Surface Layer'
self.pres = prof.gSndg[prof.sfc][prof.pind]
self.temp = prof.gSndg[prof.sfc][prof.tind]
self.dwpt = prof.gSndg[prof.sfc][prof.tdind]
if QC(pbot): self.pbot = pbot
else: self.pbot = RMISSD
if QC(ptop): self.ptop = ptop
else: self.ptop = RMISSD
return
def __effective(self, prof):
''' Create the mean-effective layer parcel '''
pbot, ptop = effective_inflow_layer(100, -250, prof)
if pbot > 0:
self.desc = '%.2f hPa Mean Effective Layer Centered at %.2f' % (
pbot - ptop, (pbot + ptop) / 2.)
mtha = mean_theta(prof, pbot, ptop)
mmr = mean_mixratio(prof, pbot, ptop)
self.pres = (ptop + pbot) / 2.
self.temp = thermo.theta(1000., mtha, self.pres)
self.dwpt = thermo.temp_at_mixrat(mmr, self.pres)
else:
self.desc = 'Defaulting to Surface Layer'
self.pres = prof.gSndg[prof.sfc][prof.pind]
self.temp = prof.gSndg[prof.sfc][prof.tind]
self.dwpt = prof.gSndg[prof.sfc][prof.tdind]
if QC(pbot): self.pbot = pbot
else: self.pbot = RMISSD
if QC(ptop): self.ptop = ptop
else: self.ptop = RMISSD
return
def convective_temp(prof, mincinh=-1.):
'''
Computes the convective temperature, assuming no change in the moisture
profile. Parcels are iteratively lifted until only mincinh is left as a
cap. The first guess is the observed surface temperature.
Inputs
------
prof (profile object) Profile Object
mincinh (float) Amount of CINH left at CI
Returns
-------
Convective Temperature (float [C])
'''
mmr = mean_mixratio(prof, -1, -1)
sfcpres = prof.gSndg[prof.sfc][prof.pind]
sfctemp = prof.gSndg[prof.sfc][prof.tind]
sfcdwpt = thermo.temp_at_mixrat(mmr, sfcpres)
# Do a quick search to find wheather to continue. If
# If you need to heat up more than 25C, don't compute.
pcl = parcelx(-1, -1, sfcpres, sfctemp+25., sfcdwpt, prof)
if pcl.bplus == 0. or pcl.bminus < mincinh: return RMISSD
excess = sfcdwpt - sfctemp
if excess > 0: sfctemp = sfctemp + excess + 4.
pcl = parcelx(-1, -1, sfcpres, sfctemp, sfcdwpt, prof)
if pcl.bplus == 0.: pcl.bminus = RMISSD
while pcl.bminus < mincinh:
if pcl.bminus < -100.: sfctemp += 2.
else: sfctemp += 0.5
pcl = parcelx(-1, -1, sfcpres, sfctemp, sfcdwpt, prof)
if pcl.bplus == 0.: pcl.bminus = RMISSD
return sfctemp
def convective_temp(prof, mincinh=-1.):
'''
Computes the convective temperature, assuming no change in the moisture
profile. Parcels are iteratively lifted until only mincinh is left as a
cap. The first guess is the observed surface temperature.
Inputs
------
prof (profile object) Profile Object
mincinh (float) Amount of CINH left at CI
Returns
-------
Convective Temperature (float [C])
'''
mmr = mean_mixratio(prof, -1, -1)
sfcpres = prof.gSndg[prof.sfc][prof.pind]
sfctemp = prof.gSndg[prof.sfc][prof.tind]
sfcdwpt = thermo.temp_at_mixrat(mmr, sfcpres)
# Do a quick search to find wheather to continue. If
# If you need to heat up more than 25C, don't compute.
pcl = parcelx(-1, -1, sfcpres, sfctemp + 25., sfcdwpt, prof)
if pcl.bplus == 0. or pcl.bminus < mincinh: return RMISSD
excess = sfcdwpt - sfctemp
if excess > 0: sfctemp = sfctemp + excess + 4.
pcl = parcelx(-1, -1, sfcpres, sfctemp, sfcdwpt, prof)
if pcl.bplus == 0.: pcl.bminus = RMISSD
while pcl.bminus < mincinh:
if pcl.bminus < -100.: sfctemp += 2.
else: sfctemp += 0.5
pcl = parcelx(-1, -1, sfcpres, sfctemp, sfcdwpt, prof)
if pcl.bplus == 0.: pcl.bminus = RMISSD
return sfctemp
def draw_background(ax,
dry=np.arange(-50, 110, 20),
moist=np.arange(-5, 40, 5),
presvals=np.arange(1050, 0, -10),
mix=[1, 2, 4, 8, 12, 16, 20, 24]):
# Plot dry adiabats
for t in dry:
ax.semilogy(thetas(t, presvals),
presvals,
'r-',
alpha=0.2,
linewidth=1)
# Plot moist adiabats to topp
topp = 200
moist_presvals = np.arange(np.max(presvals), topp, -10)
for t in moist:
tw = []
for p in moist_presvals:
tw.append(thermo.wetlift(1000., t, p))
ax.semilogy(tw,
moist_presvals,
'k-',
alpha=0.2,
linewidth=0.5,
linestyle='dashed')
# add moist adiabat text labels
ax.text(thermo.wetlift(1000., t, topp + 15),
topp + 15,
t,
va='center',
ha='center',
size=5.6,
alpha=0.3,
clip_on=True)
# Mixing ratio lines and labels to topp
topp = 650
for w in mix:
ww = []
for p in presvals:
ww.append(thermo.temp_at_mixrat(w, p))
ax.semilogy(ww,
presvals,
'g',
alpha=0.35,
linewidth=1,
linestyle="dotted")
ax.text(thermo.temp_at_mixrat(w, topp),
topp,
w,
va='bottom',
ha='center',
size=6.7,
color='g',
alpha=0.35)
# Disables the log-formatting (10 to the power of x) that comes with semilogy
ax.yaxis.set_major_formatter(plt.ScalarFormatter())
ax.set_yticks(np.linspace(100, 1000, 10))
ax.set_ylim(1050, 100)
plt.ylabel('Pressure (hPa)')
# The first time this axis object is returned, no xtick gridlines show up for -110 to -60C
ax.xaxis.set_major_locator(plt.MultipleLocator(10))
ax.set_xlim(-50, 45)
plt.xlabel('Temperature (C)')
ax.grid(True, linestyle='solid', alpha=0.5)
seconds=diffseconds)
print('start/valid', idateobj, vdateobj)
leadminute = int(diffseconds / 60)
# if (leadminute > 400): #account for day change
# leadminute = leadminute - 1440
print('lead minute', leadminute)
xlats = fin.variables["xlat"][:, :]
xlons = fin.variables["xlon"][:, :]
u = fin.variables["u"][:, :, :, :] * 1.94384
v = fin.variables["v"][:, :, :, :] * 1.94384
p = fin.variables["p"][:, :, :, :]
t = fin.variables["t"][:, :, :, :]
q = fin.variables["q"][:, :, :, :]
z_agl = fin.variables["z_agl"][:, :, :, :]
omega = fin.variables["omega"][:, :, :, :]
td = thermo.temp_at_mixrat(q * 1000., p)
nc = Dataset(summary_file, 'r')
sumlats = nc.variables['xlat'][:, :]
sumlons = nc.variables['xlon'][:, :]
cape_ml_0 = nc.variables['cape_ml'][:, :, :]
srh_0to1_0 = nc.variables['srh_0to1'][:, :, :]
nc.close()
del nc
pool = multiprocessing.Pool(processes=24)
indices = []
for index, x in np.ndenumerate(
xlats[12:16, :]): #[0:1,0:1]):
new_index = (index[0] + 12, index[1])
def parcelx(lower, upper, pres, temp, dwpt, prof, **kwargs):
'''
Lifts the specified parcel, calculated various levels and parameters from
the profile object. B+/B- are calculated based on the specified layer.
!! All calculations use the virtual temperature correction unless noted. !!
Inputs
------
lower (float) Lower-bound lifting level (hPa)
upper (float) Upper-bound lifting level
pres (float) Pressure of parcel to lift (hPa)
temp (float) Temperature of parcel to lift (C)
dwpt (float) Dew Point of parcel to lift (C)
prof (profile object) Profile Object
Returns
-------
pcl (parcel object) Parcel Object
'''
pcl = Parcel(-1, -1, pres, temp, dwpt)
if 'lplvals' in kwargs: pcl.lplvals = kwargs.get('lplvals')
else:
lplvals = DefineParcel(prof, 5, pres=pres, temp=temp, dwpt=dwpt)
pcl.lplvals = lplvals
if prof.gNumLevels < 1: return pcl
lyre = -1
cap_strength = RMISSD
cap_strengthpres = RMISSD
li_max = RMISSD
li_maxpres = RMISSD
totp = 0.
totn = 0.
tote = 0.
cinh_old = 0.
# See if default layer is specified
if lower == -1:
lower = prof.gSndg[prof.sfc][prof.pind]
pcl.blayer = lower
if upper == -1:
upper = prof.gSndg[prof.gNumLevels-1][prof.pind]
pcl.tlayer = upper
# Make sure that this is a valid layer
if lower > pres:
lower = pres
pcl.blayer = lower
if not QC(interp.vtmp(lower, prof)) or \
not QC(interp.vtmp(upper, prof)):
return RMISSD
# Begin with the Mixing Layer
te1 = interp.vtmp(pres, prof)
pe1 = lower
h1 = interp.hght(pe1, prof)
tp1 = thermo.virtemp(pres, temp, dwpt)
# te1 = tp1
# Lift parcel and return LCL pres (hPa) and LCL temp (c)
pe2, tp2 = thermo.drylift(pres, temp, dwpt)
blupper = pe2 # Define top of layer as LCL pres
h2 = interp.hght(pe2, prof)
te2 = interp.vtmp(pe2, prof)
pcl.lclpres = pe2
pcl.lclhght = interp.agl(h2, prof)
# Calculate lifted parcel theta for use in iterative CINH loop below
# RECALL: lifted parcel theta is CONSTANT from LPL to LCL
theta_parcel = thermo.theta(pe2, tp2, 1000.)
# Environmental theta and mixing ratio at LPL
bltheta = thermo.theta(pres, interp.temp(pres, prof), 1000.)
blmr = thermo.mixratio(pres, dwpt)
# ACCUMULATED CINH IN MIXING LAYER BELOW THE LCL
# This will be done in 10mb increments, and will use the virtual
# temperature correction where possible
pinc = -10
a = int(lower)
b = int(blupper)
for pp in range(a, b, int(pinc)):
pp1 = pp
pp2 = pp + pinc
if pp2 < blupper: pp2 = blupper
dz = interp.hght(pp2, prof) - interp.hght(pp1, prof)
# Calculate difference between Tv_parcel and Tv_environment at top
# and bottom of 10mb layers. Make use of constant lifted parcel
# theta and mixing ratio from LPL to LCL
tv_env_bot = thermo.virtemp(pp1, thermo.theta(pp1,
interp.temp(pp1, prof), 1000.), interp.dwpt(pp1, prof))
tdef1 = (thermo.virtemp(pp1, theta_parcel,
thermo.temp_at_mixrat(blmr, pp1)) - tv_env_bot) / \
(thermo.ctok(tv_env_bot))
tv_env_top = thermo.virtemp(pp2, thermo.theta(pp2,
interp.temp(pp2, prof), 1000.), interp.dwpt(pp2, prof))
tdef2 = (thermo.virtemp(pp2, theta_parcel,
thermo.temp_at_mixrat(blmr, pp2)) - tv_env_top) / \
(thermo.ctok(tv_env_bot))
lyre = G * (tdef1 + tdef2) / 2. * dz
if lyre < 0: totn += lyre
# Move the bottom layer to the top of the boundary layer
if lower > pe2:
lower = pe2
pcl.blayer = lower
# Calculate height of various temperature levels
p0c = temp_lvl(0., prof)
pm10c = temp_lvl(-10., prof)
pm20c = temp_lvl(-20., prof)
pm30c = temp_lvl(-30., prof)
hgt0c = interp.hght(p0c, prof)
hgtm10c = interp.hght(pm10c, prof)
hgtm20c = interp.hght(pm20c, prof)
hgtm30c = interp.hght(pm30c, prof)
pcl.p0c = p0c
pcl.pm10c = pm10c
pcl.pm20c = pm20c
pcl.pm30c = pm30c
pcl.hght0c = hgt0c
pcl.hghtm10c = hgtm10c
pcl.hghtm20c = hgtm20c
pcl.hghtm30c = hgtm30c
# Find lowest observation in layer
i = 0
while prof.gSndg[i][prof.pind] > lower:
if i == prof.gNumLevels-1: break
i += 1
while not QC(prof.gSndg[i][prof.tdind]):
if i == prof.gNumLevels-1: break
i += 1
lptr = i
if prof.gSndg[i][prof.pind] == lower:
if i != prof.gNumLevels-1: lptr += 1
# Find highest observation in layer
i = prof.gNumLevels-1
while prof.gSndg[i][prof.pind] < upper:
if i < lptr: break
i -= 1
uptr = i
if prof.gSndg[i][prof.pind] == upper:
if i > lptr: uptr -= 1
# START WITH INTERPOLATED BOTTOM LAYER
# Begin moist ascent from lifted parcel LCL (pe2, tp2)
pe1 = lower
h1 = interp.hght(pe1, prof)
te1 = interp.vtmp(pe1, prof)
tp1 = thermo.wetlift(pe2, tp2, pe1)
lyre = 0
lyrlast = 0
for i in range(lptr, prof.gNumLevels):
if not QC(prof.gSndg[i][prof.tind]): continue
pe2 = prof.gSndg[i][prof.pind]
h2 = prof.gSndg[i][prof.zind]
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe1, tp1, pe2)
tdef1 = (thermo.virtemp(pe1, tp1, tp1) - te1) / thermo.ctok(te1)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / thermo.ctok(te2)
lyrlast = lyre
lyre = G * (tdef1 + tdef2) / 2. * (h2 - h1)
# Add layer energy to total positive if lyre > 0
if lyre > 0: totp += lyre
# Add layer energy to total negative if lyre < 0, only up to EL
else:
if pe2 > 500.: totn += lyre
# Check for Max LI
mli = thermo.virtemp(pe2, tp2, tp2) - te2
if mli > li_max:
li_max = mli
li_maxpres = pe2
# Check for Max Cap Strength
mcap = te2 - mli
if mcap > cap_strength:
cap_strength = mcap
cap_strengthpres = pe2
tote += lyre
pelast = pe1
pe1 = pe2
h1 = h2
te1 = te2
tp1 = tp2
# Is this the top of the specified layer
if i >= uptr and not QC(pcl.bplus):
pe3 = pe1
h3 = h1
te3 = te1
tp3 = tp1
lyrf = lyre
if lyrf > 0:
pcl.bplus = totp - lyrf
pcl.bminus = totn
else:
pcl.bplus = totp
if pe2 > 500.: pcl.bminus = totn + lyrf
else: pcl.bminus = totn
pe2 = upper
h2 = interp.hght(pe2, prof)
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
if lyrf > 0: pcl.bplus += lyrf
else:
if pe2 > 500.: pcl.bminus += lyrf
if pcl.bplus == 0: pcl.bminus = 0.
# Is this the freezing level
if te2 < 0. and not QC(pcl.bfzl):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.bfzl = totp - lyrf
else: pcl.bfzl = totp
if not QC(p0c) or p0c > pe3:
pcl.bfzl = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgt0c - h3)
if lyrf > 0: pcl.bfzl += lyrf
# Is this the -10C level
if te2 < -10. and not QC(pcl.wm10c):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.wm10c = totp - lyrf
else: pcl.wm10c = totp
if not QC(pm10c) or pm10c > pcl.lclpres:
pcl.wm10c = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgtm10c - h3)
if lyrf > 0: pcl.wm10c += lyrf
# Is this the -20C level
if te2 < -20. and not QC(pcl.wm20c):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.wm20c = totp - lyrf
else: pcl.wm20c = totp
if not QC(pm20c) or pm20c > pcl.lclpres:
pcl.wm20c = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgtm20c - h3)
if lyrf > 0: pcl.wm20c += lyrf
# Is this the -30C level
if te2 < -30. and not QC(pcl.wm30c):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.wm30c = totp - lyrf
else: pcl.wm30c = totp
if not QC(pm30c) or pm30c > pcl.lclpres:
pcl.wm30c = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgtm30c - h3)
if lyrf > 0: pcl.wm30c += lyrf
# Is this the 3km level
if pcl.lclhght < 3000.:
h = interp.agl(interp.hght(pe2, prof), prof)
if h >= 3000. and not QC(pcl.b3km):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0: pcl.b3km = totp - lyrf
else: pcl.b3km = totp
h2 = interp.msl(3000., prof)
pe2 = interp.pres(h2, prof)
if QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
if lyrf > 0: pcl.b3km += lyrf
else: pcl.b3km = 0.
# Is this the 6km level
if pcl.lclhght < 6000.:
h = interp.agl(interp.hght(pe2, prof), prof)
if h >= 6000. and not QC(pcl.b6km):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0: pcl.b6km = totp - lyrf
else: pcl.b6km = totp
h2 = interp.msl(6000., prof)
pe2 = interp.pres(h2, prof)
if QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
if lyrf > 0: pcl.b6km += lyrf
else: pcl.b6km = 0.
# LFC Possibility
if lyre >= 0. and lyrlast <= 0.:
tp3 = tp1
te3 = te1
pe2 = pe1
pe3 = pelast
while interp.vtmp(pe3, prof) > thermo.virtemp(pe3,
thermo.wetlift(pe2, tp3, pe3), thermo.wetlift(pe2, tp3, pe3)):
pe3 -= 5
pcl.lfcpres = pe3
pcl.lfchght = interp.agl(interp.hght(pe3, prof), prof)
cinh_old = totn
tote = 0.
pcl.elpres = RMISSD
li_max = RMISSD
if cap_strength < 0.: cap_strength = 0.
pcl.cap = cap_strength
pcl.cappres = cap_strengthpres
# Hack to force LFC to be at least at the LCL
if pcl.lfcpres > pcl.lclpres:
pcl.lfcpres = pcl.lclpres
pcl.lfchght = pcl.lclhght
# EL Possibility
if lyre <= 0. and lyrlast >= 0.:
tp3 = tp1
te3 = te1
pe2 = pe1
pe3 = pelast
while interp.vtmp(pe3, prof) < thermo.virtemp(pe3,
thermo.wetlift(pe2, tp3, pe3), thermo.wetlift(pe2, tp3, pe3)):
pe3 -= 5
pcl.elpres = pe3
pcl.elhght = interp.agl(interp.hght(pe3, prof), prof)
pcl.mplpres = RMISSD
pcl.limax = -li_max
pcl.limaxpress = li_maxpres
# MPL Possibility
if tote < 0. and not QC(pcl.mplpres) and QC(pcl.elpres):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
totx = tote - lyre
pe2 = pelast
while totx > 0:
pe2 -= 1
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
h2 = interp.hght(pe2, prof)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
totx += lyrf
tp3 = tp2
te3 = te2
pe3 = pe2
pcl.mplpres = pe2
pcl.mplhght = interp.agl(interp.hght(pe2, prof), prof)
# 500 hPa Lifted Index
if prof.gSndg[i][prof.pind] <= 500. and pcl.li5 == RMISSD:
a = interp.vtmp(500., prof)
b = thermo.wetlift(pe1, tp1, 500.)
pcl.li5 = a - thermo.virtemp(500, b, b)
# 300 hPa Lifted Index
if prof.gSndg[i][prof.pind] <= 300. and pcl.li3 == RMISSD:
a = interp.vtmp(300., prof)
b = thermo.wetlift(pe1, tp1, 300.)
pcl.li3 = a - thermo.virtemp(300, b, b)
# Calculate BRN if available
pcl = bulk_rich(pcl, prof)
pcl.bminus = cinh_old
if pcl.bplus == 0: pcl.bminus = 0.
return pcl
def plot_wof(prof, members, figname, xlat, xlon, idateobj, vdateobj, **kwargs):
# '''
# Plots SHARPpy SPC window as .png
#
# Parameters
# ----------
# prof : a Profile Object from sharppy.sharptab.profile
#
# kwargs
# ------
# parcel_type: Parcel choice for plotting. 'sfc','ml','mu','fcst' Default is 'ml'
# filename: Filename as a string. Default is 'sounding.png'
# logo: Logo for upper-left portion of the skew-t. Default is 'None' and does not plot a logo.
# logo_dxdy: Size of logo. Actual dimensions are dT and dp as it is plotted on the skewT. Default is (20,13) This worked for a 489x132 pixel image.
# '''
#kwargs
parcel_type = kwargs.get('parcel_type', 'ml')
xpts = kwargs.get('x_pts')
ypts = kwargs.get('y_pts')
#Figure User Input
p_grid_labels = [
'1000', '', '', '850', '', '', '700', '', '', '', '500', '', '', '',
'300', '', '200', '', '100'
] #labels for the pressure ticks. Standard.
p_grid = [1000, 850, 700, 500, 300, 200,
100] #where horizontal lines go across the skew-T
my_dpi = 55 #dots per inch for the plot. This is a pretty hi-res image.
pmax = 1050 #lowest pressure on the skew-T
pmin = 100 #highest pressure on the skew-T
dp = -10 #pressure spacing for creating skew-T background lines
presvals = np.arange(
int(pmax),
int(pmin) + dp,
dp) #pressure values used for creating skew-T background lines
# Colors for wind speed bars and hodograph
hgt_list_bar = [0, 1000, 3000, 6000, 9000, 20000]
hgt_list_hodo = [0, 1000, 3000, 6000, 9000, 10000]
hodo_color = [
cb_colors.orange6, cb_colors.green6, cb_colors.blue6,
cb_colors.purple6, cb_colors.red6
]
hodo_label = ['0-1km', '1-3km', '3-6km', '6-9km', '9-10km']
#convoluted mess to get the title to be aligned how I wanted. This should be changed for others...
spaces = 10 #22
# title_text_1 = '' #site + ' ' + dt.strftime('%Y/%m/%d %H:%M UTC ' + data_type)
# title_text_3 = 'Sounding Powered by SHARPpy'
sharptext = 'Sounding Powered by SHARPpy'
# title_text_2 = title_text_3 = ''
title_text_3 = 'WoFS Sounding {}N, {}W'.format(
xlat, xlon) + (' ' * spaces) + 'Init: {} Valid: {}'.format(
idateobj.strftime('%Y-%m-%d %H%M UTC'),
vdateobj.strftime('%Y-%m-%d %H%M UTC'))
#xlat, xlon, initdate, validdate
title_text = title_text_3 #title_text_1 + (' '*spaces) +title_text_2 + (' '*spaces) + title_text_3
#Figures out where at which height the sounding reached in the list of h_new
#Then interpolates pressure to height levels
h_new = [0, 1000, 3000, 6000, 9000, 12000, 15000]
for i in range(len(h_new)):
if np.max(prof.hght) > h_new[i]:
index = i
h_new_labels = ['0 km', '1 km', '3 km', '6 km', '9 km', '12 km', '15 km']
h_new_labels = h_new_labels[0:index + 1]
#p_interped_func = interpolate.interp1d(prof.hght, prof.pres)
p_interped = sharptab.interp.pres(
prof, sharptab.interp.to_msl(prof, h_new[0:index + 1]))
#Thin out the winds for better plotting (significant level data points seem to bunch together to closely
minimum_separation = 250. #minimum spacing between wind barbs (meters)
h_barb = np.array(prof.hght).tolist()
p_barb = np.array(prof.pres).tolist()
spd_barb = np.array(prof.wspd).tolist()
direc_barb = np.array(prof.wdir).tolist()
#adds units to our newly created pressure, speed, and direction arrays for wind barb plotting
#p_barb = p_barb * units.mbar
#spd_barb = spd_barb * units.knot
#direc_barb = direc_barb * units.deg
# Convert wind speed and direction to components
#u, v = get_wind_components(prof.wspd * units.knot, prof.wdir * units.deg)
u, v = utils.vec2comp(prof.wdir, prof.wspd)
u_barb, v_barb = utils.vec2comp(prof.wdir, prof.wspd)
#SELECT PARCEL AND GET PARCEL DATA FROM SPC_UTILS
sfcpcl = prof.sfcpcl #params.parcelx( prof, flag=1 )
fcstpcl = prof.fcstpcl #params.parcelx( prof, flag=2)
mupcl = prof.mupcl #params.parcelx( prof, flag=3 )
mlpcl = prof.mlpcl #params.parcelx( prof, flag=4 )
if parcel_type == 'sfc':
pcl = sfcpcl
pcl_box_level = -0.065
pcl_type = 1
elif parcel_type == 'fcst':
pcl = fcstpcl
pcl_box_level = -0.0875
pcl_type = 2
elif parcel_type == 'mu':
pcl = mupcl
pcl_box_level = -0.1325
pcl_type = 4
elif parcel_type == 'ml':
pcl = mlpcl
pcl_box_level = -0.11
pcl_type = 3
else:
print(
"ERROR! Select 'sfc', 'fcst', 'mu', or 'ml' for parcel type. (plot_spc(prof,parcel_type)"
)
print("Defaulting to surface parcel...")
pcl = sfcpcl
pcl_box_level = -0.065
#PLOTTING *************************************************************************************************************
#Create full figure
fig = plt.figure(figsize=(1180 / my_dpi, 800 / my_dpi),
dpi=my_dpi,
frameon=False)
#SKEW T ***************************************************
ax = fig.add_subplot(111, projection='skewx',
facecolor="w") #skewed x-axis
# plot dashed temperature lines
ax.xaxis.grid(color='k',
linestyle='--',
dashes=(3, 3),
alpha=0.5,
zorder=0)
# plot the moist-adiabats
for temp in np.arange(-10, 45, 5):
tw = []
for pres in presvals:
tw.append(thermo.wetlift(1050., temp, pres))
ax.semilogy(tw,
presvals,
color=cb_colors.purple6,
linestyle='--',
dashes=(5, 2),
alpha=.3) #cb_colors.purple6
# plot the dry adiabats
for t in np.arange(-50, 80, 20):
thetas = ((t + thermo.ZEROCNK) / (np.power(
(1000. / presvals), thermo.ROCP))) - thermo.ZEROCNK
ax.semilogy(thetas, presvals, 'k', alpha=.3)
#plot mixing ratio lines
mixing_ratio_list = range(6, 36, 4)
for mr in mixing_ratio_list:
plt.plot((thermo.temp_at_mixrat(mr, 1050) - 273,
thermo.temp_at_mixrat(mr, 600) - 273), (1050, 600),
'g-',
lw=1.0,
zorder=3,
alpha=0.6)
ax.annotate(str(mr),
xy=((thermo.temp_at_mixrat(mr, 600) - 273), (600 - 3)),
xytext=((thermo.temp_at_mixrat(mr, 600) - 273), (600 - 3)),
ha='center',
color='g',
family='sans-serif',
weight='bold',
zorder=3,
fontsize=10,
alpha=0.6)
#plot horizontal lines at standard pressure levels
for p_loc in p_grid:
ax.axhline(y=p_loc, ls='-', c='k', alpha=0.5, linewidth=1.5, zorder=3)
# PLOT THE DATA ON THE SKEW-T
# Plot the data using normal plotting functions, in this case using log scaling in Y, as dicatated by the typical meteorological plot
ax.semilogy(prof.wetbulb,
prof.pres,
c="c",
linestyle='-',
lw=1,
alpha=1.0,
zorder=3) # Plot the wetbulb profile
ax.annotate(str(int(round(thermo.ctof(prof.wetbulb[prof.sfc])))),
xy=(prof.wetbulb[prof.sfc], prof.pres[prof.sfc] + 30),
xytext=(prof.wetbulb[prof.sfc], prof.pres[prof.sfc] + 30),
ha='left',
color="c",
family='sans-serif',
weight='normal',
zorder=7,
fontsize=12,
alpha=1.0) # annotate the sfc wetbulb in F
ax.semilogy(prof.dwpc,
prof.pres,
c=cb_colors.blue6,
linestyle='-',
lw=3,
zorder=3) # plot the dewpoint profile
ax.annotate(str(int(round(thermo.ctof(prof.dwpc[prof.sfc])))),
xy=(prof.dwpc[prof.sfc], prof.pres[prof.sfc] + 30),
xytext=(prof.dwpc[prof.sfc], prof.pres[prof.sfc] + 30),
ha='left',
color=cb_colors.blue6,
family='sans-serif',
weight='bold',
zorder=7,
fontsize=12,
alpha=1.0) # annotate the sfc dewpoint in F
ax.semilogy(prof.tmpc,
prof.pres,
c=cb_colors.orange6,
linestyle='-',
lw=3,
zorder=3) # Plot the temperature profile
ax.semilogy(prof.vtmp,
prof.pres,
c=cb_colors.orange6,
linestyle='--',
lw=3,
zorder=3) # Plot the temperature profile
ax.annotate(str(int(round(thermo.ctof(prof.tmpc[prof.sfc])))),
xy=(prof.tmpc[prof.sfc], prof.pres[prof.sfc] + 30),
xytext=(prof.tmpc[prof.sfc], prof.pres[prof.sfc] + 30),
ha='left',
color=cb_colors.orange6,
family='sans-serif',
weight='bold',
zorder=7,
fontsize=12,
alpha=1.0) # annotate the sfc temp in F
ax.semilogy(pcl.ttrace,
pcl.ptrace,
c=cb_colors.gray6,
linestyle='--',
dashes=(3, 3),
lw=1.5,
alpha=1.0,
zorder=3) # plot the parcel trace
#member_cape = []
if members is not None:
# print( "Plotting members...")
for m_idx in range(len(members['tmpc'])):
ax.semilogy(members['dwpc'][m_idx],
members['pres'][m_idx],
c=cb_colors.blue6,
linestyle='-',
lw=1.,
zorder=1,
alpha=.6) # plot the dewpoint profile
ax.semilogy(members['tmpc'][m_idx],
members['pres'][m_idx],
c=cb_colors.orange6,
linestyle='-',
lw=1.,
zorder=1,
alpha=.6) # Plot the temperature profile
# set label and tick marks for pressure and temperature
ax.xaxis.set_major_locator(plt.MultipleLocator(10))
ax.set_xticks(np.arange(-100, 60, 10))
ax.set_xticklabels([str(i) for i in np.arange(-100, 60, 10)],
color=cb_colors.gray7,
fontsize=12)
ax.set_xlim(-50, 50)
ax.yaxis.set_major_formatter(plt.ScalarFormatter())
ax.set_yticks(np.linspace(1000, 100, 19))
ax.set_yticklabels(p_grid_labels, color=cb_colors.gray7, fontsize=12)
ax.set_ylim(1050, 100)
#plot the title text
plt.text(0.05,
0.97,
title_text,
fontsize=15,
color=cb_colors.gray8,
weight='bold',
ha='left',
transform=fig.transFigure)
#x_hodo.annotate(sharptext, xy=(0.95, 0.95), xytext=(0.95, 0.95),xycoords='axes fraction',textcoords='axes fraction',ha='center', va='bottom', color=cb_colors.gray7, family='sans-serif', weight='bold', zorder=3,fontsize=14)
plt.text(0.8,
0.97,
sharptext,
fontsize=15,
color=cb_colors.gray8,
weight='bold',
ha='left',
transform=fig.transFigure)
#adjust the skew-T plot to make room for the rest of the figures. This was important to make everything line up.
plt.subplots_adjust(left=0.05, right=0.55, top=0.96, bottom=0.15)
#Plot the height labels on the left axis
ax2 = ax.twinx(
) #makes a twin of the skew-T subplot that's not skewed at 45 degrees
plt.yscale('log', nonposy='clip')
plt.yticks(p_interped, h_new_labels, color=cb_colors.green4, ha='left')
ax2.yaxis.tick_left()
ax2.tick_params(direction='in',
pad=-15,
axis='both',
which='major',
colors=cb_colors.green4,
length=10,
width=1.5)
ax2.set_yticklabels(h_new_labels,
fontsize=12,
weight='bold',
color=cb_colors.green4)
x = np.random.uniform(0.0, 10.0, 15)
y = np.random.uniform(0.0, 10.0, 15)
# Plot LCL and LFC levels
plt.plot((38, 42), (pcl.lfcpres, pcl.lfcpres),
c="darkgreen",
lw=2.0,
zorder=3)
ax2.annotate('LFC',
xy=(40, pcl.lfcpres),
xytext=(40, pcl.lfcpres),
ha='center',
va='bottom',
color=cb_colors.green5,
family='sans-serif',
weight='bold',
zorder=3,
fontsize=12)
plt.plot((38, 42), (pcl.lclpres, pcl.lclpres),
c="r",
linestyle='-',
lw=2.0,
zorder=3)
ax2.annotate('LCL',
xy=(40, pcl.lclpres + 5.),
xytext=(40, pcl.lclpres + 5.),
ha='center',
va='top',
color=cb_colors.red5,
family='sans-serif',
weight='bold',
zorder=3,
fontsize=12)
plt.plot((38, 42), (pcl.elpres, pcl.elpres),
c="m",
linestyle='-',
lw=2.0,
zorder=3)
ax2.annotate('EL',
xy=(40, pcl.elpres),
xytext=(40, pcl.elpres),
ha='center',
va='bottom',
color=cb_colors.purple5,
family='sans-serif',
weight='bold',
zorder=3,
fontsize=12)
# Plot Eff Inflow Layer
eff_inflow = (prof.ebottom, prof.etop)
eff_inflow_top = sharptab.interp.to_agl(
prof, sharptab.interp.hght(prof, eff_inflow[1]))
eff_inflow_bottom = sharptab.interp.to_agl(
prof, sharptab.interp.hght(prof, eff_inflow[0]))
bunkers = prof.srwind
effective_srh = prof.right_esrh
plt.plot((-25, -20), (eff_inflow[0], eff_inflow[0]),
c=cb_colors.red5,
linestyle='-',
lw=1.75,
zorder=3)
plt.plot((-25, -20), (eff_inflow[1], eff_inflow[1]),
c=cb_colors.red5,
linestyle='-',
lw=1.75,
zorder=3)
plt.plot((-22.5, -22.5), (eff_inflow[0], eff_inflow[1]),
c=cb_colors.red5,
linestyle='-',
lw=1.75,
zorder=3)
try:
plt.annotate(str(int(eff_inflow_bottom)) + 'm ',
xy=(-25, eff_inflow[0]),
xytext=(-25, eff_inflow[0]),
ha='right',
va='center',
color=cb_colors.red5,
zorder=3,
fontsize=12,
weight='bold')
plt.annotate(str(int(eff_inflow_top)) + 'm ',
xy=(-25, eff_inflow[1]),
xytext=(-25, eff_inflow[1]),
ha='right',
va='center',
color=cb_colors.red5,
zorder=3,
fontsize=12,
weight='bold')
plt.annotate(str(int(effective_srh[0])) + ' m$^2$/s$^2$',
xy=(-22.5, eff_inflow[1] - 10),
xytext=(-22.5, eff_inflow[1] - 10),
ha='center',
va='bottom',
color=cb_colors.red5,
zorder=3,
fontsize=12,
weight='bold')
except:
print("NO EFF INFLOW")
# PLOT WINDBARBS
p_barb = np.asarray(p_barb)
pidx = idx = np.where(np.asarray(p_barb) >= 100.)[0]
wind_barbs = ax2.barbs(55 * np.ones(len(p_barb[idx])),
p_barb[idx],
u_barb[idx],
v_barb[idx],
barbcolor=cb_colors.gray7,
flagcolor='None',
zorder=10,
lw=1.0,
length=7)
wind_barbs.set_clip_on(False)
ax2.invert_yaxis()
ax2.set_xlim(-50, 50)
ax2.set_ylim(1050, 100)
spd_barb = np.asarray(spd_barb)
# Create hodograph ********************************************************************************************
ax_hod = fig.add_axes([0.60, 0.45, 0.38, 0.475],
frameon=False) #, facecolor='k')
# Set the characteristics of the tick marks
for tick in ax_hod.xaxis.get_major_ticks():
tick.label.set_fontsize(12)
tick.label.set_color(cb_colors.gray7)
tick.label.set_weight('bold')
for tick in ax_hod.yaxis.get_major_ticks():
tick.label.set_fontsize(12)
tick.label.set_color(cb_colors.gray7)
tick.label.set_weight('bold')
for i in range(10, 90, 10):
# Draw the range rings around the hodograph.
circle = plt.Circle((0, 0),
i,
linestyle='--',
color='k',
alpha=.3,
fill=False)
ax_hod.add_artist(circle)
# Set the tick parameters to displace the tick labels from the hodograph axes
ax_hod.tick_params(axis='x',
which='major',
labelsize=10,
color=cb_colors.gray7,
pad=-235,
length=0)
ax_hod.tick_params(axis='y',
which='major',
labelsize=10,
color=cb_colors.gray7,
pad=-315,
length=0)
# Plot the hodograph axes
ax_hod.axvline(0, color=cb_colors.gray7, linestyle='-', linewidth=2.)
ax_hod.axhline(0, color=cb_colors.gray7, linestyle='-', linewidth=2.)
ax_hod.set_yticks(range(-60, 65, 10))
ax_hod.set_xticks(range(-70, 75, 10))
hod_yticklabels = [str(abs(i)) for i in range(-60, 65, 10)]
#hod_yticklabels[len(hod_yticklabels)/2] = ''
hod_xticklabels = [str(abs(i)) for i in range(-70, 75, 10)]
#hod_xticklabels[len(hod_xticklabels)/2] = ''
ax_hod.set_yticklabels(hod_yticklabels,
fontsize=12,
weight='bold',
color=cb_colors.gray7)
ax_hod.set_xticklabels(hod_xticklabels,
fontsize=12,
weight='bold',
color=cb_colors.gray7)
# Plot the hodograph using the color scheme for different layers (0-3, 3-6, etc.)
bounds = [0, 1000, 3000, 6000, 9000, 12000]
for i in range(1, len(bounds), 1):
subset_idxs = np.where(
(prof.hght <= sharptab.interp.to_msl(prof, bounds[i]))
& (prof.hght >= sharptab.interp.to_msl(prof, bounds[i - 1])))
subset_hghts = np.ma.concatenate(
([sharptab.interp.to_msl(prof, bounds[i - 1])],
prof.hght[subset_idxs], [sharptab.interp.to_msl(prof,
bounds[i])]))
u, v = sharptab.interp.components(
prof, sharptab.interp.pres(prof, subset_hghts))
ax_hod.plot(u,
v,
c=hodo_color[i - 1],
linewidth=2.5,
label=hodo_label[i - 1],
zorder=3)
if members is not None:
for mprof in members['member_profs']:
for i in range(1, len(bounds), 1):
subset_idxs = np.where(
(mprof.hght <= sharptab.interp.to_msl(mprof, bounds[i]))
& (mprof.hght >= sharptab.interp.to_msl(
mprof, bounds[i - 1])))
subset_hghts = np.ma.concatenate(
([sharptab.interp.to_msl(mprof, bounds[i - 1])
], mprof.hght[subset_idxs],
[sharptab.interp.to_msl(mprof, bounds[i])]))
u, v = sharptab.interp.components(
mprof, sharptab.interp.pres(mprof, subset_hghts))
ax_hod.plot(u,
v,
c=hodo_color[i - 1],
linewidth=1.25,
alpha=0.6,
label=hodo_label[i - 1],
zorder=1)
# Get the Bunkers storm motions and convert them to strings to plot
bunkers = srwind = prof.srwind
bunkers_rt = utils.comp2vec(bunkers[0], bunkers[1])
bunkers_lf = utils.comp2vec(bunkers[2], bunkers[3])
bunkers_rt_str = str(int(np.ma.around(bunkers_rt[0], 0))) + "/" + str(
int(np.ma.around(bunkers_rt[1], 0)))
bunkers_lf_str = str(int(np.ma.around(bunkers_lf[0], 0))) + "/" + str(
int(np.ma.around(bunkers_lf[1], 0)))
# Plot the effective inflow layer on the hodograph
effubot, effvbot = sharptab.interp.components(prof, eff_inflow[0])
effutop, effvtop = sharptab.interp.components(prof, eff_inflow[1])
ax_hod.plot([effubot, srwind[0]], [effvbot, srwind[1]],
c='c',
linewidth=1.5)
ax_hod.plot([effutop, srwind[0]], [effvtop, srwind[1]],
c='c',
linewidth=1.5)
# Annotate where the Bunkers storm motion vectors are on the hodograph
ax_hod.plot(srwind[0],
srwind[1],
marker='o',
fillstyle='none',
markeredgecolor=cb_colors.blue8,
markeredgewidth=1.5,
markersize=11)
ax_hod.annotate(bunkers_rt_str + ' RM', (srwind[0] + 1.5, srwind[1] - 1.5),
fontsize=12,
va="top",
ha="left",
color='k',
weight='bold',
zorder=10)
ax_hod.plot(srwind[2],
srwind[3],
marker='o',
fillstyle='none',
markeredgecolor=cb_colors.blue8,
markeredgewidth=1.5,
markersize=11)
ax_hod.annotate(bunkers_lf_str + ' LM', (srwind[2] + 1.5, srwind[3] - 1.5),
fontsize=12,
va="top",
ha="left",
color='k',
weight='bold',
zorder=10)
# Annotate where the Corfidi MBE vectors are on the hodograph
corfidi = prof.upshear_downshear
corfidi_up = utils.comp2vec(corfidi[0], corfidi[1])
corfidi_dn = utils.comp2vec(corfidi[2], corfidi[3])
c = 'k' #'#0A74C6'
ax_hod.plot(corfidi[0],
corfidi[1],
marker='o',
fillstyle='none',
markeredgecolor=c,
markeredgewidth=1.5,
markersize=9)
ax_hod.annotate(str(int(corfidi_up[0])) + '/' + str(int(corfidi_up[1])) +
' UP', (corfidi[0] + 1.5, corfidi[1] - 1.5),
fontsize=12,
va="top",
ha="left",
color=cb_colors.purple8,
weight='bold',
zorder=10)
ax_hod.plot(corfidi[2],
corfidi[3],
marker='o',
fillstyle='none',
markeredgecolor=c,
markeredgewidth=1.5,
markersize=9)
ax_hod.annotate(str(int(corfidi_dn[0])) + '/' + str(int(corfidi_dn[1])) +
' DN', (corfidi[2] + 1.5, corfidi[3] - 1.5),
fontsize=12,
va="top",
ha="left",
color=cb_colors.purple8,
weight='bold',
zorder=10)
# Get the cloud-layer mean wind
mean_cloudlayer = winds.mean_wind(prof, pbot=pcl.lclpres, ptop=pcl.elpres)
mean_cloudlayer_comp = utils.comp2vec(mean_cloudlayer[0],
mean_cloudlayer[1])
try:
mean_cloudlayer_str = str(int(np.ma.around(
mean_cloudlayer_comp[0], 0))) + "/" + str(
int(np.ma.around(mean_cloudlayer_comp[1], 0)))
except:
mean_cloudlayer_str = 'M/M'
# Write the critical angle to the hodograph.
if eff_inflow[0] == prof.pres[prof.sfc]:
ax_hod.annotate('Critical Angle = ' + str(int(prof.critical_angle)),
(-65, -50),
fontsize=12,
va="bottom",
ha="left",
color=cb_colors.green6,
weight='bold',
zorder=10)
ax_hod.set_xlim(-80, 80)
ax_hod.set_ylim(-70, 70)
#BELOW IS STUFF FOR BOXES/BORDERS ******************************************************************************
ax3 = ax2.twinx()
ax3.axes.get_xaxis().set_visible(False)
ax3.axes.get_yaxis().set_visible(False)
ax3.set_yticks([])
ax3.set_yticklabels([])
#Big Thick Box around Skew-T
#box = ax3.add_patch(patches.Rectangle((-50, 0), 110.0, 1.0,fill=False,linewidth=2,edgecolor="w",zorder=3))
#box.set_clip_on(False)
#box around hodograph
#box = ax_hod.add_patch(patches.Rectangle((-80., -70.), 160., 140.,fill=False,linewidth=2,edgecolor="w",zorder=4))
#box.set_clip_on(False)
inset_color = cb_colors.gray7
#THICK TEXT BOX around Thermodynamics Text
box = ax3.add_patch(
patches.Rectangle((-58.0, -0.035),
54,
-0.12,
fill=False,
linewidth=2,
edgecolor=inset_color,
zorder=4))
box.set_clip_on(False)
#THICK TEXT BOX around Kinematics Text
box = ax3.add_patch(
patches.Rectangle((-3.0, -0.035),
60,
-0.12,
fill=False,
linewidth=2,
edgecolor=inset_color,
zorder=4))
box.set_clip_on(False)
#THICK TEXT BOX Around Dynamics Text
# box = ax3.add_patch(patches.Rectangle((9.0, -0.04), 60, -0.38,fill=False,linewidth=2,edgecolor=inset_color,zorder=4))
# box.set_clip_on(False)
#THICK TEXT BOX Around SARS Text
# box = ax3.add_patch(patches.Rectangle((69.0, -0.04), 55, -0.38,fill=False,linewidth=2,edgecolor=inset_color,zorder=4))
# box.set_clip_on(False)
#Thermodynamics
#box = ax3.add_patch(patches.Rectangle((-55.0, -0.04), 64.0, -0.12,fill=False,linewidth=1,edgecolor=inset_color,zorder=4))
#box.set_clip_on(False)
#box = ax3.add_patch(patches.Rectangle((-55.0, -0.04), 64.0, -0.025,fill=False,linewidth=1,edgecolor=inset_color,zorder=4))
#box.set_clip_on(False)
# Write the parcel properties to the inset.
#x_list = [0, 0.08, 0.17, 0.25, 0.33, 0.39, 0.47]
x_list = np.array([0, 0.08, 0.17, 0.25, 0.33, 0.39, 0.47]) - 0.075
y_list = [-0.045, -0.07, -0.0925, -0.115, -0.1375]
A = [
"SFC", prof.sfcpcl.bplus,
int(prof.sfcpcl.bminus), prof.sfcpcl.lclhght, prof.sfcpcl.li5,
prof.sfcpcl.lfchght, prof.sfcpcl.elhght
]
# B = ["FCST", prof.fcstpcl.bplus, int(prof.fcstpcl.bminus), prof.fcstpcl.lclhght, prof.fcstpcl.li5, prof.fcstpcl.lfchght, prof.fcstpcl.elhght]
C = [
"ML", prof.mlpcl.bplus,
int(prof.mlpcl.bminus), prof.mlpcl.lclhght, prof.mlpcl.li5,
prof.mlpcl.lfchght, prof.mlpcl.elhght
]
D = [
"MU", prof.mupcl.bplus,
int(prof.mupcl.bminus), prof.mupcl.lclhght, prof.mupcl.li5,
prof.mupcl.lfchght, prof.mupcl.elhght
]
#mlcape = C[1]
#print('mlcape',mlcape)
data = np.array([["PCL", "CAPE", "CINH", "LCL", "LI", "LFC", "EL"],
[
str(int(np.ma.around(A[i], 0))) if
(type(A[i]) == np.float64) else str(A[i])
for i in range(len(A))
],
[
str(int(np.ma.around(C[i], 0))) if
(type(C[i]) == np.float64) else str(C[i])
for i in range(len(C))
],
[
str(int(np.ma.around(D[i], 0))) if
(type(D[i]) == np.float64) else str(D[i])
for i in range(len(D))
]])
for i in range(data.shape[0]):
for j in range(data.shape[1]):
ax2.annotate(data[i, j], (x_list[j], y_list[i]),
xycoords="axes fraction",
fontsize=12,
va="top",
ha="left",
color=cb_colors.gray7,
weight='bold')
# Draw a box around the selected parcel being shown in the Skew-T
box = ax3.add_patch(
patches.Rectangle((-57.7, pcl_box_level),
53.,
0.0225,
fill=False,
linewidth=1,
edgecolor=cb_colors.purple4,
zorder=4))
box.set_clip_on(False)
# Write the lapse rates to the inset.
#box = ax3.add_patch(patches.Rectangle((-55.0, -0.305), 43.0, -0.115,fill=False,linewidth=1,edgecolor="w",zorder=4))
#box.set_clip_on(False)
x_list = [0.15, 0.16]
y_list = np.arange(-0.315, -.40, -0.0225)
data = np.array([[
"0-3km AGL LR =",
str(np.ma.around(prof.lapserate_3km, 1)) + " C/km"
], [
"3-6km AGL LR =",
str(np.ma.around(prof.lapserate_3_6km, 1)) + " C/km"
],
[
"850-500mb LR =",
str(np.ma.around(prof.lapserate_850_500, 1)) + " C/km"
],
[
"700-500mb LR =",
str(np.ma.around(prof.lapserate_700_500, 1)) + " C/km"
]])
for i in range(data.shape[0]):
for j in range(data.shape[1]):
if (j % 2 == 0):
ax2.annotate(data[i, j], (x_list[j], y_list[i]),
xycoords="axes fraction",
fontsize=12,
va="top",
ha="right",
color='k',
weight='bold')
else:
ax2.annotate(data[i, j], (x_list[j], y_list[i]),
xycoords="axes fraction",
fontsize=12,
va="top",
ha="left",
color='k',
weight='bold')
#Severe Indices
#box = ax3.add_patch(patches.Rectangle((-12.0, -0.305), 21.0, -0.115,fill=False,linewidth=1,edgecolor="w",zorder=4))
#box.set_clip_on(False)
x_list = [0.52, 0.53]
y_list = np.arange(-0.315, -.40, -0.0225)
# This looks lifted from the Profile class. Don't need this.
sfc = prof.pres[prof.sfc]
p6km = sharptab.interp.pres(prof, sharptab.interp.to_msl(prof, 6000.))
p8km = sharptab.interp.pres(prof, sharptab.interp.to_msl(prof, 8000.))
# ebot_hght = interp.to_agl(prof, interp.hght(prof, eff_inflow[0]))
# etop_hght = interp.to_agl(prof, interp.hght(prof, eff_inflow[1]))
# Mean winds
#mean_1km = winds.mean_wind(prof, pbot=sfc, ptop=p1km)
mean_1km_comp = prof.mean_1km #utils.comp2vec(mean_1km[0],mean_1km[1])
#mean_3km = winds.mean_wind(prof, pbot=sfc, ptop=p3km)
mean_3km_comp = prof.mean_3km #utils.comp2vec(mean_3km[0],mean_3km[1])
#mean_eff = winds.mean_wind(prof, pbot=eff_inflow[0], ptop=eff_inflow[1])
mean_eff_comp = utils.comp2vec(
*prof.mean_eff) #utils.comp2vec(mean_eff[0],mean_eff[1])
if type(eff_inflow[0]) != np.float64:
mean_eff_comp = ['---', '--']
mean_6km = winds.mean_wind(prof, pbot=sfc, ptop=p6km)
mean_6km_comp = prof.mean_6km #utils.comp2vec(mean_6km[0],mean_6km[1])
mean_8km = winds.mean_wind(prof, pbot=sfc, ptop=p8km)
mean_8km_comp = prof.mean_8km #utils.comp2vec(mean_8km[0],mean_8km[1])
mean_cloudlayer = winds.mean_wind(prof, pbot=pcl.lclpres, ptop=pcl.elpres)
mean_cloudlayer_comp = prof.mean_lcl_el #utils.comp2vec(mean_cloudlayer[0],mean_cloudlayer[1])
mean_ebwd = winds.mean_wind(prof, pbot=eff_inflow[0], ptop=eff_inflow[1])
mean_ebwd_comp = utils.comp2vec(
*prof.mean_ebw) #utils.comp2vec(mean_ebwd[0],mean_ebwd[1])
if type(eff_inflow[0]) != np.float64:
mean_ebwd_comp = ['---', '--']
bunkers_rt = utils.comp2vec(bunkers[0], bunkers[1])
bunkers_lf = utils.comp2vec(bunkers[2], bunkers[3])
corfidi_up = utils.comp2vec(corfidi[0], corfidi[1])
corfidi_dn = utils.comp2vec(corfidi[2], corfidi[3])
srw_1km = prof.srw_1km #utils.comp2vec(*winds.sr_wind(prof, pbot=sfc, ptop=p1km, stu=prof.srwind[0], stv=prof.srwind[1]))
srw_3km = prof.srw_3km #utils.comp2vec(*winds.sr_wind(prof, pbot=sfc, ptop=p3km, stu=prof.srwind[0], stv=prof.srwind[1]))
srw_eff = utils.comp2vec(
*prof.srw_eff
) #utils.comp2vec(*winds.sr_wind(prof, pbot=eff_inflow[0], ptop=eff_inflow[1], stu=prof.srwind[0], stv=prof.srwind[1]))
if type(eff_inflow[0]) != np.float64:
srw_eff = ['---', '--']
srw_6km = prof.srw_6km #utils.comp2vec(*winds.sr_wind(prof, pbot=sfc, ptop=p6km, stu=prof.srwind[0], stv=prof.srwind[1]))
srw_8km = prof.srw_8km #utils.comp2vec(*winds.sr_wind(prof, pbot=sfc, ptop=p8km, stu=prof.srwind[0], stv=prof.srwind[1]))
srw_cloudlayer = prof.srw_lcl_el #utils.comp2vec(*winds.sr_wind(prof, pbot=pcl.lclpres, ptop=pcl.elpres, stu=prof.srwind[0], stv=prof.srwind[1]))
srw_ebwd = utils.comp2vec(
*prof.srw_ebw
) #utils.comp2vec(*winds.sr_wind(prof, pbot=eff_inflow[0], ptop=eff_inflow[1], stu=prof.srwind[0], stv=prof.srwind[1]))
if type(eff_inflow[0]) != np.float64:
srw_ebwd = ['---', '--']
srw_46km = utils.comp2vec(
*prof.srw_4_6km
) #utils.comp2vec(*winds.sr_wind(prof, pbot=p4km, ptop=p6km, stu=prof.srwind[0], stv=prof.srwind[1]))
sfc_8km_shear = prof.sfc_8km_shear #winds.wind_shear(prof, pbot=sfc, ptop=p8km)
sfc_6km_shear = prof.sfc_6km_shear #winds.wind_shear(prof, pbot=sfc, ptop=p6km)
sfc_3km_shear = prof.sfc_3km_shear #winds.wind_shear(prof, pbot=sfc, ptop=p3km)
sfc_1km_shear = prof.sfc_1km_shear #winds.wind_shear(prof, pbot=sfc, ptop=p1km)
effective_shear = prof.eff_shear #winds.wind_shear(prof, pbot=eff_inflow[0], ptop=etop_hght)
cloudlayer_shear = prof.lcl_el_shear #winds.wind_shear(prof,pbot= pcl.lclpres, ptop=pcl.elpres)
srh3km = prof.srh3km #winds.helicity(prof, 0, 3000., stu = bunkers[0], stv = bunkers[1])
srh1km = prof.srh1km #winds.helicity(prof, 0, 1000., stu = bunkers[0], stv = bunkers[1])
stp_fixed = prof.stp_fixed #params.stp_fixed(pcl.bplus, pcl.lclhght, srh1km[0], utils.comp2vec(sfc_6km_shear[0], sfc_6km_shear[1])[1])
ship = prof.ship
effective_srh = prof.right_esrh #winds.helicity(prof, ebot_hght, etop_hght, stu = bunkers[0], stv = bunkers[1])
ebwd = prof.ebwd #winds.wind_shear(prof, pbot=eff_inflow[0], ptop=eff_inflow[1])
ebwspd = prof.ebwspd
scp = prof.right_scp
stp_cin = prof.stp_cin #params.stp_cin(pcl.bplus, effective_srh[0], ebwspd, pcl.lclhght, pcl.bminus)
brn_shear = pcl.brnshear
# Draw the SCP, STP, SHIP indices to the plot
# TODO: Include the color variations on this to denote intensity of the index.
# if prof.stp_fixed is ma.masked:
# temp_stp_fixed = '0.0'
# else:
# temp_stp_fixed = str(round(prof.stp_fixed,1))
# if prof.stp_cin is ma.masked:
# temp_stp_cin = '0.0'
# else:
# temp_stp_cin = str(round(prof.stp_cin,1))
# if prof.right_scp is ma.masked:
# temp_right_scp = '0.0'
# else:
# temp_right_scp = str(round(prof.right_scp,1))
# data = np.array([["Supercell =",temp_right_scp],
# ["STP (cin) =",temp_stp_cin],
# ["STP (fix) =",temp_stp_fixed]])
data = np.array([["Supercell =",
str(np.ma.around(prof.right_scp, 1))],
["STP (cin) =",
str(np.ma.around(prof.stp_cin, 1))],
["STP (fix) =",
str(np.ma.around(prof.stp_fixed, 1))]])
data = np.array([["Supercell =",
str(np.ma.around(prof.right_scp, 1))],
["STP (cin) =",
str(np.ma.around(prof.stp_cin, 1))],
["STP (fix) =",
str(np.ma.around(prof.stp_fixed, 1))],
["SHIP =", str(np.ma.around(prof.ship, 1))]])
'''
for i in range(data.shape[0]):
for j in range(data.shape[1]):
d = float(data[i,1])
if i == 0:
if d >= 19.95:
c = MAGENTA
elif d >= 11.95:
c = RED
elif d >= 1.95:
c = YELLOW
elif d >= .45:
c = WHITE
elif d >= -.45:
c = LBROWN
elif d < -0.45:
c = CYAN
elif i == 1:
if d >= 8:
c = MAGENTA
elif d >= 4:
c = RED
elif d >= 2:
c = YELLOW
elif d >= 1:
c = WHITE
elif d >= .5:
c = LBROWN
elif d < .5:
c = DBROWN
stpCinColor = c
elif i == 2:
if d >= 7:
c = MAGENTA
elif d >= 5:
c = RED
elif d >= 2:
c = YELLOW
elif d >= 1:
c = WHITE
elif d >= 0.5:
c = LBROWN
else:
c = DBROWN
elif i == 3:
if d >= 5:
c = MAGENTA
elif d >= 2:
c = RED
elif d >= 1:
c = YELLOW
elif d >= .5:
c = WHITE
else:
c = DBROWN
if (j % 2 == 0):
ax2.annotate(data[i,j], (x_list[j], y_list[i]), xycoords="axes fraction",
fontsize=12, va="top", ha="right", color=c, weight='bold')
else:
ax2.annotate(data[i,j], (x_list[j], y_list[i]), xycoords="axes fraction",
fontsize=12, va="top", ha="left", color=cb_colors.gray7, weight='bold')
'''
# Draw the kinematic inset on the plot
# box = ax3.add_patch(patches.Rectangle((9.0, -0.04), 60.0, -0.025,fill=False,linewidth=1,edgecolor="w",zorder=4))
# box.set_clip_on(False)
x_list = np.array([0.60, 0.84, 0.97, 1.08, 1.18]) - 0.12
y_list = [-0.045]
y_list.extend(np.arange(-.07, -0.12, -.0225).tolist())
y_list.extend(np.arange(-.145, -0.22, -.0225).tolist())
y_list.extend(np.arange(-.2425, -0.27, -.0225).tolist())
y_list.extend(np.arange(-0.295, -.4, -0.0225).tolist())
A = [
"SFC-1km", srh1km[0],
utils.comp2vec(sfc_1km_shear[0], sfc_1km_shear[1])[1]
]
A2 = [mean_1km_comp, srw_1km]
B = [
"SFC-3km", srh3km[0],
utils.comp2vec(sfc_3km_shear[0], sfc_3km_shear[1])[1]
]
B2 = [mean_3km_comp, srw_3km]
C = [
"Eff Inflow Layer", effective_srh[0],
utils.comp2vec(effective_shear[0], effective_shear[1])[1]
]
C2 = [mean_eff_comp, srw_eff]
# D = ["SFC-6km", "", utils.comp2vec(sfc_6km_shear[0],sfc_6km_shear[1])[1]]
# D2 = [mean_6km_comp, srw_6km]
# E = ["SFC-8km", "", utils.comp2vec(sfc_8km_shear[0],sfc_8km_shear[1])[1]]
# E2 = [mean_8km_comp, srw_8km]
# F = ["LCL-EL (CLoud Layer)", "", utils.comp2vec(cloudlayer_shear[0],cloudlayer_shear[1])[1]]
# F2 = [mean_cloudlayer_comp, srw_cloudlayer]
# G = ["Eff Shear (EBWD)", "", utils.comp2vec(ebwd[0],ebwd[1])[1]]
# G2 = [mean_ebwd_comp, srw_ebwd]
# H = ["BRN Shear (m2/s2)", "", brn_shear, "", ""]
# I = ["4-6km SR Wind", ""]
# I2 = [str(int(round(srw_46km[0],0)))+"/"+str(int(round(srw_46km[1],0)))]
# I3 = ["", ""]
# J = ["...Storm Motion Vectors...", "", "", "", ""]
# K = ["Bunkers Right", ""]
# K2 = [str(int(round(bunkers_rt[0],0)))+"/"+str(int(round(bunkers_rt[1],0)))]
# K3 = ["", ""]
# L = ["Bunkers Left", ""]
# L2 = [str(int(round(bunkers_lf[0],0)))+"/"+str(int(round(bunkers_lf[1],0)))]
# L3 = ["", ""]
# M = ["Corfidi Downshear", ""]
# M2 = [str(int(round(corfidi_dn[0],0)))+"/"+str(int(round(corfidi_dn[1],0)))]
# M3 = ["", ""]
# N = ["Corfidi Upshear", ""]
# N2 = [str(int(round(corfidi_up[0],0)))+"/"+str(int(round(corfidi_up[1],0)))]
# N3 = ["", ""]
data = np.array([np.array(["", "SRH (m2/s2)", "Shear (kt)", "MnWind", "SRW"]),
np.array([ str(int(round(A[i],0))) if (type(A[i])== np.float64) else str(A[i]) for i in range(len(A)) ]+\
[ str(int(np.ma.around(A2[i][0],0)))+"/"+str(int(np.ma.around(A2[i][1],0))) if (type(A2[i][0])== np.ma.core.MaskedArray) else str(A2[i][0])+"/"+str(A2[i][1]) for i in range(len(A2)) ]),
np.array([ str(int(round(B[i],0))) if (type(B[i])== np.float64) else str(B[i]) for i in range(len(B)) ]+\
[ str(int(np.ma.around(B2[i][0],0)))+"/"+str(int(np.ma.around(B2[i][1],0))) if (type(B2[i][0])== np.ma.core.MaskedArray) else str(B2[i][0])+"/"+str(B2[i][1]) for i in range(len(B2)) ]),
np.array([ str(int(np.ma.around(C[i],0))) if (type(C[i])== np.float64) else str(C[i]) for i in range(len(C)) ]+\
[ str(int(np.ma.around(C2[i][0],0)))+"/"+str(int(np.ma.around(C2[i][1],0))) if (type(C2[i][0])== np.ma.core.MaskedArray) else str(C2[i][0])+"/"+str(C2[i][1]) for i in range(len(C2)) ])]) #,
# np.array([ str(int(round(D[i],0))) if (type(D[i])== np.float64) else str(D[i]) for i in range(len(D)) ]+\
# [ str(int(round(D2[i][0],0)))+"/"+str(int(round(D2[i][1],0))) if (type(D2[i][0])== np.ma.core.MaskedArray) else str(D2[i][0])+"/"+str(D2[i][1]) for i in range(len(D2)) ]),
# np.array([ str(int(round(E[i],0))) if (type(E[i])== np.float64) else str(E[i]) for i in range(len(E)) ]+\
# [ str(int(round(E2[i][0],0)))+"/"+str(int(round(E2[i][1],0))) if (type(E2[i][0])== np.ma.core.MaskedArray) else str(E2[i][0])+"/"+str(E2[i][1]) for i in range(len(E2)) ]),
# np.array([ str(int(round(F[i],0))) if (type(F[i])== np.float64) else str(F[i]) for i in range(len(F)) ]+\
# [ str(int(round(F2[i][0],0)))+"/"+str(int(round(F2[i][1],0))) if (type(F2[i][0])== np.ma.core.MaskedArray) else str(F2[i][0])+"/"+str(F2[i][1]) for i in range(len(F2)) ]),
# np.array([ str(int(round(G[i],0))) if (type(G[i])== np.float64) else str(G[i]) for i in range(len(G)) ]+\
# [ str(int(round(G2[i][0],0)))+"/"+str(int(round(G2[i][1],0))) if (type(G2[i][0])== np.ma.core.MaskedArray) else str(G2[i][0])+"/"+str(G2[i][1]) for i in range(len(G2)) ]),
# np.array([ str(int(round(H[i],0))) if (type(H[i])== np.float64) else str(H[i]) for i in range(len(H)) ]),
# np.array(I+I2+I3),
# np.array(J),
# np.array(K+K2+K3),
# np.array(L+L2+L3),
# np.array(M+M2+M3),
# np.array(N+N2+N3)])
#x_list = np.array([0, 0.08, 0.17, 0.25, 0.33, 0.39, 0.47])-0.05
y_list = [-0.045, -0.07, -0.0925, -0.115, -0.1375]
for i in range(data.shape[0]):
for j in range(data[0].shape[0]):
if j > 0:
ax2.annotate(data[i][j], (x_list[j], y_list[i]),
xycoords="axes fraction",
fontsize=12,
va="top",
ha="right",
color=cb_colors.gray7,
weight='bold')
else:
ax2.annotate(data[i][j], (x_list[j], y_list[i]),
xycoords="axes fraction",
fontsize=12,
va="top",
ha="left",
color=cb_colors.gray7,
weight='bold')
# wind_1km = utils.vec2comp(prof.wind1km[0], prof.wind1km[1])
# wind_6km = utils.vec2comp(prof.wind6km[0], prof.wind6km[1])
# wind_barbs = ax2.barbs(58, 2200, wind_1km[0], wind_1km[1], color='#AA0000', zorder=3, lw=1.25,length=9)
# wind_barbs.set_clip_on(False)
# wind_barbs = ax2.barbs(58, 2200, wind_6km[0], wind_6km[1], color='#0A74C6', zorder=3, lw=1.25,length=9)
# wind_barbs.set_clip_on(False)
# ax2.annotate("1km & 6km AGL\nWind Barbs", (1.08,-0.37), xycoords="axes fraction", fontsize=12, va="top", ha="center", color='#0A74C6', weight='bold')
# Draw the CAPE vs. SRH Scatter
#ax_EFSTP = fig.add_axes([0.74625, 0.0229, 0.20375, 0.2507], frameon=False)
#x_EFSTP = fig.add_axes([0.72625, 0.0229, 0.20375, 0.2507], frameon=False)
ax_EFSTP = fig.add_axes([0.625, 0.05, 0.35, 0.3], frameon=False)
for member_no, c in zip(
np.arange(1, 19, 1),
np.tile([
cb_colors.orange6, cb_colors.orange6, cb_colors.green6,
cb_colors.green6, cb_colors.purple6, cb_colors.purple6
], (3, 1))):
memidx = [0, 10, 11, 12, 13, 14, 15, 16, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ax_EFSTP.scatter(xpts[memidx[member_no - 1], :, :].ravel(),
ypts[memidx[member_no - 1], :, :].ravel(),
color=c,
marker='o',
s=5,
alpha=0.7)
ax_EFSTP.set_xticks(np.arange(0, 5001, 1000))
ax_EFSTP.set_yticks(np.arange(0, 601, 100))
#ax_EFSTP.set_xticklabels(np.arange(0,5001,1000),color='k',fontsize=12)
#ax_EFSTP.set_yticklabels(np.arange(0,601,100),color='k',fontsize=12)
ax_EFSTP.set_xlabel('MLCAPE', weight='bold', fontsize=14)
ax_EFSTP.set_ylabel('0-1km SRH', weight='bold', fontsize=14)
ax_EFSTP.tick_params(axis='both', labelsize=12, labelcolor='k')
ax_EFSTP.set_xlim(-200, 5000)
ax_EFSTP.set_ylim(-100, 600)
#ax_EFSTP.tick_params(direction='in', axis='x', which='major', colors=cb_colors.gray4,length=0,width=1.5,size=12)#pad=-10
#ax_EFSTP.tick_params(direction='in', axis='y', which='major', colors=cb_colors.gray4,length=0,width=1.5,size=12)#pad=-23
ax_EFSTP.grid(color=cb_colors.gray4,
linestyle='--',
dashes=(3, 3),
alpha=0.75,
zorder=0,
linewidth=1.25)
ax_EFSTP.text(0.8,
0.95,
'YSU',
color=cb_colors.orange6,
transform=ax_EFSTP.transAxes,
fontsize=16,
weight='bold')
ax_EFSTP.text(0.8,
0.89,
'MYJ',
color=cb_colors.green6,
transform=ax_EFSTP.transAxes,
fontsize=16,
weight='bold')
ax_EFSTP.text(0.8,
0.83,
'MYNN',
color=cb_colors.purple6,
transform=ax_EFSTP.transAxes,
fontsize=16,
weight='bold')
box = ax_EFSTP.add_patch(
patches.Rectangle((0, -1),
13,
13,
fill=False,
linewidth=2,
edgecolor=cb_colors.gray4,
zorder=10))
box.set_clip_on(False)
ax_EFSTP.annotate("0-1 km SRH vs. 100-mb MLCAPE", (0.5, 1.075),
xycoords="axes fraction",
fontsize=14,
va="center",
ha="center",
color=cb_colors.gray7,
weight='bold')
ax_EFSTP.annotate("(9 km neighborhood)", (0.5, 1.025),
xycoords="axes fraction",
fontsize=12,
va="center",
ha="center",
color=cb_colors.gray7,
weight='bold')
plt.savefig(figname, facecolor=fig.get_facecolor()) #, edgecolor=None)
def _parse(self):
"""
Parse the netCDF file according to the variable naming and
dimmensional conventions of the WRF-ARW.
"""
## open the file and also store the lat/lon of the selected point
file_data = self._downloadFile()
gridx = self._file_name[1]
gridy = self._file_name[2]
## calculate the nearest grid point to the map point
idx = self._find_nearest_point(file_data, gridx, gridy)
## check to see if this is a 4D netCDF4 that includes all available times.
## If it does, open and compute the variables as 4D variables
if len(file_data.variables["T"][:].shape) == 4:
## read in the data from the WRF file and conduct necessary processing
theta = file_data.variables["T"][:, :, idx[0], idx[1]] + 300.0
qvapr = file_data.variables["QVAPOR"][:, :, idx[0],
idx[1]] * 10**3 #g/kg
mpres = (file_data.variables["P"][:, :, idx[0], idx[1]] +
file_data.variables["PB"][:, :, idx[0], idx[1]]) * .01
mhght = file_data.variables[
"PH"][:, :, idx[0],
idx[1]] + file_data.variables["PHB"][:, :, idx[0],
idx[1]] / G
## unstagger the height grid
mhght = (mhght[:, :-1, :, :] + mhght[:, 1:, :, :]) / 2.
muwin = file_data.variables["U"][:, :, idx[0], idx[1]]
mvwin = file_data.variables["V"][:, :, idx[0], idx[1]]
## convert the potential temperature to air temperature
mtmpc = thermo.theta(1000.0, theta - 273.15, p2=mpres)
## convert the mixing ratio to dewpoint
mdwpc = thermo.temp_at_mixrat(qvapr, mpres)
## convert the grid relative wind to earth relative
U = muwin * file_data.variables['COSALPHA'][
0, idx[0], idx[1]] - mvwin * file_data.variables['SINALPHA'][
0, idx[0], idx[1]]
V = mvwin * file_data.variables['COSALPHA'][
0, idx[0], idx[1]] + muwin * file_data.variables['SINALPHA'][
0, idx[0], idx[1]]
## convert from m/s to kts
muwin = utils.MS2KTS(U)
mvwin = utils.MS2KTS(V)
## if the data is not 4D, then it must be assumed that this is a file containing only a single time
else:
## read in the data from the WRF file and conduct necessary processing
theta = file_data.variables["T"][:, idx[0], idx[1]] + 300.0
qvapr = file_data.variables["QVAPOR"][:, idx[0],
idx[1]] * 10**3 #g/kg
mpres = (file_data.variables["P"][:, idx[0], idx[1]] +
file_data.variables["PB"][:, idx[0], idx[1]]) * .01
mhght = file_data.variables["PH"][:, idx[0],
idx[1]] + file_data.variables[
"PHB"][:, idx[0], idx[1]] / G
## unstagger the height grid
mhght = (mhght[:-1, :, :] + mhght[1:, :, :]) / 2.
muwin = file_data.variables["U"][:, idx[0], idx[1]]
mvwin = file_data.variables["V"][:, idx[0], idx[1]]
## convert the potential temperature to air temperature
mtmpc = thermo.theta(1000.0, theta - 273.15, p2=mpres)
## convert the mixing ratio to dewpoint
mdwpc = thermo.temp_at_mixrat(qvapr, mpres)
## convert the grid relative wind to earth relative
U = muwin * file_data.variables['COSALPHA'][
0, idx[0], idx[1]] - mvwin * file_data.variables['SINALPHA'][
0, idx[0], idx[1]]
V = mvwin * file_data.variables['COSALPHA'][
0, idx[0], idx[1]] + muwin * file_data.variables['SINALPHA'][
0, idx[0], idx[1]]
## convert from m/s to kts
muwin = utils.MS2KTS(U)
mvwin = utils.MS2KTS(V)
## get the model start time of the file
inittime = dattim.datetime.strptime(str(file_data.START_DATE),
'%Y-%m-%d_%H:%M:%S')
profiles = []
dates = []
## loop over the available times
for i in range(file_data.variables["T"][:].shape[0]):
## make sure the arrays are 1D
prof_pres = mpres[i].flatten()
prof_hght = mhght[i].flatten()
prof_tmpc = mtmpc[i].flatten()
prof_dwpc = mdwpc[i].flatten()
prof_uwin = muwin[i].flatten()
prof_vwin = mvwin[i].flatten()
## compute the time of the profile
try:
delta = dattim.timedelta(
minutes=int(file_data.variables["XTIME"][i]))
curtime = inittime + delta
except KeyError:
var = ''.join(
np.asarray(file_data.variables['Times'][i], dtype=str))
curtime = dattim.datetime.strptime(var, '%Y-%m-%d_%H:%M:%S')
date_obj = curtime
## construct the profile object
prof = profile.create_profile(profile="raw",
pres=prof_pres,
hght=prof_hght,
tmpc=prof_tmpc,
dwpc=prof_dwpc,
u=prof_uwin,
v=prof_vwin,
location=str(gridx) + "," +
str(gridy),
date=date_obj,
missing=-999.0,
latitude=gridy,
strictQC=False)
## append the dates and profiles
profiles.append(prof)
dates.append(date_obj)
## create a profile collection - dictionary has no key since this
## is not an ensemble model
prof_coll = prof_collection.ProfCollection({'': profiles}, dates)
return prof_coll
def parcelx(lower, upper, pres, temp, dwpt, prof, **kwargs):
'''
Lifts the specified parcel, calculated various levels and parameters from
the profile object. B+/B- are calculated based on the specified layer.
!! All calculations use the virtual temperature correction unless noted. !!
Inputs
------
lower (float) Lower-bound lifting level (hPa)
upper (float) Upper-bound lifting level
pres (float) Pressure of parcel to lift (hPa)
temp (float) Temperature of parcel to lift (C)
dwpt (float) Dew Point of parcel to lift (C)
prof (profile object) Profile Object
Returns
-------
pcl (parcel object) Parcel Object
'''
pcl = Parcel(-1, -1, pres, temp, dwpt)
if 'lplvals' in kwargs: pcl.lplvals = kwargs.get('lplvals')
else:
lplvals = DefineParcel(prof, 5, pres=pres, temp=temp, dwpt=dwpt)
pcl.lplvals = lplvals
if prof.gNumLevels < 1: return pcl
lyre = -1
cap_strength = RMISSD
cap_strengthpres = RMISSD
li_max = RMISSD
li_maxpres = RMISSD
totp = 0.
totn = 0.
tote = 0.
cinh_old = 0.
# See if default layer is specified
if lower == -1:
lower = prof.gSndg[prof.sfc][prof.pind]
pcl.blayer = lower
if upper == -1:
upper = prof.gSndg[prof.gNumLevels - 1][prof.pind]
pcl.tlayer = upper
# Make sure that this is a valid layer
if lower > pres:
lower = pres
pcl.blayer = lower
if not QC(interp.vtmp(lower, prof)) or \
not QC(interp.vtmp(upper, prof)):
return RMISSD
# Begin with the Mixing Layer
te1 = interp.vtmp(pres, prof)
pe1 = lower
h1 = interp.hght(pe1, prof)
tp1 = thermo.virtemp(pres, temp, dwpt)
# te1 = tp1
# Lift parcel and return LCL pres (hPa) and LCL temp (c)
pe2, tp2 = thermo.drylift(pres, temp, dwpt)
blupper = pe2 # Define top of layer as LCL pres
h2 = interp.hght(pe2, prof)
te2 = interp.vtmp(pe2, prof)
pcl.lclpres = pe2
pcl.lclhght = interp.agl(h2, prof)
# Calculate lifted parcel theta for use in iterative CINH loop below
# RECALL: lifted parcel theta is CONSTANT from LPL to LCL
theta_parcel = thermo.theta(pe2, tp2, 1000.)
# Environmental theta and mixing ratio at LPL
bltheta = thermo.theta(pres, interp.temp(pres, prof), 1000.)
blmr = thermo.mixratio(pres, dwpt)
# ACCUMULATED CINH IN MIXING LAYER BELOW THE LCL
# This will be done in 10mb increments, and will use the virtual
# temperature correction where possible
pinc = -10
a = int(lower)
b = int(blupper)
for pp in range(a, b, int(pinc)):
pp1 = pp
pp2 = pp + pinc
if pp2 < blupper: pp2 = blupper
dz = interp.hght(pp2, prof) - interp.hght(pp1, prof)
# Calculate difference between Tv_parcel and Tv_environment at top
# and bottom of 10mb layers. Make use of constant lifted parcel
# theta and mixing ratio from LPL to LCL
tv_env_bot = thermo.virtemp(
pp1, thermo.theta(pp1, interp.temp(pp1, prof), 1000.),
interp.dwpt(pp1, prof))
tdef1 = (thermo.virtemp(pp1, theta_parcel,
thermo.temp_at_mixrat(blmr, pp1)) - tv_env_bot) / \
(thermo.ctok(tv_env_bot))
tv_env_top = thermo.virtemp(
pp2, thermo.theta(pp2, interp.temp(pp2, prof), 1000.),
interp.dwpt(pp2, prof))
tdef2 = (thermo.virtemp(pp2, theta_parcel,
thermo.temp_at_mixrat(blmr, pp2)) - tv_env_top) / \
(thermo.ctok(tv_env_bot))
lyre = G * (tdef1 + tdef2) / 2. * dz
if lyre < 0: totn += lyre
# Move the bottom layer to the top of the boundary layer
if lower > pe2:
lower = pe2
pcl.blayer = lower
# Calculate height of various temperature levels
p0c = temp_lvl(0., prof)
pm10c = temp_lvl(-10., prof)
pm20c = temp_lvl(-20., prof)
pm30c = temp_lvl(-30., prof)
hgt0c = interp.hght(p0c, prof)
hgtm10c = interp.hght(pm10c, prof)
hgtm20c = interp.hght(pm20c, prof)
hgtm30c = interp.hght(pm30c, prof)
pcl.p0c = p0c
pcl.pm10c = pm10c
pcl.pm20c = pm20c
pcl.pm30c = pm30c
pcl.hght0c = hgt0c
pcl.hghtm10c = hgtm10c
pcl.hghtm20c = hgtm20c
pcl.hghtm30c = hgtm30c
# Find lowest observation in layer
i = 0
while prof.gSndg[i][prof.pind] > lower:
if i == prof.gNumLevels - 1: break
i += 1
while not QC(prof.gSndg[i][prof.tdind]):
if i == prof.gNumLevels - 1: break
i += 1
lptr = i
if prof.gSndg[i][prof.pind] == lower:
if i != prof.gNumLevels - 1: lptr += 1
# Find highest observation in layer
i = prof.gNumLevels - 1
while prof.gSndg[i][prof.pind] < upper:
if i < lptr: break
i -= 1
uptr = i
if prof.gSndg[i][prof.pind] == upper:
if i > lptr: uptr -= 1
# START WITH INTERPOLATED BOTTOM LAYER
# Begin moist ascent from lifted parcel LCL (pe2, tp2)
pe1 = lower
h1 = interp.hght(pe1, prof)
te1 = interp.vtmp(pe1, prof)
tp1 = thermo.wetlift(pe2, tp2, pe1)
lyre = 0
lyrlast = 0
for i in range(lptr, prof.gNumLevels):
if not QC(prof.gSndg[i][prof.tind]): continue
pe2 = prof.gSndg[i][prof.pind]
h2 = prof.gSndg[i][prof.zind]
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe1, tp1, pe2)
tdef1 = (thermo.virtemp(pe1, tp1, tp1) - te1) / thermo.ctok(te1)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / thermo.ctok(te2)
lyrlast = lyre
lyre = G * (tdef1 + tdef2) / 2. * (h2 - h1)
# Add layer energy to total positive if lyre > 0
if lyre > 0:
totp += lyre
# Add layer energy to total negative if lyre < 0, only up to EL
else:
if pe2 > 500.: totn += lyre
# Check for Max LI
mli = thermo.virtemp(pe2, tp2, tp2) - te2
if mli > li_max:
li_max = mli
li_maxpres = pe2
# Check for Max Cap Strength
mcap = te2 - mli
if mcap > cap_strength:
cap_strength = mcap
cap_strengthpres = pe2
tote += lyre
pelast = pe1
pe1 = pe2
h1 = h2
te1 = te2
tp1 = tp2
# Is this the top of the specified layer
if i >= uptr and not QC(pcl.bplus):
pe3 = pe1
h3 = h1
te3 = te1
tp3 = tp1
lyrf = lyre
if lyrf > 0:
pcl.bplus = totp - lyrf
pcl.bminus = totn
else:
pcl.bplus = totp
if pe2 > 500.: pcl.bminus = totn + lyrf
else: pcl.bminus = totn
pe2 = upper
h2 = interp.hght(pe2, prof)
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
if lyrf > 0: pcl.bplus += lyrf
else:
if pe2 > 500.: pcl.bminus += lyrf
if pcl.bplus == 0: pcl.bminus = 0.
# Is this the freezing level
if te2 < 0. and not QC(pcl.bfzl):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.bfzl = totp - lyrf
else: pcl.bfzl = totp
if not QC(p0c) or p0c > pe3:
pcl.bfzl = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgt0c - h3)
if lyrf > 0: pcl.bfzl += lyrf
# Is this the -10C level
if te2 < -10. and not QC(pcl.wm10c):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.wm10c = totp - lyrf
else: pcl.wm10c = totp
if not QC(pm10c) or pm10c > pcl.lclpres:
pcl.wm10c = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgtm10c - h3)
if lyrf > 0: pcl.wm10c += lyrf
# Is this the -20C level
if te2 < -20. and not QC(pcl.wm20c):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.wm20c = totp - lyrf
else: pcl.wm20c = totp
if not QC(pm20c) or pm20c > pcl.lclpres:
pcl.wm20c = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgtm20c - h3)
if lyrf > 0: pcl.wm20c += lyrf
# Is this the -30C level
if te2 < -30. and not QC(pcl.wm30c):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0.: pcl.wm30c = totp - lyrf
else: pcl.wm30c = totp
if not QC(pm30c) or pm30c > pcl.lclpres:
pcl.wm30c = 0
elif QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (hgtm30c - h3)
if lyrf > 0: pcl.wm30c += lyrf
# Is this the 3km level
if pcl.lclhght < 3000.:
h = interp.agl(interp.hght(pe2, prof), prof)
if h >= 3000. and not QC(pcl.b3km):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0: pcl.b3km = totp - lyrf
else: pcl.b3km = totp
h2 = interp.msl(3000., prof)
pe2 = interp.pres(h2, prof)
if QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
if lyrf > 0: pcl.b3km += lyrf
else: pcl.b3km = 0.
# Is this the 6km level
if pcl.lclhght < 6000.:
h = interp.agl(interp.hght(pe2, prof), prof)
if h >= 6000. and not QC(pcl.b6km):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
lyrf = lyre
if lyrf > 0: pcl.b6km = totp - lyrf
else: pcl.b6km = totp
h2 = interp.msl(6000., prof)
pe2 = interp.pres(h2, prof)
if QC(pe2):
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
if lyrf > 0: pcl.b6km += lyrf
else: pcl.b6km = 0.
# LFC Possibility
if lyre >= 0. and lyrlast <= 0.:
tp3 = tp1
te3 = te1
pe2 = pe1
pe3 = pelast
while interp.vtmp(pe3, prof) > thermo.virtemp(
pe3, thermo.wetlift(pe2, tp3, pe3),
thermo.wetlift(pe2, tp3, pe3)):
pe3 -= 5
pcl.lfcpres = pe3
pcl.lfchght = interp.agl(interp.hght(pe3, prof), prof)
cinh_old = totn
tote = 0.
pcl.elpres = RMISSD
li_max = RMISSD
if cap_strength < 0.: cap_strength = 0.
pcl.cap = cap_strength
pcl.cappres = cap_strengthpres
# Hack to force LFC to be at least at the LCL
if pcl.lfcpres > pcl.lclpres:
pcl.lfcpres = pcl.lclpres
pcl.lfchght = pcl.lclhght
# EL Possibility
if lyre <= 0. and lyrlast >= 0.:
tp3 = tp1
te3 = te1
pe2 = pe1
pe3 = pelast
while interp.vtmp(pe3, prof) < thermo.virtemp(
pe3, thermo.wetlift(pe2, tp3, pe3),
thermo.wetlift(pe2, tp3, pe3)):
pe3 -= 5
pcl.elpres = pe3
pcl.elhght = interp.agl(interp.hght(pe3, prof), prof)
pcl.mplpres = RMISSD
pcl.limax = -li_max
pcl.limaxpress = li_maxpres
# MPL Possibility
if tote < 0. and not QC(pcl.mplpres) and QC(pcl.elpres):
pe3 = pelast
h3 = interp.hght(pe3, prof)
te3 = interp.vtmp(pe3, prof)
tp3 = thermo.wetlift(pe1, tp1, pe3)
totx = tote - lyre
pe2 = pelast
while totx > 0:
pe2 -= 1
te2 = interp.vtmp(pe2, prof)
tp2 = thermo.wetlift(pe3, tp3, pe2)
h2 = interp.hght(pe2, prof)
tdef3 = (thermo.virtemp(pe3, tp3, tp3) - te3) / \
thermo.ctok(te3)
tdef2 = (thermo.virtemp(pe2, tp2, tp2) - te2) / \
thermo.ctok(te2)
lyrf = G * (tdef3 + tdef2) / 2. * (h2 - h3)
totx += lyrf
tp3 = tp2
te3 = te2
pe3 = pe2
pcl.mplpres = pe2
pcl.mplhght = interp.agl(interp.hght(pe2, prof), prof)
# 500 hPa Lifted Index
if prof.gSndg[i][prof.pind] <= 500. and pcl.li5 == RMISSD:
a = interp.vtmp(500., prof)
b = thermo.wetlift(pe1, tp1, 500.)
pcl.li5 = a - thermo.virtemp(500, b, b)
# 300 hPa Lifted Index
if prof.gSndg[i][prof.pind] <= 300. and pcl.li3 == RMISSD:
a = interp.vtmp(300., prof)
b = thermo.wetlift(pe1, tp1, 300.)
pcl.li3 = a - thermo.virtemp(300, b, b)
# Calculate BRN if available
pcl = bulk_rich(pcl, prof)
pcl.bminus = cinh_old
if pcl.bplus == 0: pcl.bminus = 0.
return pcl
