def get_fire(self):
'''
Function to generate different indices and information
regarding any fire weather in the sounding. This helps fill
the data shown in the FIRE inset.
Parameters
----------
None
Returns
-------
None
'''
self.fosberg = fire.fosberg(self)
self.ppbl_top = params.pbl_top(self)
self.sfc_rh = thermo.relh(self.pres[self.sfc], self.tmpc[self.sfc], self.dwpc[self.sfc])
pres_sfc = self.pres[self.sfc]
pres_1km = interp.pres(self, interp.to_msl(self, 1000.))
pbl_h = interp.to_agl(self, interp.hght(self, self.ppbl_top))
self.rh01km = params.mean_relh(self, pbot=pres_sfc, ptop=pres_1km)
self.pblrh = params.mean_relh(self, pbot=pres_sfc, ptop=self.ppbl_top)
self.meanwind01km = winds.mean_wind(self, pbot=pres_sfc, ptop=pres_1km)
self.meanwindpbl = winds.mean_wind(self, pbot=pres_sfc, ptop=self.ppbl_top)
self.pblmaxwind = winds.max_wind(self, lower=0, upper=pbl_h)
#self.pblmaxwind = [np.ma.masked, np.ma.masked]
mulplvals = params.DefineParcel(self, flag=3, pres=500)
mupcl = params.cape(self, lplvals=mulplvals)
self.bplus_fire = mupcl.bplus
def get_fire(self):
'''
Function to generate different indices and information
regarding any fire weather in the sounding. This helps fill
the data shown in the FIRE inset.
Parameters
----------
None
Returns
-------
None
'''
self.fosberg = fire.fosberg(self)
self.ppbl_top = params.pbl_top(self)
self.sfc_rh = thermo.relh(self.pres[self.sfc], self.tmpc[self.sfc],
self.dwpc[self.sfc])
pres_sfc = self.pres[self.sfc]
pres_1km = interp.pres(self, interp.to_msl(self, 1000.))
pbl_h = interp.to_agl(self, interp.hght(self, self.ppbl_top))
self.rh01km = params.mean_relh(self, pbot=pres_sfc, ptop=pres_1km)
self.pblrh = params.mean_relh(self, pbot=pres_sfc, ptop=self.ppbl_top)
self.meanwind01km = winds.mean_wind(self, pbot=pres_sfc, ptop=pres_1km)
self.meanwindpbl = winds.mean_wind(self,
pbot=pres_sfc,
ptop=self.ppbl_top)
self.pblmaxwind = winds.max_wind(self, lower=0, upper=pbl_h)
#self.pblmaxwind = [np.ma.masked, np.ma.masked]
mulplvals = params.DefineParcel(self, flag=3, pres=500)
mupcl = params.cape(self, lplvals=mulplvals)
self.bplus_fire = mupcl.bplus
def bulk_rich(pcl, prof):
'''
Calculates the Bulk Richardson Number for a given parcel.
Inputs
------
pcl (parcel object) Parcel Object
prof (profile object) Profile Object
Returns
-------
Bulk Richardson Number
'''
# Make sure parcel is initialized
if pcl.lplvals.flag == RMISSD:
pbot = RMISSD
elif pcl.lplvals.flag > 0 and pcl.lplvals.flag < 4:
ptop = interp.pres(interp.msl(6000., prof), prof)
pbot = prof.gSndg[prof.sfc][prof.pind]
else:
h0 = interp.hght(pcl.pres, prof)
try:
pbot = interp.pres(h0 - 500., prof)
except:
pbot = RMISSD
if not QC(pbot): pbot = prof.gSndg[prof.sfc][prof.pind]
h1 = interp.hght(pbot, prof)
ptop = interp.pres(h1 + 6000., prof)
if not QC(pbot) or not QC(ptop):
pcl.brnshear = RMISSD
pcl.brn = RMISSD
return pcl
# Calculate lowest 500m mean wind
p = interp.pres(interp.hght(pbot, prof) + 500., prof)
mnlu, mnlv = winds.mean_wind(pbot, p, prof)
# Calculate the 6000m mean wind
mnuu, mnuv = winds.mean_wind(pbot, ptop, prof)
# Make sure CAPE and Shear are available
if not QC(pcl.bplus) or not QC(mnlu) or not QC(mnuu):
pcl.brnshear = RMISSD
pcl.brn = RMISSD
return pcl
# Calculate shear between levels
dx = mnuu - mnlu
dy = mnuv - mnlv
pcl.brnshear = KTS2MS(vector.comp2vec(dx, dy)[1])
pcl.brnshear = pcl.brnshear**2 / 2.
pcl.brn = pcl.bplus / pcl.brnshear
return pcl
def bulk_rich(pcl, prof):
'''
Calculates the Bulk Richardson Number for a given parcel.
Inputs
------
pcl (parcel object) Parcel Object
prof (profile object) Profile Object
Returns
-------
Bulk Richardson Number
'''
# Make sure parcel is initialized
if pcl.lplvals.flag == RMISSD:
pbot = RMISSD
elif pcl.lplvals.flag > 0 and pcl.lplvals.flag < 4:
ptop = interp.pres(interp.msl(6000., prof), prof)
pbot = prof.gSndg[prof.sfc][prof.pind]
else:
h0 = interp.hght(pcl.pres, prof)
try:
pbot = interp.pres(h0 - 500., prof)
except:
pbot = RMISSD
if not QC(pbot): pbot = prof.gSndg[prof.sfc][prof.pind]
h1 = interp.hght(pbot, prof)
ptop = interp.pres(h1 + 6000., prof)
if not QC(pbot) or not QC(ptop):
pcl.brnshear = RMISSD
pcl.brn = RMISSD
return pcl
# Calculate lowest 500m mean wind
p = interp.pres(interp.hght(pbot, prof) + 500., prof)
mnlu, mnlv = winds.mean_wind(pbot, p, prof)
# Calculate the 6000m mean wind
mnuu, mnuv = winds.mean_wind(pbot, ptop, prof)
# Make sure CAPE and Shear are available
if not QC(pcl.bplus) or not QC(mnlu) or not QC(mnuu):
pcl.brnshear = RMISSD
pcl.brn = RMISSD
return pcl
# Calculate shear between levels
dx = mnuu - mnlu
dy = mnuv - mnlv
pcl.brnshear = KTS2MS(vector.comp2vec(dx, dy)[1])
pcl.brnshear = pcl.brnshear**2 / 2.
pcl.brn = pcl.bplus / pcl.brnshear
return pcl
def get_kinematics(self):
'''
Function to generate the numerous kinematic quantities
used for display and calculations. It requires that the
parcel calculations have already been called for the lcl
to el shear and mean wind vectors, as well as indices
that require an effective inflow layer.
Parameters
----------
None
Returns
-------
None
'''
sfc = self.pres[self.sfc]
heights = np.array([1000., 3000., 4000., 5000., 6000., 8000., 9000.])
p1km, p3km, p4km, p5km, p6km, p8km, p9km = interp.pres(
self, interp.to_msl(self, heights))
## 1km and 6km winds
self.wind1km = interp.vec(self, p1km)
self.wind6km = interp.vec(self, p6km)
## calcluate wind shear
self.sfc_1km_shear = winds.wind_shear(self, pbot=sfc, ptop=p1km)
self.sfc_3km_shear = winds.wind_shear(self, pbot=sfc, ptop=p3km)
self.sfc_6km_shear = winds.wind_shear(self, pbot=sfc, ptop=p6km)
self.sfc_8km_shear = winds.wind_shear(self, pbot=sfc, ptop=p8km)
self.sfc_9km_shear = winds.wind_shear(self, pbot=sfc, ptop=p9km)
self.lcl_el_shear = winds.wind_shear(self,
pbot=self.mupcl.lclpres,
ptop=self.mupcl.elpres)
## calculate mean wind
self.mean_1km = utils.comp2vec(
*winds.mean_wind(self, pbot=sfc, ptop=p1km))
self.mean_3km = utils.comp2vec(
*winds.mean_wind(self, pbot=sfc, ptop=p3km))
self.mean_6km = utils.comp2vec(
*winds.mean_wind(self, pbot=sfc, ptop=p6km))
self.mean_8km = utils.comp2vec(
*winds.mean_wind(self, pbot=sfc, ptop=p8km))
self.mean_lcl_el = utils.comp2vec(*winds.mean_wind(
self, pbot=self.mupcl.lclpres, ptop=self.mupcl.elpres))
## parameters that depend on the presence of an effective inflow layer
if self.etop is ma.masked or self.ebottom is ma.masked:
self.etopm = ma.masked
self.ebotm = ma.masked
self.srwind = winds.non_parcel_bunkers_motion(self)
self.eff_shear = [MISSING, MISSING]
self.ebwd = [MISSING, MISSING, MISSING]
self.ebwspd = MISSING
self.mean_eff = [MISSING, MISSING, MISSING]
self.mean_ebw = [MISSING, MISSING, MISSING]
self.srw_eff = [MISSING, MISSING, MISSING]
self.srw_ebw = [MISSING, MISSING, MISSING]
self.right_esrh = [ma.masked, ma.masked, ma.masked]
self.left_esrh = [ma.masked, ma.masked, ma.masked]
self.critical_angle = ma.masked
else:
self.srwind = params.bunkers_storm_motion(self,
mupcl=self.mupcl,
pbot=self.ebottom)
depth = (self.mupcl.elhght - self.ebotm) / 2
elh = interp.pres(self, interp.to_msl(self, self.ebotm + depth))
## calculate mean wind
self.mean_eff = winds.mean_wind(self, self.ebottom, self.etop)
self.mean_ebw = winds.mean_wind(self, pbot=self.ebottom, ptop=elh)
## calculate wind shear of the effective layer
self.eff_shear = winds.wind_shear(self,
pbot=self.ebottom,
ptop=self.etop)
self.ebwd = winds.wind_shear(self, pbot=self.ebottom, ptop=elh)
self.ebwspd = utils.mag(self.ebwd[0], self.ebwd[1])
## calculate the mean sr wind
self.srw_eff = winds.sr_wind(self,
pbot=self.ebottom,
ptop=self.etop,
stu=self.srwind[0],
stv=self.srwind[1])
self.srw_ebw = winds.sr_wind(self,
pbot=self.ebottom,
ptop=elh,
stu=self.srwind[0],
stv=self.srwind[1])
self.right_esrh = winds.helicity(self,
self.ebotm,
self.etopm,
stu=self.srwind[0],
stv=self.srwind[1])
self.left_esrh = winds.helicity(self,
self.ebotm,
self.etopm,
stu=self.srwind[2],
stv=self.srwind[3])
self.critical_angle = winds.critical_angle(self,
stu=self.srwind[0],
stv=self.srwind[1])
## calculate mean srw
self.srw_1km = utils.comp2vec(*winds.sr_wind(
self, pbot=sfc, ptop=p1km, stu=self.srwind[0], stv=self.srwind[1]))
self.srw_3km = utils.comp2vec(*winds.sr_wind(
self, pbot=sfc, ptop=p3km, stu=self.srwind[0], stv=self.srwind[1]))
self.srw_6km = utils.comp2vec(*winds.sr_wind(
self, pbot=sfc, ptop=p6km, stu=self.srwind[0], stv=self.srwind[1]))
self.srw_8km = utils.comp2vec(*winds.sr_wind(
self, pbot=sfc, ptop=p8km, stu=self.srwind[0], stv=self.srwind[1]))
self.srw_4_5km = utils.comp2vec(*winds.sr_wind(
self, pbot=p4km, ptop=p5km, stu=self.srwind[0],
stv=self.srwind[1]))
self.srw_lcl_el = utils.comp2vec(
*winds.sr_wind(self,
pbot=self.mupcl.lclpres,
ptop=self.mupcl.elpres,
stu=self.srwind[0],
stv=self.srwind[1]))
# This is for the red, blue, and purple bars that appear on the SR Winds vs. Height plot
self.srw_0_2km = winds.sr_wind(self,
pbot=sfc,
ptop=interp.pres(
self, interp.to_msl(self, 2000.)),
stu=self.srwind[0],
stv=self.srwind[1])
self.srw_4_6km = winds.sr_wind(self,
pbot=interp.pres(
self, interp.to_msl(self, 4000.)),
ptop=p6km,
stu=self.srwind[0],
stv=self.srwind[1])
self.srw_9_11km = winds.sr_wind(
self,
pbot=interp.pres(self, interp.to_msl(self, 9000.)),
ptop=interp.pres(self, interp.to_msl(self, 11000.)),
stu=self.srwind[0],
stv=self.srwind[1])
## calculate upshear and downshear
self.upshear_downshear = winds.mbe_vectors(self)
self.srh1km = winds.helicity(self,
0,
1000.,
stu=self.srwind[0],
stv=self.srwind[1])
self.srh3km = winds.helicity(self,
0,
3000.,
stu=self.srwind[0],
stv=self.srwind[1])
def indices(prof, debug=False):
# return a formatted-string list of stability and kinematic indices
sfcpcl = params.parcelx(prof, flag=1)
mupcl = params.parcelx(prof, flag=3) # most unstable
mlpcl = params.parcelx(prof, flag=4) # 100 mb mean layer parcel
pcl = mupcl
sfc = prof.pres[prof.sfc]
p3km = interp.pres(prof, interp.to_msl(prof, 3000.))
p6km = interp.pres(prof, interp.to_msl(prof, 6000.))
p1km = interp.pres(prof, interp.to_msl(prof, 1000.))
mean_3km = winds.mean_wind(prof, pbot=sfc, ptop=p3km)
sfc_6km_shear = winds.wind_shear(prof, pbot=sfc, ptop=p6km)
sfc_3km_shear = winds.wind_shear(prof, pbot=sfc, ptop=p3km)
sfc_1km_shear = winds.wind_shear(prof, pbot=sfc, ptop=p1km)
#print "0-3 km Pressure-Weighted Mean Wind (kt):", utils.comp2vec(mean_3km[0], mean_3km[1])[1]
#print "0-6 km Shear (kt):", utils.comp2vec(sfc_6km_shear[0], sfc_6km_shear[1])[1]
srwind = params.bunkers_storm_motion(prof)
srh3km = winds.helicity(prof, 0, 3000., stu=srwind[0], stv=srwind[1])
srh1km = winds.helicity(prof, 0, 1000., stu=srwind[0], stv=srwind[1])
#print "0-3 km Storm Relative Helicity [m2/s2]:",srh3km[0]
#### Calculating variables based off of the effective inflow layer:
# The effective inflow layer concept is used to obtain the layer of buoyant parcels that feed a storm's inflow.
# Here are a few examples of how to compute variables that require the effective inflow layer in order to calculate them:
stp_fixed = params.stp_fixed(
sfcpcl.bplus, sfcpcl.lclhght, srh1km[0],
utils.comp2vec(sfc_6km_shear[0], sfc_6km_shear[1])[1])
ship = params.ship(prof)
# If you get an error about not converting masked constant to python int
# use the round() function instead of int() - Ahijevych May 11 2016
# 2nd element of list is the # of decimal places
indices = {
'SBCAPE': [sfcpcl.bplus, 0, 'J $\mathregular{kg^{-1}}$'],
'SBCIN': [sfcpcl.bminus, 0, 'J $\mathregular{kg^{-1}}$'],
'SBLCL': [sfcpcl.lclhght, 0, 'm AGL'],
'SBLFC': [sfcpcl.lfchght, 0, 'm AGL'],
'SBEL': [sfcpcl.elhght, 0, 'm AGL'],
'SBLI': [sfcpcl.li5, 0, 'C'],
'MLCAPE': [mlpcl.bplus, 0, 'J $\mathregular{kg^{-1}}$'],
'MLCIN': [mlpcl.bminus, 0, 'J $\mathregular{kg^{-1}}$'],
'MLLCL': [mlpcl.lclhght, 0, 'm AGL'],
'MLLFC': [mlpcl.lfchght, 0, 'm AGL'],
'MLEL': [mlpcl.elhght, 0, 'm AGL'],
'MLLI': [mlpcl.li5, 0, 'C'],
'MUCAPE': [mupcl.bplus, 0, 'J $\mathregular{kg^{-1}}$'],
'MUCIN': [mupcl.bminus, 0, 'J $\mathregular{kg^{-1}}$'],
'MULCL': [mupcl.lclhght, 0, 'm AGL'],
'MULFC': [mupcl.lfchght, 0, 'm AGL'],
'MUEL': [mupcl.elhght, 0, 'm AGL'],
'MULI': [mupcl.li5, 0, 'C'],
'0-1 km SRH': [srh1km[0], 0, '$\mathregular{m^{2}s^{-2}}$'],
'0-1 km Shear':
[utils.comp2vec(sfc_1km_shear[0], sfc_1km_shear[1])[1], 0, 'kt'],
'0-3 km SRH': [srh3km[0], 0, '$\mathregular{m^{2}s^{-2}}$'],
'0-6 km Shear':
[utils.comp2vec(sfc_6km_shear[0], sfc_6km_shear[1])[1], 0, 'kt'],
'PWV': [params.precip_water(prof), 2, 'inch'],
'K-index': [params.k_index(prof), 0, ''],
'STP(fix)': [stp_fixed, 1, ''],
'SHIP': [ship, 1, '']
}
eff_inflow = params.effective_inflow_layer(prof)
if any(eff_inflow):
ebot_hght = interp.to_agl(prof, interp.hght(prof, eff_inflow[0]))
etop_hght = interp.to_agl(prof, interp.hght(prof, eff_inflow[1]))
#print "Effective Inflow Layer Bottom Height (m AGL):", ebot_hght
#print "Effective Inflow Layer Top Height (m AGL):", etop_hght
effective_srh = winds.helicity(prof,
ebot_hght,
etop_hght,
stu=srwind[0],
stv=srwind[1])
indices['Eff. SRH'] = [
effective_srh[0], 0, '$\mathregular{m^{2}s^{-2}}$'
]
#print "Effective Inflow Layer SRH (m2/s2):", effective_srh[0]
ebwd = winds.wind_shear(prof, pbot=eff_inflow[0], ptop=eff_inflow[1])
ebwspd = utils.mag(*ebwd)
indices['EBWD'] = [ebwspd, 0, 'kt']
#print "Effective Bulk Wind Difference:", ebwspd
scp = params.scp(mupcl.bplus, effective_srh[0], ebwspd)
indices['SCP'] = [scp, 1, '']
stp_cin = params.stp_cin(mlpcl.bplus, effective_srh[0], ebwspd,
mlpcl.lclhght, mlpcl.bminus)
indices['STP(cin)'] = [stp_cin, 1, '']
#print "Supercell Composite Parameter:", scp
#print "Significant Tornado Parameter (w/CIN):", stp_cin
#print "Significant Tornado Parameter (fixed):", stp_fixed
# Update the indices within the indices dictionary on the side of the plot.
string = ''
for index, value in sorted(indices.items()):
if np.ma.is_masked(value[0]):
if debug:
print("skipping masked value for index=", index)
continue
if debug:
print("index=", index)
print("value=", value)
format = '%.' + str(value[1]) + 'f'
string += index + ": " + format % value[0] + " " + value[2] + '\n'
return string
''' Create the Sounding (Profile) Object '''
# Convert wind speed and direction to components
u, v = get_wind_components(spd, direc)
u_std, v_std = get_wind_components(spd_std, direc_std)
#PARCEL CALCULATIONS with sharppy
sfcpcl = params.parcelx(prof, flag=1) # Surface Parcel
fcstpcl = params.parcelx(prof, flag=2) # Forecast Parcel
mupcl = params.parcelx(prof, flag=3) # Most-Unstable Parcel
mlpcl = params.parcelx(prof, flag=4) # 100 mb Mean Layer Parcel
sfc = prof.pres[prof.sfc]
p3km = interp.pres(prof, interp.to_msl(prof, 3000.))
p6km = interp.pres(prof, interp.to_msl(prof, 6000.))
p1km = interp.pres(prof, interp.to_msl(prof, 1000.))
mean_3km = winds.mean_wind(prof, pbot=sfc, ptop=p3km)
sfc_6km_shear = winds.wind_shear(prof, pbot=sfc, ptop=p6km)
sfc_3km_shear = winds.wind_shear(prof, pbot=sfc, ptop=p3km)
sfc_1km_shear = winds.wind_shear(prof, pbot=sfc, ptop=p1km)
srwind = params.bunkers_storm_motion(prof)
srh3km = winds.helicity(prof, 0, 3000., stu=srwind[0], stv=srwind[1])
srh1km = winds.helicity(prof, 0, 1000., stu=srwind[0], stv=srwind[1])
stp_fixed = params.stp_fixed(
sfcpcl.bplus, sfcpcl.lclhght, srh1km[0],
utils.comp2vec(sfc_6km_shear[0], sfc_6km_shear[1])[1])
ship = params.ship(prof)
eff_inflow = params.effective_inflow_layer(prof)
ebot_hght = interp.to_agl(prof, interp.hght(prof, eff_inflow[0]))
etop_hght = interp.to_agl(prof, interp.hght(prof, eff_inflow[1]))
effective_srh = winds.helicity(prof,
def get_kinematics(self):
'''
Function to generate the numerous kinematic quantities
used for display and calculations. It requires that the
parcel calculations have already been called for the lcl
to el shear and mean wind vectors, as well as indices
that require an effective inflow layer.
Parameters
----------
None
Returns
-------
None
'''
sfc = self.pres[self.sfc]
heights = np.array([1000., 3000., 4000., 5000., 6000., 8000., 9000.])
p1km, p3km, p4km, p5km, p6km, p8km, p9km = interp.pres(self, interp.to_msl(self, heights))
## 1km and 6km winds
self.wind1km = interp.vec(self, p1km)
self.wind6km = interp.vec(self, p6km)
## calcluate wind shear
self.sfc_1km_shear = winds.wind_shear(self, pbot=sfc, ptop=p1km)
self.sfc_3km_shear = winds.wind_shear(self, pbot=sfc, ptop=p3km)
self.sfc_6km_shear = winds.wind_shear(self, pbot=sfc, ptop=p6km)
self.sfc_8km_shear = winds.wind_shear(self, pbot=sfc, ptop=p8km)
self.sfc_9km_shear = winds.wind_shear(self, pbot=sfc, ptop=p9km)
self.lcl_el_shear = winds.wind_shear(self, pbot=self.mupcl.lclpres, ptop=self.mupcl.elpres)
## calculate mean wind
self.mean_1km = utils.comp2vec(*winds.mean_wind(self, pbot=sfc, ptop=p1km))
self.mean_3km = utils.comp2vec(*winds.mean_wind(self, pbot=sfc, ptop=p3km))
self.mean_6km = utils.comp2vec(*winds.mean_wind(self, pbot=sfc, ptop=p6km))
self.mean_8km = utils.comp2vec(*winds.mean_wind(self, pbot=sfc, ptop=p8km))
self.mean_lcl_el = utils.comp2vec(*winds.mean_wind(self, pbot=self.mupcl.lclpres, ptop=self.mupcl.elpres))
## parameters that depend on the presence of an effective inflow layer
if self.etop is ma.masked or self.ebottom is ma.masked:
self.etopm = ma.masked; self.ebotm = ma.masked
self.srwind = winds.non_parcel_bunkers_motion( self )
self.eff_shear = [MISSING, MISSING]
self.ebwd = [MISSING, MISSING, MISSING]
self.ebwspd = MISSING
self.mean_eff = [MISSING, MISSING, MISSING]
self.mean_ebw = [MISSING, MISSING, MISSING]
self.srw_eff = [MISSING, MISSING, MISSING]
self.srw_ebw = [MISSING, MISSING, MISSING]
self.right_esrh = [ma.masked, ma.masked, ma.masked]
self.left_esrh = [ma.masked, ma.masked, ma.masked]
self.critical_angle = ma.masked
else:
self.srwind = params.bunkers_storm_motion(self, mupcl=self.mupcl, pbot=self.ebottom)
depth = ( self.mupcl.elhght - self.ebotm ) / 2
elh = interp.pres(self, interp.to_msl(self, self.ebotm + depth))
## calculate mean wind
self.mean_eff = winds.mean_wind(self, self.ebottom, self.etop )
self.mean_ebw = winds.mean_wind(self, pbot=self.ebottom, ptop=elh )
## calculate wind shear of the effective layer
self.eff_shear = winds.wind_shear(self, pbot=self.ebottom, ptop=self.etop)
self.ebwd = winds.wind_shear(self, pbot=self.ebottom, ptop=elh)
self.ebwspd = utils.mag( self.ebwd[0], self.ebwd[1] )
## calculate the mean sr wind
self.srw_eff = winds.sr_wind(self, pbot=self.ebottom, ptop=self.etop, stu=self.srwind[0], stv=self.srwind[1] )
self.srw_ebw = winds.sr_wind(self, pbot=self.ebottom, ptop=elh, stu=self.srwind[0], stv=self.srwind[1] )
self.right_esrh = winds.helicity(self, self.ebotm, self.etopm, stu=self.srwind[0], stv=self.srwind[1])
self.left_esrh = winds.helicity(self, self.ebotm, self.etopm, stu=self.srwind[2], stv=self.srwind[3])
self.critical_angle = winds.critical_angle(self, stu=self.srwind[0], stv=self.srwind[1])
## calculate mean srw
self.srw_1km = utils.comp2vec(*winds.sr_wind(self, pbot=sfc, ptop=p1km, stu=self.srwind[0], stv=self.srwind[1] ))
self.srw_3km = utils.comp2vec(*winds.sr_wind(self, pbot=sfc, ptop=p3km, stu=self.srwind[0], stv=self.srwind[1] ))
self.srw_6km = utils.comp2vec(*winds.sr_wind(self, pbot=sfc, ptop=p6km, stu=self.srwind[0], stv=self.srwind[1] ))
self.srw_8km = utils.comp2vec(*winds.sr_wind(self, pbot=sfc, ptop=p8km, stu=self.srwind[0], stv=self.srwind[1] ))
self.srw_4_5km = utils.comp2vec(*winds.sr_wind(self, pbot=p4km, ptop=p5km, stu=self.srwind[0], stv=self.srwind[1] ))
self.srw_lcl_el = utils.comp2vec(*winds.sr_wind(self, pbot=self.mupcl.lclpres, ptop=self.mupcl.elpres, stu=self.srwind[0], stv=self.srwind[1] ))
# This is for the red, blue, and purple bars that appear on the SR Winds vs. Height plot
self.srw_0_2km = winds.sr_wind(self, pbot=sfc, ptop=interp.pres(self, interp.to_msl(self, 2000.)), stu=self.srwind[0], stv=self.srwind[1])
self.srw_4_6km = winds.sr_wind(self, pbot=interp.pres(self, interp.to_msl(self, 4000.)), ptop=p6km, stu=self.srwind[0], stv=self.srwind[1])
self.srw_9_11km = winds.sr_wind(self, pbot=interp.pres(self, interp.to_msl(self, 9000.)), ptop=interp.pres(self, interp.to_msl(self, 11000.)), stu=self.srwind[0], stv=self.srwind[1])
## calculate upshear and downshear
self.upshear_downshear = winds.mbe_vectors(self)
self.srh1km = winds.helicity(self, 0, 1000., stu=self.srwind[0], stv=self.srwind[1])
self.srh3km = winds.helicity(self, 0, 3000., stu=self.srwind[0], stv=self.srwind[1])
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 test_mean_wind():
returned = winds.mean_wind(prof)
correct_u, correct_v = 27.347100616691097, 1.7088123127933754
npt.assert_almost_equal(returned, [correct_u, correct_v])
def test_mean_wind():
returned = winds.mean_wind(prof)
correct_u, correct_v = 27.347100616691097, 1.7088123127933754
npt.assert_almost_equal(returned, [correct_u, correct_v])