def main():
base_path = "/caps2/tsupinie/"
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
ap.add_argument('--fcst', dest='fcst', action='store_true')
args = ap.parse_args()
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400, end=14400)
grid = goshen_1km_grid()
ens_vort = loadEnsemble(data_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'dx', 'dy'], getVortUV), {'z': 1000},
agl=True,
fcst=args.fcst)
print ens_vort.shape
fcst_str = ""
if args.fcst: fcst_str = "_fcst"
cPickle.dump(
ens_vort,
open("vort_pkl/vorticity%s_%s.pkl" % (fcst_str, exp_name), 'w'), -1)
return
def main():
np.seterr(all='ignore')
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400)
grid = goshen_1km_grid()
ens_bvg = loadEnsemble(
data_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'pt', 'p', 'qv', 'qc', 'qi', 'qr', 'qs', 'qh', 'x', 'y'
], computeBaroclinicVortGen), {'z': 500},
agl=True)
cPickle.dump(ens_bvg, open("vort_gen_baroc_mean_%s.pkl" % exp_name, 'w'),
-1)
return
def main():
bounds = (slice(100, 180), slice(90, 170))
exp_base = "/caps2/tsupinie/"
exp_name = "1kmf-r0h=6km-bc7dBZ,5ms"
height = 2000
exp_tag = "-".join(exp_name.split("-")[1:])
n_ens_members = 40
grid = goshen_1km_grid(bounds=bounds)
temp = goshen_1km_temporal(start=14400)
# proj = setupMapProjection(goshen_1km_proj, goshen_1km_gs, bounds)
# map = Basemap(**proj)
# fcst_files = glob.glob("%s/%s/ena???.hdf014400" % (exp_base, exp_name))
# fcst_files.extend(glob.glob("%s/1km-control-%s/ena???.hdf01[5678]*" % (exp_base, exp_name)))
# vort, ens_members, times = loadAndInterpolateEnsemble(fcst_files, ['u', 'v', 'dx', 'dy'], getVorticity, "%s/%s/ena001.hdfgrdbas" % exp_base, exp_name, { 'z':height })
vort = loadEnsemble("%s/%s" % (exp_base, exp_name),
n_ens_members,
temp.getTimes(),
(['u', 'v', 'p', 'pt', 'z', 'dx', 'dy'], getVorticity),
{'z': height},
agl=True)
cms = ClickMaxState("%s-%dm" % (exp_tag, height), vort, n_ens_members,
temp, grid)
# pylab.plot(np.random.random_sample(10), np.random.random_sample(10), 'ko')
# pylab.xlim(0, 1)
# pylab.ylim(0, 1)
return
def compileDeviations():
experiments = [
'1kmf-sndr0h=25km', '1kmf-zs25-no-05XP', '1kmf-zs25-no-mm-05XP',
'1kmf-zs25-no-mm', '1kmf-z-no-snd', '1kmf-z-no-v2'
]
temp = goshen_1km_temporal(start=14400, end=14400)
deviations = []
for exp in experiments:
exp_dev = []
for t_ens in temp:
exp_dev.append(
cPickle.load(
open("closest/ens_dev_%s_%d.pkl" % (exp, t_ens), 'r')))
deviations.append(np.array(exp_dev, dtype=exp_dev[0].dtype))
deviations = np.array(deviations, dtype=deviations[0].dtype)
print deviations.shape
deviations = np.array([
sum(deviations[idx]) / len(deviations[idx])
for idx in np.ndindex(deviations.shape)
]).reshape(deviations.shape).mean(axis=1)
min_ens_member = np.argmin(deviations, axis=1)
for exp, min_ens in zip(experiments, min_ens_member + 1):
print "Closest ensemble member for %s: %d" % (exp, min_ens)
return
def main():
temp = goshen_1km_temporal(start=14400) #start=10800, end=14400)
grid = goshen_1km_grid() #bounds=(slice(242, 327), slice(199, 284)))
bounds = grid.getBounds()
ubounds = {'u': 10, 'v': 10, 't': 3, 'qv': 0.0035}
base_path = "/caps2/tsupinie/"
exp_name = "1kmf-mult=1.03"
exp_path = "%s%s" % (base_path, exp_name)
n_ens_members = 40
ens = loadEnsemble(exp_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'pt', 'p', 'qv'], computeSfc),
points={'sigma': 2},
agl=True) #, fcst=True)
for wdt, (time, time_str) in enumerate(
zip(temp, temp.getStrings("%d %B %Y %H%M UTC"))):
try:
mo = ARPSModelObsFile("%s/KCYSan%06d" % (exp_path, time))
except AssertionError:
mo = ARPSModelObsFile("%s/KCYSan%06d" % (exp_path, time),
mpi_config=(2, 12))
for field in ens.dtype.fields.iterkeys():
std = ens[field][:, wdt, ...].std(axis=0, ddof=1)
plotSpread(std,
grid,
ubounds[field],
"Spread in %s at %s" % (field, time_str),
"spread_%s_%s_%06d.png" % (field, exp_name, time),
refl=mo['Z'][0])
return
def main():
base_path = "/caps2/tsupinie/1kmf-control/"
temp = goshen_1km_temporal(start=14400, end=14400)
grid = goshen_1km_grid()
n_ens_members = 40
np.seterr(all='ignore')
ens = loadEnsemble(base_path, [ 11 ], temp.getTimes(), ([ 'pt', 'p' ], computeDensity))
ens = ens[0, 0]
zs = decompressVariable(nio.open_file("%s/ena001.hdfgrdbas" % base_path, mode='r', format='hdf').variables['zp'])
xs, ys = grid.getXY()
xs = xs[np.newaxis, ...].repeat(zs.shape[0], axis=0)
ys = ys[np.newaxis, ...].repeat(zs.shape[0], axis=0)
eff_buoy = effectiveBuoyancy(ens, (zs, ys, xs), plane={'z':10})
print eff_buoy
pylab.figure()
pylab.contourf(xs[0], ys[0], eff_buoy[0], cmap=matplotlib.cm.get_cmap('RdBu_r'))
pylab.colorbar()
grid.drawPolitical()
pylab.suptitle("Effective Buoyancy")
pylab.savefig("eff_buoy.png")
pylab.close()
return
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400)
grid = goshen_1km_grid()
ens_vg = loadEnsemble(data_path, n_ens_members, temp.getTimes(), (['u', 'v', 'w', 'x', 'y', 'z'], getVGTandUV), {'z':500}, agl=True, buffer=True)
ens_vort = compute3DVorticity(vg_tensor=ens_vg)
z_stretching = ens_vort['zvort'] * ens_vg['dwdz']
y_stretching = ens_vort['yvort'] * ens_vg['dvdy']
x_stretching = ens_vort['xvort'] * ens_vg['dudx']
horiz_tilting = ens_vort['yvort'] * ens_vg['dwdy'] + ens_vort['xvort'] * ens_vg['dwdx']
horiz_stretching = (ens_vg['u'] * x_stretching + ens_vg['v'] * y_stretching) / np.hypot(ens_vg['u'], ens_vg['v'])
cPickle.dump((z_stretching, horiz_tilting, horiz_stretching, ens_vg['u'].mean(axis=0), ens_vg['v'].mean(axis=0)), open("vort_gen_mean_%s.pkl" % exp_name, 'w'), -1)
return
def main():
temp = goshen_1km_temporal(start=14400)
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM'), ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
refl_thresh = [ 25, 45 ]
all_AUCs = []
for thresh in refl_thresh:
rocs = []
for exp in experiments.iterkeys():
pkl_name = "roc_pkl/%s_%02ddBZ_roc.pkl" % (exp, thresh)
roc = cPickle.load(open(pkl_name, 'r'))
rocs.append(roc)
rocs = zip(*rocs)
AUCs = []
for time, roc_group in zip(temp, rocs):
AUC = [ computeAUC(r[0]) for r in roc_group ]
AUCs.append(AUC)
all_AUCs.append(AUCs)
all_AUCs = [ zip(*a) for a in all_AUCs ]
def subplotFactory(AUC_group, thresh):
colors = dict(zip(experiments.iterkeys(), ['k', 'r', 'g', 'b', 'c', 'm']))
def doSubplot(multiplier=1.0, layout=(-1, -1)):
for idx, (exp, exp_name) in enumerate(experiments.iteritems()):
pylab.plot(temp.getTimes(), AUC_group[idx], label=exp_name, color=colors[exp])
pylab.axhline(y=0.5, color='k', linestyle=':')
n_row, n_col = layout
if n_row == 2:
pylab.xlabel("Time (UTC)", size='large')
pylab.xlim(temp.getTimes()[0], temp.getTimes()[-1])
pylab.xticks(temp.getTimes(), temp.getStrings("%H%M", aslist=True), rotation=30, size='x-large')
pylab.legend(loc=3)
else:
pylab.xlim(temp.getTimes()[0], temp.getTimes()[-1])
pylab.xticks(temp.getTimes(), [ "" for t in temp ])
pylab.ylabel(r"AUC (Reflectivity $\geq$ %d dBZ)" % thresh, size='large')
pylab.ylim(0.4, 1.0)
pylab.yticks(size='x-large')
return
return doSubplot
subplots = []
for AUC_group, thresh in zip(all_AUCs, refl_thresh):
subplots.append(subplotFactory(AUC_group, thresh))
pylab.figure(figsize=(8, 9.5))
pylab.subplots_adjust(left=0.1, right=0.95, top=0.95, bottom=0.1, hspace=0.05)
publicationFigure(subplots, (2, 1), corner='ur')
pylab.savefig("roc_AUC.png")
pylab.close()
return
def main():
base_path = "/caps2/tsupinie/"
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400, end=18000)
grid = goshen_1km_grid()
# Sounding loc: [164124.50758138258, 92544.16037613325]
y_snd, x_snd = grid.getXY(164, 103)
print x_snd, y_snd
ens_hodo = loadEnsemble(data_path, n_ens_members, temp.getTimes(),
(['u', 'v'], vectorTuple), {
'x': x_snd,
'y': y_snd
})
cPickle.dump(ens_hodo, open("hodo_pkl/%s_hodo.pkl" % exp_name, 'w'), -1)
return
def main():
bounds = (slice(100, 180), slice(90, 170))
exp_base = "/caps2/tsupinie/"
exp_name = "1kmf-r0h=6km-bc7dBZ,5ms"
height = 2000
exp_tag = "-".join(exp_name.split("-")[1:])
n_ens_members = 40
grid = goshen_1km_grid(bounds=bounds)
temp = goshen_1km_temporal(start=14400)
# proj = setupMapProjection(goshen_1km_proj, goshen_1km_gs, bounds)
# map = Basemap(**proj)
# fcst_files = glob.glob("%s/%s/ena???.hdf014400" % (exp_base, exp_name))
# fcst_files.extend(glob.glob("%s/1km-control-%s/ena???.hdf01[5678]*" % (exp_base, exp_name)))
# vort, ens_members, times = loadAndInterpolateEnsemble(fcst_files, ['u', 'v', 'dx', 'dy'], getVorticity, "%s/%s/ena001.hdfgrdbas" % exp_base, exp_name, { 'z':height })
vort = loadEnsemble("%s/%s" % (exp_base, exp_name), n_ens_members, temp.getTimes(), (['u', 'v', 'p', 'pt', 'z', 'dx', 'dy'], getVorticity), { 'z':height }, agl=True)
cms = ClickMaxState("%s-%dm" % (exp_tag, height), vort, n_ens_members, temp, grid)
# pylab.plot(np.random.random_sample(10), np.random.random_sample(10), 'ko')
# pylab.xlim(0, 1)
# pylab.ylim(0, 1)
return
def main():
experiments = [ '1kmf-sndr0h=50km', '1kmf-zs-no-05XP', '1kmf-zs-no-mm-05XP', '1kmf-zs-no-mm', '1kmf-z-no-snd', '1kmf-z-no-v2' ]
grid = goshen_1km_grid(bounds=(slice(100, 180), slice(90, 170)))
temp = goshen_1km_temporal(start=14400)
obs_file_names = ['psu_straka_mesonet.pkl', 'ttu_sticknet.pkl', 'asos.pkl']
all_obs = loadObs(obs_file_names, temp.getDatetimes(aslist=True), grid, grid.getWidthHeight())
ens_obs = {}
for exp in experiments:
ens_obs[exp] = cPickle.load(open("cold_pool_obs_%s.pkl" % exp, 'r'))
mm_ids = np.unique1d(all_obs['id'])
for id in mm_ids:
id_idxs = np.where(all_obs['id'] == id)
for ob_var, ens_var in [('temp', 't'), ('dewp', 'td')]:
pylab.figure()
pylab.plot(all_obs['time'][id_idxs], 5 / 9. * (all_obs[ob_var][id_idxs] - 32), 'k-', label='Observed')
for exp_name, exp in ens_obs.iteritems():
pylab.plot(all_obs['time'][id_idxs], exp[ens_var][id_idxs] - 273.15, label=exp_name)
pylab.xticks(temp.getEpochs(aslist=True), temp.getStrings("%H%M", aslist=True), rotation=30)
pylab.xlim(temp.getEpochs(aslist=True)[0], temp.getEpochs(aslist=True)[-1])
pylab.legend(loc=1)
pylab.savefig("mm_timeseries_%s_%s.png" % (ens_var, id))
pylab.close()
return
def main():
base_path = "/caps2/tsupinie/"
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM'), ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
domain_bounds = (slice(110, 135), slice(118, 143))
grid = goshen_1km_grid(bounds=domain_bounds)
domain_bounds = grid.getBounds()
temp = goshen_1km_temporal(start=14400, end=14400)
xs, ys = grid.getXY()
levels = np.arange(-0.030, 0.033, 0.003)
exp_vort = []
exp_refl = []
for exp in experiments.iterkeys():
vort = cPickle.load(open("vort_pkl/vorticity_%s.pkl" % exp, 'r'))
refl = []
for time_sec in temp:
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp, time_sec), mpi_config=(2, 12))
except:
mo = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
refl.append(mo)
exp_refl.append(np.array(refl))
def subplotFactory(exp, exp_vort, exp_refl):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
pylab.quiver(xs, ys, exp_vort['u'].mean(axis=0)[domain_bounds], exp_vort['v'].mean(axis=0)[domain_bounds])
pylab.contour(xs, ys, exp_refl['Z'][0][domain_bounds], colors='#666666', levels=np.arange(20, 80, 20))
pylab.contour(xs, ys, exp_vort['vort'].mean(axis=0)[domain_bounds], colors='k', linestyles='--', linewidths=1.5, levels=[ 0.015 ])
pylab.contour(xs, ys, exp_vort['vort'].max(axis=0)[domain_bounds], colors='k', linestyles='-', linewidths=1.5, levels=[ 0.015 ])
pylab.contourf(xs, ys, exp_vort['vort'].mean(axis=0)[domain_bounds], cmap=matplotlib.cm.get_cmap('RdBu_r'), levels=levels, zorder=-10)
grid.drawPolitical()
pylab.text(0.05, 0.95, experiments[exp], ha='left', va='top', transform=pylab.gca().transAxes, size=14 * multiplier)
return
return doSubplot
for wdt, time_sec in enumerate(temp):
print time_sec
subplots = []
for exp_name, vort, refl in zip(experiments.iterkeys(), exp_vort, exp_refl):
print vort.shape
subplots.append(subplotFactory(exp_name, vort[:, wdt], refl[wdt]))
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
publicationFigure(subplots, (2, 3), corner='ur', colorbar=(r'Vorticity ($\times$ 10$^3$ s$^{-1}$)', "%d", levels, np.round(1000 * levels)))
pylab.savefig("vorticity_%d.png" % time_sec)
return
def main():
base_path = "/caps2/tsupinie/"
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
n_ens_members = 40
exp_name = args.exp_name
bounds_obs = (slice(100, 180), slice(90, 170))
grid_obs = goshen_1km_grid(bounds=bounds_obs)
bounds = (slice(None), slice(None))
grid = goshen_1km_grid(bounds=bounds)
temp = goshen_1km_temporal(start=14400)
obs_file_names = ['psu_straka_mesonet.pkl', 'ttu_sticknet.pkl', 'asos.pkl']
all_obs = loadObs(obs_file_names, temp.getDatetimes(aslist=True), grid_obs, grid_obs.getWidthHeight())
obs_xy = np.vstack(grid(all_obs['longitude'], all_obs['latitude'])).T
ens = loadEnsemble("/caps2/tsupinie/%s/" % exp_name, n_ens_members, temp.getTimes(), (['u', 'v', 'pt', 'p', 'qv'], getTempDewpRefl), {'sigma':2}, agl=True, wrap=True)
grid_xs, grid_ys = grid.getXY()
obs_t_verif = []
for wdt, (time_sec, time_epoch) in enumerate(zip(temp, temp.getEpochs())):
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp_name, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp_name, time_sec), mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
time_ob_idxs = np.where(all_obs['nom_time'] == time_epoch)[0]
time_obs = all_obs[time_ob_idxs]
time_obs_xy = obs_xy[time_ob_idxs]
obs_intrp = griddata(time_obs_xy, 5. / 9. * (time_obs['temp'] - 32) + 273.15, (grid_xs, grid_ys))
print np.isfinite(obs_intrp).sum()
pylab.figure()
pylab.contourf(grid_xs, grid_ys, ens['t'][:, wdt].mean(axis=0)[bounds] - obs_intrp, levels=np.arange(-6, 6.5, 0.5), cmap=matplotlib.cm.get_cmap("RdBu_r"))
pylab.colorbar()
pylab.contour(grid_xs, grid_ys, mo['Z'][0][tuple(reversed(bounds))], levels=np.arange(10, 80, 10), colors='k')
grid.drawPolitical()
pylab.savefig("obs_verif/obs_%s_t_grid_%06d.png" % (exp_name[5:], time_sec))
pylab.close()
obs_t_verif.append(ens['t'][:, wdt].mean(axis=0) - obs_intrp)
cPickle.dump(np.array(obs_t_verif), open("obs_verif/obs_verif_%s.pkl" % exp_name, 'w'), -1)
return
def main():
base_path = "/caps2/tsupinie/"
radars = [ 'KCYS' ] #, 'KFTG, '05XP' ]
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM'), ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
temp = goshen_1km_temporal()
for rad in radars:
radar_params = {}
for exp, name in experiments.iteritems():
radar_params[exp] = loadRadar("%s/%s" % (base_path, exp), rad, temp)
plotRadar(radar_params, temp, experiments, 'Z', "obs_space_%s.png" % rad)
return
def main():
experiments = [
'1kmf-sndr0h=50km', '1kmf-zs-no-05XP', '1kmf-zs-no-mm-05XP',
'1kmf-zs-no-mm', '1kmf-z-no-snd', '1kmf-z-no-v2'
]
grid = goshen_1km_grid(bounds=(slice(100, 180), slice(90, 170)))
temp = goshen_1km_temporal(start=14400)
obs_file_names = ['psu_straka_mesonet.pkl', 'ttu_sticknet.pkl', 'asos.pkl']
all_obs = loadObs(obs_file_names, temp.getDatetimes(aslist=True), grid,
grid.getWidthHeight())
ens_obs = {}
for exp in experiments:
ens_obs[exp] = cPickle.load(open("cold_pool_obs_%s.pkl" % exp, 'r'))
mm_ids = np.unique1d(all_obs['id'])
for id in mm_ids:
id_idxs = np.where(all_obs['id'] == id)
for ob_var, ens_var in [('temp', 't'), ('dewp', 'td')]:
pylab.figure()
pylab.plot(all_obs['time'][id_idxs],
5 / 9. * (all_obs[ob_var][id_idxs] - 32),
'k-',
label='Observed')
for exp_name, exp in ens_obs.iteritems():
pylab.plot(all_obs['time'][id_idxs],
exp[ens_var][id_idxs] - 273.15,
label=exp_name)
pylab.xticks(temp.getEpochs(aslist=True),
temp.getStrings("%H%M", aslist=True),
rotation=30)
pylab.xlim(
temp.getEpochs(aslist=True)[0],
temp.getEpochs(aslist=True)[-1])
pylab.legend(loc=1)
pylab.savefig("mm_timeseries_%s_%s.png" % (ens_var, id))
pylab.close()
return
def main():
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM')]) #, ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
domain_bounds = (slice(115, 165), slice(105, 155))
grid = goshen_1km_grid(bounds=domain_bounds)
domain_bounds = grid.getBounds()
temporal = goshen_1km_temporal(start=14400)
tornado_track = zip(*((41.63, -104.383), (41.6134, -104.224)))
track_xs, track_ys = grid(*[ np.array(list(t)) for t in reversed(tornado_track) ])
def subplotFactory(exp):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
data = cPickle.load(open("updraft_hel/NEPcirc_UH0-3_75m2s2_%s.pkl" % exp, 'r'))
cmap = matplotlib.cm.get_cmap('RdYlBu_r')
cmap.set_under('#ffffff')
xs, ys = grid.getXY()
pylab.pcolormesh(xs, ys, data[domain_bounds], cmap=cmap, vmin=0.1, vmax=1.0)
grid.drawPolitical(scale_len=10)
pylab.plot(track_xs, track_ys, 'mv-', lw=2.5, mfc='k', ms=8)
pylab.text(0.05, 0.95, experiments[exp], ha='left', va='top', transform=pylab.gca().transAxes, size=18 * multiplier)
return
return doSubplot
subplots = []
for exp in experiments.iterkeys():
subplots.append(subplotFactory(exp))
# pylab.figure(figsize=(12, 8))
pylab.figure(figsize=(8.5, 8))
pylab.subplots_adjust(left=0.025, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
publicationFigure(subplots, (2, 2), corner='ur')
cax = pylab.axes((0.90, 0.1125, 0.020, 0.825))
bar = pylab.colorbar(cax=cax)
bar.ax.text(3.5, 0.5, r"Probability of UH $\geq$ 75 m$^2$ s$^{-2}$", rotation=90, transform=bar.ax.transAxes, size='large', va='center')
bar.ax.tick_params(labelsize='large')
pylab.savefig("UH0-3_75m2s2_four.png")
return
def main():
base_path = "/caps2/tsupinie/1kmf-control/"
temp = goshen_1km_temporal(start=14400, end=14400)
grid = goshen_1km_grid()
n_ens_members = 40
x_snd, y_snd = grid.getXY(115, 115)
ens_anal = loadEnsemble(base_path, n_ens_members, temp.getTimes(), (['u', 'v', 'pt', 'p', 'qv'], getSndParams), {'x':x_snd, 'y':y_snd}, fcst=False)
ens_fcst = loadEnsemble(base_path, n_ens_members, temp.getTimes(), (['u', 'v', 'pt', 'p', 'qv'], getSndParams), {'x':x_snd, 'y':y_snd}, fcst=True)
robs = RadarObsFile("qc/1km/KCYS.20090605.220000")
grdbas = nio.open_file("%s/ena001.hdfgrdbas" % base_path, mode='r', format='hdf')
weights = computeInflWeights(grdbas.variables['zp'], robs.heights, grid, robs['Z'] > 20., 6000, 0)
ens_mean = np.empty(ens_anal.shape[1:], dtype=ens_anal.dtype)
ens_preinfl = np.empty(ens_anal.shape, dtype=ens_anal.dtype)
for field in ens_anal.dtype.fields.iterkeys():
ens_mean[field] = ens_anal[field].mean(axis=0)
ens_preinfl[field] = undoAdaptiveInfl(ens_fcst[field], ens_anal[field], 0.9)
for wdt, (t_ens, time_str) in enumerate(zip(temp, temp.getStrings("%d %B %Y %H%M UTC"))):
pylab.figure(figsize=(8, 10))
plotSkewTBackground(pylab.gca())
for n_ens in xrange(n_ens_members):
pres_profile = ens_preinfl['p'][n_ens, wdt]
temp_profile = theta2Temperature(pt=ens_preinfl['pt'][n_ens, wdt], p=ens_preinfl['p'][n_ens, wdt])
dewp_profile = qv2Dewpoint(qv=ens_preinfl['qv'][n_ens, wdt], p=ens_preinfl['p'][n_ens, wdt])
if np.any(temp_profile < dewp_profile):
print "Dewpoint greater than temperature at t=%06d, n=%03d" % (t_ens, n_ens + 1), np.where(temp_profile < dewp_profile)
plotProfile(temp_profile - 273.15, pres_profile / 100., color='r', linewidth=0.5)
plotProfile(dewp_profile - 273.15, pres_profile / 100., color='g', linewidth=0.5)
mean_pres_profile = ens_mean['p'][wdt]
mean_temp_profile = theta2Temperature(pt=ens_mean['pt'][wdt], p=ens_mean['p'][wdt])
mean_dewp_profile = qv2Dewpoint(qv=ens_mean['qv'][wdt], p=ens_mean['p'][wdt])
plotProfile(mean_temp_profile - 273.15, mean_pres_profile / 100., color='k', linewidth=1.5)
plotProfile(mean_dewp_profile - 273.15, mean_pres_profile / 100., color='k', linewidth=1.5)
pylab.suptitle("Ensemble Soundings at %s" % time_str)
pylab.savefig("fcst_snd_1kmf-control_preinfl_%06d.png" % t_ens)
return
def compileDeviations():
experiments = ['1kmf-sndr0h=25km', '1kmf-zs25-no-05XP', '1kmf-zs25-no-mm-05XP', '1kmf-zs25-no-mm', '1kmf-z-no-snd', '1kmf-z-no-v2']
temp = goshen_1km_temporal(start=14400, end=14400)
deviations = []
for exp in experiments:
exp_dev = []
for t_ens in temp:
exp_dev.append(cPickle.load(open("closest/ens_dev_%s_%d.pkl" % (exp, t_ens), 'r')))
deviations.append(np.array(exp_dev, dtype=exp_dev[0].dtype))
deviations = np.array(deviations, dtype=deviations[0].dtype)
print deviations.shape
deviations = np.array([ sum(deviations[idx]) / len(deviations[idx]) for idx in np.ndindex(deviations.shape) ]).reshape(deviations.shape).mean(axis=1)
min_ens_member = np.argmin(deviations, axis=1)
for exp, min_ens in zip(experiments, min_ens_member + 1):
print "Closest ensemble member for %s: %d" % (exp, min_ens)
return
def main():
np.seterr(all='ignore')
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400)
grid = goshen_1km_grid()
ens_bvg = loadEnsemble(data_path, n_ens_members, temp.getTimes(), (['u', 'v', 'pt', 'p', 'qv', 'qc', 'qi', 'qr', 'qs', 'qh', 'x', 'y'], computeBaroclinicVortGen), {'z':500}, agl=True)
cPickle.dump(ens_bvg, open("vort_gen_baroc_mean_%s.pkl" % exp_name, 'w'), -1)
return
def main():
base_path = "/caps2/tsupinie/"
radars = ['KCYS'] #, 'KFTG, '05XP' ]
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'),
('1kmf-zs25-no-05XP', 'NO_MWR'),
('1kmf-z-no-snd', 'NO_SND'),
('1kmf-zs25-no-mm', 'NO_MM'),
('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'),
('1kmf-z-no-v2', 'NO_V2')])
temp = goshen_1km_temporal()
for rad in radars:
radar_params = {}
for exp, name in experiments.iteritems():
radar_params[exp] = loadRadar("%s/%s" % (base_path, exp), rad,
temp)
plotRadar(radar_params, temp, experiments, 'Z',
"obs_space_%s.png" % rad)
return
def createDeviations(args):
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=args.ens_time, end=args.ens_time)
grid = goshen_1km_grid()
ens = loadEnsemble(data_path, n_ens_members, temp.getTimes(), ([ 'u', 'v', 'pt' ], toRecArray))
ens_dev = np.empty(ens.shape[:1], dtype=ens.dtype)
for field in ens.dtype.fields.iterkeys():
ens_mean = ens[field].mean(axis=0)
print field
for lde in range(ens.shape[0]):
mem_dev = np.sqrt(np.mean((ens[field][lde] - ens_mean) ** 2)) / np.std(ens_mean, ddof=1)
cPickle.dump(ens_dev, open("closest/ens_dev_%s.pkl" % exp_name, 'w'), -1)
return
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
bounds = (slice(90, 170), slice(100, 180))
base_path = "/caps2/tsupinie/1kmf-%s" % args.exp_name
temp = goshen_1km_temporal(start=14400)
n_ens_members = 40
# files = glob.glob("%s/ena???.hdf014[47]00" % base_path)
# files.extend(glob.glob("%s/ena???.hdf01[5678]?00" % base_path))
# files = glob.glob("%s/ena???.hdf01[0123]*" % base_path)
# files.extend(glob.glob("%s/ena???.hdf014100" % base_path))
ens_vort = loadEnsemble(base_path, n_ens_members, temp.getTimes(),
(['u', 'v', 'dx', 'dy'], computeVorticity))
# ens_vort = loadEnsemble(base_path, n_ens_members, temp.getTimes(), (['w'], lambda **k: k['w']))
full_bounds = [slice(None)] * 3
full_bounds.extend(bounds)
print ens_vort.shape
# time_height = (ens_vort[full_bounds].max(axis=-1).max(axis=-1) >= 0.015).sum(axis=0) / float(ens_vort.shape[0])
time_height = ens_vort[full_bounds].max(axis=-1).max(axis=-1).mean(axis=0)
print time_height.shape
cPickle.dump(time_height,
open("vort_time_height_%s.pkl" % args.exp_name, 'w'), -1)
plotTimeHeight(time_height, temp.getTimes(),
r"Time-Height plot of maximum $\zeta$",
"vort_time_height_%s.png" % args.exp_name)
return
def main():
temp = goshen_1km_temporal(start=14400) #start=10800, end=14400)
grid = goshen_1km_grid() #bounds=(slice(242, 327), slice(199, 284)))
bounds = grid.getBounds()
ubounds = {'u':10, 'v':10, 't':3, 'qv':0.0035}
base_path = "/caps2/tsupinie/"
exp_name = "1kmf-mult=1.03"
exp_path = "%s%s" % (base_path, exp_name)
n_ens_members = 40
ens = loadEnsemble(exp_path, n_ens_members, temp.getTimes(), (['u', 'v', 'pt', 'p', 'qv'], computeSfc), points={'sigma':2}, agl=True) #, fcst=True)
for wdt, (time, time_str) in enumerate(zip(temp, temp.getStrings("%d %B %Y %H%M UTC"))):
try:
mo = ARPSModelObsFile("%s/KCYSan%06d" % (exp_path, time))
except AssertionError:
mo = ARPSModelObsFile("%s/KCYSan%06d" % (exp_path, time), mpi_config=(2, 12))
for field in ens.dtype.fields.iterkeys():
std = ens[field][:, wdt, ...].std(axis=0, ddof=1)
plotSpread(std, grid, ubounds[field], "Spread in %s at %s" % (field, time_str), "spread_%s_%s_%06d.png" % (field, exp_name, time), refl=mo['Z'][0])
return
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400)
grid = goshen_1km_grid()
ens_vg = loadEnsemble(data_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'w', 'x', 'y', 'z'], getVGTandUV),
{'z': 500},
agl=True,
buffer=True)
ens_vort = compute3DVorticity(vg_tensor=ens_vg)
z_stretching = ens_vort['zvort'] * ens_vg['dwdz']
y_stretching = ens_vort['yvort'] * ens_vg['dvdy']
x_stretching = ens_vort['xvort'] * ens_vg['dudx']
horiz_tilting = ens_vort['yvort'] * ens_vg['dwdy'] + ens_vort[
'xvort'] * ens_vg['dwdx']
horiz_stretching = (ens_vg['u'] * x_stretching + ens_vg['v'] *
y_stretching) / np.hypot(ens_vg['u'], ens_vg['v'])
cPickle.dump((z_stretching, horiz_tilting, horiz_stretching,
ens_vg['u'].mean(axis=0), ens_vg['v'].mean(axis=0)),
open("vort_gen_mean_%s.pkl" % exp_name, 'w'), -1)
return
def main():
refl_threshold = 20
vel_threshold = 20
confusion_refl = cPickle.load(open("all_confusion_1km_%ddBZ.pkl" % (refl_threshold)))
confusion_vel = cPickle.load(open("all_confusion_1km_%dms.pkl" % (vel_threshold)))
missing_data = -1
fa_value = 1
miss_value = 2
grid = goshen_1km_grid()
temp = goshen_1km_temporal(start=14400)
bbox_files = glob.glob("bbox*.pkl")
bbox_buffer = 10
bbox_offsets = [0, 10, 0]
bboxes = {}
for bfile in bbox_files:
root, ext = bfile.split(".")
bits = root.split("_")
key = "1kmf-%s" % bits[-1]
bboxes[key] = cPickle.load(open(bfile, 'r'))
bboxes[key] = (slice(0, 14),) + tuple( slice(b.start - bbox_buffer + o, b.stop + bbox_buffer + o) for b, o in zip(bboxes[key][1:], bbox_offsets[1:]) )
misses = dict( (e, [ (c[bboxes[e]] == miss_value).sum() / float((c[bboxes[e]] != missing_data).sum()) for c in r['KCYS'] ]) for e, r in confusion_refl.iteritems() )
false_alarms = dict( (e, [ (c[bboxes[e]] == fa_value).sum() / float((c[bboxes[e]] != missing_data).sum()) for c in r['KCYS'] ]) for e, r in confusion_refl.iteritems() )
plotGraph(temp, misses, "Misses", "all_misses_%ddBZ_thd0.5.png" % refl_threshold)
plotGraph(temp, false_alarms, "False Alarms", "all_false_alarms_%ddBZ_thd0.5.png" % refl_threshold)
for exp, r_confusion in confusion_refl.iteritems():
for confusion, time_sec, time_str in zip(r_confusion['KCYS'], temp.getTimes(), temp.getStrings('%H%M')):
plotConfusion(confusion[0], grid, "Contingency Plot for KCYS at %s" % time_str, "confusion_KCYS_%s_tilt00_%06d.png" % (exp, time_sec), inset=bboxes[exp][1:])
return
def main():
base_path = "/caps2/tsupinie/1kmf-control/"
temp = goshen_1km_temporal(start=14400, end=14400)
grid = goshen_1km_grid()
n_ens_members = 40
np.seterr(all='ignore')
ens = loadEnsemble(base_path, [11], temp.getTimes(),
(['pt', 'p'], computeDensity))
ens = ens[0, 0]
zs = decompressVariable(
nio.open_file("%s/ena001.hdfgrdbas" % base_path,
mode='r',
format='hdf').variables['zp'])
xs, ys = grid.getXY()
xs = xs[np.newaxis, ...].repeat(zs.shape[0], axis=0)
ys = ys[np.newaxis, ...].repeat(zs.shape[0], axis=0)
eff_buoy = effectiveBuoyancy(ens, (zs, ys, xs), plane={'z': 10})
print eff_buoy
pylab.figure()
pylab.contourf(xs[0],
ys[0],
eff_buoy[0],
cmap=matplotlib.cm.get_cmap('RdBu_r'))
pylab.colorbar()
grid.drawPolitical()
pylab.suptitle("Effective Buoyancy")
pylab.savefig("eff_buoy.png")
pylab.close()
return
def main():
base_path = "/caps2/tsupinie/"
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=14400, end=18000)
grid = goshen_1km_grid()
# Sounding loc: [164124.50758138258, 92544.16037613325]
y_snd, x_snd = grid.getXY(164, 103)
print x_snd, y_snd
ens_hodo = loadEnsemble(data_path, n_ens_members, temp.getTimes(), (['u', 'v'], vectorTuple), {'x':x_snd, 'y':y_snd})
cPickle.dump(ens_hodo, open("hodo_pkl/%s_hodo.pkl" % exp_name, 'w'), -1)
return
def createDeviations(args):
np.seterr(all='ignore')
exp_name = args.exp_name
base_path = "/caps2/tsupinie/"
data_path = "%s/%s/" % (base_path, exp_name)
n_ens_members = 40
temp = goshen_1km_temporal(start=args.ens_time, end=args.ens_time)
grid = goshen_1km_grid()
ens = loadEnsemble(data_path, n_ens_members, temp.getTimes(),
(['u', 'v', 'pt'], toRecArray))
ens_dev = np.empty(ens.shape[:1], dtype=ens.dtype)
for field in ens.dtype.fields.iterkeys():
ens_mean = ens[field].mean(axis=0)
print field
for lde in range(ens.shape[0]):
mem_dev = np.sqrt(np.mean(
(ens[field][lde] - ens_mean)**2)) / np.std(ens_mean, ddof=1)
cPickle.dump(ens_dev, open("closest/ens_dev_%s.pkl" % exp_name, 'w'), -1)
return
def main():
base_path = "/caps2/tsupinie/"
exp_names = { '1kmf-sndr0h=25km':"CTRL", '1kmf-zs25-no-05XP':"NO_MWR", '1kmf-zs25-no-mm-05XP':"NO_MWR_MM", '1kmf-zs25-no-mm':"NO_MM", '1kmf-z-no-snd':"NO_SND", '1kmf-z-no-v2':"NO_V2" }
experiments = [ '1kmf-sndr0h=25km', '1kmf-zs25-no-05XP', '1kmf-z-no-snd', '1kmf-zs25-no-mm' ] #, '1kmf-zs25-no-mm-05XP', '1kmf-z-no-v2']
min_ens_members = [ 17, 31, 31, 31 ] #, 36, 1 ]
bounds_1sthalf = (slice(105, 160), slice(105, 160))
bounds_2ndhalf = (slice(130, 185), slice(105, 160))
grid_1 = goshen_1km_grid(bounds=bounds_1sthalf)
grid_2 = goshen_1km_grid(bounds=bounds_2ndhalf)
bounds_1sthalf = grid_1.getBounds()
bounds_2ndhalf = grid_2.getBounds()
xs_1, ys_1 = grid_1.getXY()
xs_2, ys_2 = grid_2.getXY()
thin_factor = 2
thin = tuple([slice(None, None, thin_factor)] * 2)
temp = goshen_1km_temporal(start=14400)
wind = {}
for exp, min_ens in zip(experiments, min_ens_members):
wind[exp] = loadEnsemble("%s%s" % (base_path, exp), [ min_ens ], temp.getTimes(), (['u', 'v', 'w'], toRecArray), {'z':1000}, agl=True)[0]
def modelSubplotFactory(exp, min_ens, time_sec):
wdt = temp.getTimes().index(time_sec)
def doSubplot(multiplier=1.0, layout=(-1, -1)):
if time_sec < 16200:
xs, ys = xs_1, ys_1
domain_bounds = bounds_1sthalf
grid = grid_1
else:
xs, ys = xs_2, ys_2
domain_bounds = bounds_2ndhalf
grid = grid_2
try:
mo = ARPSModelObsFile("%s/%s/KCYS%03dan%06d" % (base_path, exp, min_ens, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYS%03dan%06d" % (base_path, exp, min_ens, time_sec), mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
pylab.contour(xs, ys, wind[exp]['w'][wdt][domain_bounds], levels=np.arange(2, 102, 2), styles='-', colors='k')
pylab.contour(xs, ys, wind[exp]['w'][wdt][domain_bounds], levels=np.arange(-100, 0, 2), styles='--', colors='k')
pylab.quiver(xs[thin], ys[thin], wind[exp]['u'][wdt][domain_bounds][thin], wind[exp]['v'][wdt][domain_bounds][thin])
pylab.contourf(xs, ys, mo['Z'][0][domain_bounds], levels=np.arange(10, 85, 5), cmap=NWSRef, zorder=-10)
grid.drawPolitical(scale_len=10)
row, col = layout
if col == 1:
pylab.text(-0.075, 0.5, exp_names[exp], transform=pylab.gca().transAxes, rotation=90, ha='center', va='center', size=12 * multiplier)
return doSubplot
def obsSubplotFactory(time):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
if (time - datetime(2009, 6, 5, 18, 0, 0)).total_seconds() < 16200:
xs, ys = xs_1, ys_1
domain_bounds = bounds_1sthalf
grid = grid_1
else:
xs, ys = xs_2, ys_2
domain_bounds = bounds_2ndhalf
grid = grid_2
try:
erf = RadarObsFile("qc/1km/KCYS.20090605.%s" % time.strftime("%H%M%S"))
except:
print "Can't load reflectivity ..."
erf = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
pylab.contourf(xs, ys, erf['Z'][0][domain_bounds], levels=np.arange(10, 85, 5), cmap=NWSRef)
grid.drawPolitical(scale_len=10)
row, col = layout
if col == 1:
pylab.text(-0.075, 0.5, "Observations", transform=pylab.gca().transAxes, rotation=90, ha='center', va='center', size=12 * multiplier)
pylab.text(0.5, 1.075, "%s UTC" % time.strftime("%H%M"), transform=pylab.gca().transAxes, ha='center', va='center', size=12 * multiplier)
return doSubplot
pylab.figure(figsize=(18, 21))
pylab.subplots_adjust(left=0.025, bottom=0.1, right=0.875, top=0.975, hspace=0.05, wspace=0.05)
subplots = []
for dt in temp.getDatetimes(aslist=True)[::4]:
subplots.append(obsSubplotFactory(dt))
for exp, min_ens in zip(experiments, min_ens_members):
for time_sec in temp.getTimes()[::4]:
subplots.append(modelSubplotFactory(exp, min_ens, time_sec))
publicationFigure(subplots, (5, 4), corner='ur', colorbar=("Reflectivity (dBZ)", "%d", np.arange(10, 85, 5)))
pylab.savefig("closest/bref.png")
pylab.close()
return
def main():
base_path="/caps2/tsupinie/"
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM'), ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
pkl_path = "vort_gen/500m"
vector_thin = 1
thin = tuple([ slice(None, None, vector_thin) ] * 2)
domain_bounds = (slice(110, 135), slice(118, 143))
grid = goshen_1km_grid(bounds=domain_bounds)
domain_bounds = grid.getBounds()
temp = goshen_1km_temporal(start=14400)
exp_vort = []
exp_refl = []
for exp in experiments.iterkeys():
exp_vort.append(cPickle.load(open("%s/vort_gen_mean_%s.pkl" % (pkl_path, exp), 'r')))
exp_vort[-1] = exp_vort[-1] + (cPickle.load(open("%s/vort_gen_baroc_mean_%s.pkl" % (pkl_path, exp), 'r')),)
refl = []
for time_sec in temp:
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp, time_sec), mpi_config=(2, 12))
except:
mo = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
refl.append(mo['Z'][0])
exp_refl.append(np.array(refl))
v_stretching, tilting, h_stretching, u_mean, v_mean, baroclinic = zip(*exp_vort)
v_stretching_max = [ vs.max(axis=0) for vs in v_stretching ]
tilting_max = [ tl.max(axis=0) for tl in tilting ]
h_stretching_max = [ hs.max(axis=0) for hs in h_stretching ]
baroclinic_max = [ bc.max(axis=0) for bc in baroclinic ]
v_stretching = [ vs.mean(axis=0) for vs in v_stretching ]
tilting = [ tl.mean(axis=0) for tl in tilting ]
h_stretching = [ hs.mean(axis=0) for hs in h_stretching ]
baroclinic = [ bc.mean(axis=0) for bc in baroclinic ]
xs, ys = grid.getXY()
def subplotFactory(exp, vgen, vgen_max, refl, u, v, levels):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
pylab.contour(xs, ys, refl[domain_bounds], levels=np.arange(20, 80, 20), colors='#666666')
pylab.quiver(xs[thin], ys[thin], u[domain_bounds][thin], v[domain_bounds][thin])
c_level = 4 * len(levels) / 5
print "Contours at %e s^-2" % (levels[c_level])
pylab.contour(xs, ys, vgen_max[domain_bounds], levels=[ levels[c_level] ], colors='k', linestyles='-', linewidths=1.5)
pylab.contour(xs, ys, vgen[domain_bounds], levels=[ levels[c_level] ], colors='k', linestyles='--', linewidths=1.5)
pylab.contourf(xs, ys, vgen[domain_bounds], levels=levels, cmap=matplotlib.cm.get_cmap('RdBu_r'), zorder=-10)
grid.drawPolitical()
pylab.text(0.05, 0.95, experiments[exp], transform=pylab.gca().transAxes, ha='left', va='top', size=14 * multiplier)
return
return doSubplot
levels = np.arange(-0.0001, 0.000105, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
for exp, strt, strt_max, refl, u, v in zip(experiments.iterkeys(), v_stretching, v_stretching_max, exp_refl, u_mean, v_mean):
subplots.append(subplotFactory(exp, strt[wdt], strt_max[wdt], refl[wdt], u[wdt], v[wdt], levels))
publicationFigure(subplots, (2, 3), corner='ur', colorbar=(r"Vertical Stretching ($\times$ 10$^3$ s$^{-2}$)", "%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/stretching_%d.png" % (pkl_path, time_sec))
pylab.close()
levels = np.arange(-0.00007, 0.000075, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
for exp, tilt, tilt_max, refl, u, v in zip(experiments.iterkeys(), tilting, tilting_max, exp_refl, u_mean, v_mean):
subplots.append(subplotFactory(exp, tilt[wdt], tilt_max[wdt], refl[wdt], u[wdt], v[wdt], levels))
publicationFigure(subplots, (2, 3), corner='ur', colorbar=(r"Tilting ($\times$ 10$^3$ s$^{-2}$)", "%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/tilting_%d.png" % (pkl_path, time_sec))
pylab.close()
levels = np.arange(-0.0001, 0.000105, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
for exp, strt, strt_max, refl, u, v in zip(experiments.iterkeys(), h_stretching, h_stretching_max, exp_refl, u_mean, v_mean):
subplots.append(subplotFactory(exp, strt[wdt], strt_max[wdt], refl[wdt], u[wdt], v[wdt], levels))
publicationFigure(subplots, (2, 3), corner='ur', colorbar=(r"Horizontal Streamwise Stretching ($\times$ 10$^3$ s$^{-2}$)", "%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/horiz_stretching_%d.png" % (pkl_path, time_sec))
pylab.close()
levels = np.arange(-0.00005, 0.000055, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
for exp, brcl, brcl_max, refl, u, v in zip(experiments.iterkeys(), baroclinic, baroclinic_max, exp_refl, u_mean, v_mean):
subplots.append(subplotFactory(exp, brcl[wdt], brcl_max[wdt], refl[wdt], u[wdt], v[wdt], levels))
publicationFigure(subplots, (2, 3), corner='ur', colorbar=(r"Streamwise Baroclinic Generation ($\times$ 10$^3$ s$^{-2}$)", "%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/baroclinic_%d.png" % (pkl_path, time_sec))
pylab.close()
return
def main():
base_path = "/caps2/tsupinie/"
model_paths_3km = [ "/caps1/tsupinie/3km-fixed-radar/", "/caps2/tsupinie/3km-control/", "/caps2/tsupinie/3km-n0r=8e5/",
"/caps2/tsupinie/3km-7dBZ,5ms/", "/caps1/tsupinie/3kmf-r0h=12km/", "/caps2/tsupinie/3kmf-pr0h=16km/", "/caps2/tsupinie/3kmf-r0h=18km/" ]
model_paths_1km = [ "/caps2/tsupinie/1kmf-z-no-snd/"]
exp_names_1km = [ "1kmf-zupdtpt", "1kmf-z-no-05XP", "1kmf-z-no-mm-05XP", "1kmf-z-no-mm", "1kmf-z-no-v2", "1kmf-z-no-snd" ]
model_paths = [ "%s%s/" % (base_path, e) for e in exp_names_1km ]
obs_path = "/data6/tsupinie/goshen/qc/1km/"
temp = goshen_1km_temporal(start=14400)
refl_threshold = 40
vel_threshold = 30
base_time = datetime(2009, 6, 5, 18, 0, 0)
grid = goshen_1km_grid()
all_ets_refl = {}
all_ets_vel = {}
confusion_refl = {}
confusion_vel = {}
bbox_files = glob.glob("bbox*.pkl")
bboxes = {}
bbox_buffer = 10
bbox_offsets = [0, 10, 0]
for bfile in bbox_files:
root, ext = bfile.split(".")
bits = root.split("_")
key = "1kmf-%s" % bits[-1]
bboxes[key] = cPickle.load(open(bfile, 'r'))
bboxes[key] = (slice(0, 14),) + tuple( slice(b.start - bbox_buffer + o, b.stop + bbox_buffer + o) for b, o in zip(bboxes[key][1:], bbox_offsets[1:]) )
for model_path in model_paths:
print model_path
exp_key = model_path.split("/")[-2]
all_ets_refl[exp_key] = {}
all_ets_vel[exp_key] = {}
confusion_refl[exp_key] = {}
confusion_vel[exp_key] = {}
for radar in [ 'KCYS', 'KFTG', '05XP' ]:
print "%s ..." % radar
ets_refl, ets_vel, conf_refl, conf_vel = runConcurrently(doETS, temp.getTimes(), zip_result=True, args=(radar, model_path, obs_path, "__placeholder__", base_time, refl_threshold, vel_threshold, grid),
kwargs={'n_ens_members':40, 'prob_threshold':0.5, 'bbox':bboxes[exp_key]})
all_ets_refl[exp_key][radar] = ets_refl
all_ets_vel[exp_key][radar] = ets_vel
confusion_refl[exp_key][radar] = conf_refl
confusion_vel[exp_key][radar] = conf_vel
cPickle.dump(all_ets_refl, open("all_ets_new_1km_%02ddBZ_bnd.pkl" % refl_threshold, 'w'), -1)
cPickle.dump(all_ets_vel, open("all_ets_new_1km_%02dms_bnd.pkl" % vel_threshold, 'w'), -1)
cPickle.dump(confusion_refl, open("all_confusion_1km_%02ddBZ.pkl" % refl_threshold, 'w'), -1)
cPickle.dump(confusion_vel, open("all_confusion_1km_%02dms.pkl" % vel_threshold, 'w'), -1)
return
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--data-path', dest='data_path', default="/caps2/tsupinie/")
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
data_path = args.data_path
exp_name = args.exp_name
base_path = "%s/%s/" % (data_path, exp_name)
n_ens_members = 40
domain_bounds = (slice(90, 160), slice(90, 160))
grid = goshen_1km_grid(bounds=domain_bounds)
temp = goshen_1km_temporal(start=14400)
tornado_track = zip(*((41.63, -104.383), (41.6134, -104.224)))
track_xs, track_ys = grid(*[ np.array(list(t)) for t in reversed(tornado_track) ])
updraft_lb = 0
updraft_ub = 3000
updraft_hel_thresh = 125.
vert_hel = loadEnsemble(base_path, n_ens_members, temp.getTimes(), ([ 'u', 'v', 'w', 'dx', 'dy' ], computeVH), agl=True)
cPickle.dump(vert_hel[3], open("updraft_hel/VH_%s.pkl" % exp_name, 'w'), -1)
axes = getAxes(base_path, agl=True)
interp_func, bounds_func = getInterpFunctions(axes, {'z':updraft_lb})
updraft_hel = np.empty(vert_hel.shape[:2] + vert_hel.shape[-2:], dtype=vert_hel.dtype)
n_ens_members, n_times = vert_hel.shape[:2]
for wdt in xrange(n_times):
print "Integrating time %06d ..." % temp[wdt]
vh_members = [ vert_hel[(lde, wdt)] for lde in xrange(n_ens_members) ]
timestep = runConcurrently(integrateUH, vh_members, args=("__placeholder__", (updraft_lb, updraft_ub), axes, interp_func))
for lde in xrange(n_ens_members):
updraft_hel[(lde, wdt)] = timestep[lde]
# print np.nanmax(updraft_hel)
# argmax_uh = np.unravel_index(np.nanargmax(updraft_hel), updraft_hel.shape)
# print argmax_uh
xs, ys = grid.getXY()
prob_color_map = matplotlib.cm.RdYlBu_r
prob_color_map.set_under('#ffffff')
for updraft_hel_thresh in range(75, 425, 25):
prob_updraft_hel = np.nansum(np.nanmax(updraft_hel, axis=1) >= updraft_hel_thresh, axis=0) / float(n_ens_members)
nep_updraft_hel = neighborhoodEnsembleProbability(np.nanmax(updraft_hel, axis=1), updraft_hel_thresh)
pylab.figure()
pylab.pcolormesh(xs, ys, prob_updraft_hel[domain_bounds], vmin=0.1, vmax=1.0, cmap=prob_color_map)
pylab.colorbar()
pylab.plot(track_xs, track_ys, 'mv-', lw=2.5, mfc='k', ms=8)
grid.drawPolitical()
pylab.savefig("updraft_hel/UH0-3_%dm2s2_%s.png" % (int(updraft_hel_thresh), exp_name))
pylab.close()
pylab.figure()
pylab.pcolormesh(xs, ys, nep_updraft_hel[domain_bounds], vmin=0.1, vmax=1.0, cmap=prob_color_map)
pylab.colorbar()
pylab.plot(track_xs, track_ys, 'mv-', lw=2.5, mfc='k', ms=8)
grid.drawPolitical()
pylab.savefig("updraft_hel/NEPcirc_UH0-3_%dm2s2_%s.png" % (int(updraft_hel_thresh), exp_name))
pylab.close()
if updraft_hel_thresh == 75:
cPickle.dump(nep_updraft_hel, open("updraft_hel/NEPcirc_UH0-3_%dm2s2_%s.pkl" % (int(updraft_hel_thresh), exp_name), 'w'), -1)
# for lde in xrange(n_ens_members):
# pylab.figure()
# pylab.pcolormesh(xs, ys, updraft_hel[lde, 0], vmin=25, vmax=125, cmap=prob_color_map)
# pylab.colorbar()
# grid.drawPolitical()
# pylab.savefig("updraft_hel/UH%03d_%s_%06d.png" % (lde + 1, exp_name, 14400))
# pylab.close()
return
def main():
base_path = "/caps2/tsupinie/1kmf-control/"
temp = goshen_1km_temporal(start=14400, end=14400)
grid = goshen_1km_grid()
n_ens_members = 40
x_snd, y_snd = grid.getXY(115, 115)
ens_anal = loadEnsemble(base_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'pt', 'p', 'qv'], getSndParams), {
'x': x_snd,
'y': y_snd
},
fcst=False)
ens_fcst = loadEnsemble(base_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'pt', 'p', 'qv'], getSndParams), {
'x': x_snd,
'y': y_snd
},
fcst=True)
robs = RadarObsFile("qc/1km/KCYS.20090605.220000")
grdbas = nio.open_file("%s/ena001.hdfgrdbas" % base_path,
mode='r',
format='hdf')
weights = computeInflWeights(grdbas.variables['zp'], robs.heights, grid,
robs['Z'] > 20., 6000, 0)
ens_mean = np.empty(ens_anal.shape[1:], dtype=ens_anal.dtype)
ens_preinfl = np.empty(ens_anal.shape, dtype=ens_anal.dtype)
for field in ens_anal.dtype.fields.iterkeys():
ens_mean[field] = ens_anal[field].mean(axis=0)
ens_preinfl[field] = undoAdaptiveInfl(ens_fcst[field], ens_anal[field],
0.9)
for wdt, (t_ens, time_str) in enumerate(
zip(temp, temp.getStrings("%d %B %Y %H%M UTC"))):
pylab.figure(figsize=(8, 10))
plotSkewTBackground(pylab.gca())
for n_ens in xrange(n_ens_members):
pres_profile = ens_preinfl['p'][n_ens, wdt]
temp_profile = theta2Temperature(pt=ens_preinfl['pt'][n_ens, wdt],
p=ens_preinfl['p'][n_ens, wdt])
dewp_profile = qv2Dewpoint(qv=ens_preinfl['qv'][n_ens, wdt],
p=ens_preinfl['p'][n_ens, wdt])
if np.any(temp_profile < dewp_profile):
print "Dewpoint greater than temperature at t=%06d, n=%03d" % (
t_ens, n_ens + 1), np.where(temp_profile < dewp_profile)
plotProfile(temp_profile - 273.15,
pres_profile / 100.,
color='r',
linewidth=0.5)
plotProfile(dewp_profile - 273.15,
pres_profile / 100.,
color='g',
linewidth=0.5)
mean_pres_profile = ens_mean['p'][wdt]
mean_temp_profile = theta2Temperature(pt=ens_mean['pt'][wdt],
p=ens_mean['p'][wdt])
mean_dewp_profile = qv2Dewpoint(qv=ens_mean['qv'][wdt],
p=ens_mean['p'][wdt])
plotProfile(mean_temp_profile - 273.15,
mean_pres_profile / 100.,
color='k',
linewidth=1.5)
plotProfile(mean_dewp_profile - 273.15,
mean_pres_profile / 100.,
color='k',
linewidth=1.5)
pylab.suptitle("Ensemble Soundings at %s" % time_str)
pylab.savefig("fcst_snd_1kmf-control_preinfl_%06d.png" % t_ens)
return
def main():
# exp_names = [ 'sndr0h=25km', 'zs25-no-05XP', 'z-no-snd', 'zs25-no-mm', 'zs25-no-mm-05XP', 'z-no-v2' ]
# exp_names = [ 'sndr0h=25km', 'zs25-offtime-05XP' ]
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM')]) #, ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
temp = goshen_1km_temporal(start=14400)
z_column = findHeights("/caps2/tsupinie/%s/ena001.hdfgrdbas" % experiments.keys()[0], (slice(90, 170), slice(100, 180)))
cutoff = 14
vort_data = {}
max_vorticity = 0.035
min_vorticity = 0.0075
def subplotFactory(exp):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
exp_vort = cPickle.load(open("vort_time_height_%s.pkl" % exp[5:], 'r'))
vort_data[exp] = exp_vort
print "Max vorticity:", exp_vort.max()
cmap = cm.get_cmap('RdYlBu_r')
cmap.set_under('#ffffff')
# pylab.pcolormesh(boundCoordinate(np.array(temp.getTimes())), boundCoordinate(z_column / 1000.), exp_vort.T, cmap=cmap, vmin=min_vorticity, vmax=max_vorticity)
pylab.contourf(temp.getTimes(), z_column / 1000., exp_vort.T, cmap=cmap, levels=np.arange(min_vorticity, max_vorticity + 0.0024, 0.0025))
pylab.xlim(temp.getTimes()[0], temp.getTimes()[-1])
pylab.ylim([z_column[0] / 1000, 10])
layout_r, layout_c = layout
if layout_r == 2 and layout_c == 1 or layout_r == -1 and layout_c == -1:
pylab.xlabel("Time (UTC)", size='large')
pylab.ylabel("Height (km MSL)", size='large')
# pylab.axvline(14400, color='k', linestyle=':')
pylab.xticks(temp.getTimes(), temp.getStrings('%H%M', aslist=True), size='large')
pylab.yticks(size='large')
else:
pylab.xticks(temp.getTimes(), [ '' for t in temp ])
pylab.yticks(pylab.yticks()[0], [ '' for z in pylab.yticks()[0] ])
pylab.text(0.05, 0.95, experiments[exp], ha='left', va='top', transform=pylab.gca().transAxes, size=18 * multiplier)
pylab.xlim(temp.getTimes()[0], temp.getTimes()[3])
pylab.ylim([z_column[1] / 1000, 6])
# pylab.title(exp)
return
return doSubplot
def diffSubplotFactory(exp):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
exp_vort = vort_data[exp]
pylab.pcolormesh(boundCoordinate(np.array(temp.getTimes())), boundCoordinate(z_column / 1000.), exp_vort.T - vort_data['sndr0h=50km'].T,
cmap=cm.get_cmap('RdBu_r'), vmin=-max_vorticity / 2, vmax=max_vorticity / 2)
layout_r, layout_c = layout
if layout_r == 2 and layout_c == 1 or layout_r == -1 and layout_c == -1:
pylab.xlabel("Time (UTC)", size='large')
pylab.ylabel("Height (km MSL)", size='large')
pylab.xticks(temp.getTimes(), temp.getStrings('%H%M', aslist=True), size='large')
pylab.yticks(size='large')
pylab.xlim(temp.getTimes()[0], temp.getTimes()[3])
pylab.ylim([z_column[1] / 1000, 6])
# pylab.title(exp)
return
return doSubplot
subplots = []
diff_subplots = []
for exp in experiments.keys():
subplots.append(subplotFactory(exp))
# if exp != 'sndr0h=50km':
# diff_subplots.append(diffSubplotFactory(exp))
# pylab.figure(figsize=(12, 9))
pylab.figure(figsize=(8.5, 9))
pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
ticks = np.arange(min_vorticity, max_vorticity + 0.0024, 0.0025)
publicationFigure(subplots, (2, 2), corner='ur', colorbar=(r"Vertical Vorticity ($\times$ 10$^{-3}$ s$^{-1}$)", '%.1f', ticks, 1000 * ticks))
# pylab.suptitle("Ensemble Mean of Max $\zeta$")
pylab.savefig("vort_time_height_four.png")
pylab.close()
return
def main():
base_path = "/caps2/tsupinie/"
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'),
('1kmf-zs25-no-05XP', 'NO_MWR'),
('1kmf-z-no-snd', 'NO_SND'),
('1kmf-zs25-no-mm', 'NO_MM'),
('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'),
('1kmf-z-no-v2', 'NO_V2')])
domain_bounds = (slice(110, 135), slice(118, 143))
grid = goshen_1km_grid(bounds=domain_bounds)
domain_bounds = grid.getBounds()
temp = goshen_1km_temporal(start=14400, end=14400)
xs, ys = grid.getXY()
levels = np.arange(-0.030, 0.033, 0.003)
exp_vort = []
exp_refl = []
for exp in experiments.iterkeys():
vort = cPickle.load(open("vort_pkl/vorticity_%s.pkl" % exp, 'r'))
refl = []
for time_sec in temp:
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" %
(base_path, exp, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" %
(base_path, exp, time_sec),
mpi_config=(2, 12))
except:
mo = {'Z': np.zeros((1, 255, 255), dtype=np.float32)}
refl.append(mo)
exp_refl.append(np.array(refl))
def subplotFactory(exp, exp_vort, exp_refl):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
pylab.quiver(xs, ys, exp_vort['u'].mean(axis=0)[domain_bounds],
exp_vort['v'].mean(axis=0)[domain_bounds])
pylab.contour(xs,
ys,
exp_refl['Z'][0][domain_bounds],
colors='#666666',
levels=np.arange(20, 80, 20))
pylab.contour(xs,
ys,
exp_vort['vort'].mean(axis=0)[domain_bounds],
colors='k',
linestyles='--',
linewidths=1.5,
levels=[0.015])
pylab.contour(xs,
ys,
exp_vort['vort'].max(axis=0)[domain_bounds],
colors='k',
linestyles='-',
linewidths=1.5,
levels=[0.015])
pylab.contourf(xs,
ys,
exp_vort['vort'].mean(axis=0)[domain_bounds],
cmap=matplotlib.cm.get_cmap('RdBu_r'),
levels=levels,
zorder=-10)
grid.drawPolitical()
pylab.text(0.05,
0.95,
experiments[exp],
ha='left',
va='top',
transform=pylab.gca().transAxes,
size=14 * multiplier)
return
return doSubplot
for wdt, time_sec in enumerate(temp):
print time_sec
subplots = []
for exp_name, vort, refl in zip(experiments.iterkeys(), exp_vort,
exp_refl):
print vort.shape
subplots.append(subplotFactory(exp_name, vort[:, wdt], refl[wdt]))
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.1,
wspace=0.1)
publicationFigure(subplots, (2, 3),
corner='ur',
colorbar=(r'Vorticity ($\times$ 10$^3$ s$^{-1}$)',
"%d", levels, np.round(1000 * levels)))
pylab.savefig("vorticity_%d.png" % time_sec)
return
def main():
np.seterr(all='ignore')
ap = argparse.ArgumentParser()
ap.add_argument('--data-path', dest='data_path', default="/caps2/tsupinie/")
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
exp_base = args.data_path
exp_name = args.exp_name
n_ensemble_members = 40
# base_time = datetime(2009, 6, 5, 18, 0, 0)
# epoch = datetime(1970, 1, 1, 0, 0, 0)
# base_epoch = (base_time - epoch).total_seconds()
#
# sec_times = np.arange(14400, 18300, 300)
# times = [ base_time + timedelta(seconds=int(t)) for t in sec_times ]
temp = goshen_1km_temporal(start=14400)
bounds = (slice(100, 180), slice(90, 170))
# bounds = (slice(None), slice(None))
# proj = setupMapProjection(goshen_1km_proj, goshen_1km_gs, bounds)
# map = Basemap(**proj)
grid = goshen_1km_grid(bounds=bounds)
obs_file_names = ['psu_straka_mesonet.pkl', 'ttu_sticknet.pkl', 'asos.pkl']
all_obs = loadObs(obs_file_names, temp.getDatetimes(aslist=True), grid, grid.getWidthHeight())
obs_x, obs_y = grid(all_obs['longitude'], all_obs['latitude'])
obs_z = all_obs['elevation']
grdbas_file = "%s/1kmf-%s/ena001.hdfgrdbas" % (exp_base, exp_name)
grdbas = nio.open_file(grdbas_file, mode='r', format='hdf')
y_axis = decompressVariable(grdbas.variables['y'])[bounds[1]]
x_axis = decompressVariable(grdbas.variables['x'])[bounds[0]]
y_axis = y_axis - y_axis[0]
x_axis = x_axis - x_axis[0]
# fcst_files = glob.glob("%s/1km-control-%s/ena???.hdf014[47]00" % (exp_base, exp_name))
# fcst_files.extend(glob.glob("%s/1km-control-%s/ena???.hdf01[5678]*" % (exp_base, exp_name)))
# ens, ens_members, ens_times = loadAndInterpolateEnsemble(fcst_files, ['u', 'v', 'pt', 'p', 'qv', 'qr', 'qs', 'qh'], getTempDewpRefl, grdbas_file,
# {'z':10}, agl=True, wrap=True)
ens = loadEnsemble("/caps2/tsupinie/1kmf-%s/" % exp_name, n_ensemble_members, temp.getTimes(), (['u', 'v', 'pt', 'p', 'qv', 'qr', 'qs', 'qh'], getTempDewpRefl), {'sigma':2}, agl=True, wrap=True)
# ens = ens[:, :, 2, :, :]
ens_slice = [ slice(None), slice(None) ]
ens_slice.extend(bounds[::-1])
ens_mean = np.empty(ens.shape[1:], dtype=[('t', np.float32), ('td', np.float32), ('u', np.float32), ('v', np.float32)])
for var in ens_mean.dtype.fields.iterkeys():
ens_mean[var] = ens[var].mean(axis=0)
cPickle.dump(ens_mean, open("cold_pool_1kmf-%s.pkl" % exp_name, 'w'), -1)
ens = ens[tuple(ens_slice)]
ens_refl = np.maximum(0, ens['refl'].mean(axis=0)) #probMatchMean(ens['refl'])
ens_obs = np.empty(ens.shape[:1] + all_obs.shape, dtype=ens_mean.dtype)
for lde in xrange(ens.shape[0]):
for var in ens_obs.dtype.fields.iterkeys():
for ob_idx, (ob_x, ob_y) in enumerate(zip(obs_x, obs_y)):
wdt = temp.getEpochs(aslist=True).index(int(all_obs['nom_time'][ob_idx]))
ens_obs[var][lde, ob_idx] = interpolate(ens[var][lde, wdt, np.newaxis], {'y':y_axis, 'x':x_axis}, {'y':ob_y, 'x':ob_y})
# print ens_obs.shape
ens_obs_std = np.empty(ens_obs.shape[1:], dtype=ens_obs.dtype)
ens_obs_mean = np.empty(ens_obs.shape[1:], dtype=ens_obs.dtype)
for var in ens_obs_std.dtype.fields.iterkeys():
ens_obs_std[var] = ens_obs[var].std(ddof=1, axis=0)
ens_obs_mean[var] = ens_obs[var].mean(axis=0)
cPickle.dump(ens_obs_mean, open("cold_pool_obs_1kmf-%s.pkl" % exp_name, 'w'), -1)
# print ens_obs_std.shape
# for wdt, (time_sec, time_epoch) in enumerate(zip(temp, temp.getEpochs())):
# time_ob_idxs = np.where(all_obs['time'] == time_epoch)[0]
#
# ob_locations = (all_obs[time_ob_idxs]['longitude'], all_obs[time_ob_idxs]['latitude'])
#
# temp_K = 5. / 9. * (all_obs[time_ob_idxs]['temp'] - 32) + 273.15
# dewp_K = 5. / 9. * (all_obs[time_ob_idxs]['dewp'] - 32) + 273.15
#
# wdir = all_obs[time_ob_idxs]['wind_dir']
# wspd = all_obs[time_ob_idxs]['wind_spd']
#
# u = -wspd * np.sin(np.radians(wdir))
# v = -wspd * np.cos(np.radians(wdir))
#
# print "Plotting temperature ..."
# plotComparison(ens_mean['t'][wdt], ens_obs_mean['t'][time_ob_idxs], ens_obs_std['t'][time_ob_idxs], temp_K, ob_locations, ens_refl[wdt], grid, np.arange(289., 298., 1.), matplotlib.cm.get_cmap('Blues_r'),
# "Ensemble Mean/Obs Comparison at Time %s" % time_sec, "cold_pool_t_%s.png" % time_sec)
# print "Plotting dewpoint ..."
# plotComparison(ens_mean['td'][wdt], ens_obs_mean['td'][time_ob_idxs], ens_obs_std['td'][time_ob_idxs], dewp_K, ob_locations, ens_refl[wdt], grid, np.arange(277., 290., 1.), matplotlib.cm.get_cmap('YlGn'),
# "Ensemble Mean/Obs Comparison at Time %s" % time_sec, "cold_pool_td_%s.png" % time_sec)
#
# print "Plotting u ..."
# plotComparison(ens_mean['u'][wdt], ens_obs_mean['u'][time_ob_idxs], ens_obs_std['u'][time_ob_idxs], u, ob_locations, ens_refl[wdt], grid, np.arange(-20., 22., 2.), matplotlib.cm.get_cmap('RdBu_r'),
# "Ensemble Mean/Obs Comparison at Time %s" % time_sec, "cold_pool_u_%s.png" % time_sec)
# print "Plotting v ..."
# plotComparison(ens_mean['v'][wdt], ens_obs_mean['v'][time_ob_idxs], ens_obs_std['v'][time_ob_idxs], v, ob_locations, ens_refl[wdt], grid, np.arange(-20., 22., 2.), matplotlib.cm.get_cmap('RdBu_r'),
# "Ensemble Mean/Obs Comparison at Time %s" % time_sec, "cold_pool_v_%s.png" % time_sec)
return
def main():
# exp_names = [ 'sndr0h=25km', 'zs25-no-05XP', 'z-no-snd', 'zs25-no-mm', 'zs25-no-mm-05XP', 'z-no-v2' ]
# exp_names = [ 'sndr0h=25km', 'zs25-offtime-05XP' ]
experiments = OrderedDict([
('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'),
('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM')
]) #, ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
temp = goshen_1km_temporal(start=14400)
z_column = findHeights(
"/caps2/tsupinie/%s/ena001.hdfgrdbas" % experiments.keys()[0],
(slice(90, 170), slice(100, 180)))
cutoff = 14
vort_data = {}
max_vorticity = 0.035
min_vorticity = 0.0075
def subplotFactory(exp):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
exp_vort = cPickle.load(
open("vort_time_height_%s.pkl" % exp[5:], 'r'))
vort_data[exp] = exp_vort
print "Max vorticity:", exp_vort.max()
cmap = cm.get_cmap('RdYlBu_r')
cmap.set_under('#ffffff')
# pylab.pcolormesh(boundCoordinate(np.array(temp.getTimes())), boundCoordinate(z_column / 1000.), exp_vort.T, cmap=cmap, vmin=min_vorticity, vmax=max_vorticity)
pylab.contourf(temp.getTimes(),
z_column / 1000.,
exp_vort.T,
cmap=cmap,
levels=np.arange(min_vorticity,
max_vorticity + 0.0024, 0.0025))
pylab.xlim(temp.getTimes()[0], temp.getTimes()[-1])
pylab.ylim([z_column[0] / 1000, 10])
layout_r, layout_c = layout
if layout_r == 2 and layout_c == 1 or layout_r == -1 and layout_c == -1:
pylab.xlabel("Time (UTC)", size='large')
pylab.ylabel("Height (km MSL)", size='large')
# pylab.axvline(14400, color='k', linestyle=':')
pylab.xticks(temp.getTimes(),
temp.getStrings('%H%M', aslist=True),
size='large')
pylab.yticks(size='large')
else:
pylab.xticks(temp.getTimes(), ['' for t in temp])
pylab.yticks(pylab.yticks()[0],
['' for z in pylab.yticks()[0]])
pylab.text(0.05,
0.95,
experiments[exp],
ha='left',
va='top',
transform=pylab.gca().transAxes,
size=18 * multiplier)
pylab.xlim(temp.getTimes()[0], temp.getTimes()[3])
pylab.ylim([z_column[1] / 1000, 6])
# pylab.title(exp)
return
return doSubplot
def diffSubplotFactory(exp):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
exp_vort = vort_data[exp]
pylab.pcolormesh(boundCoordinate(np.array(temp.getTimes())),
boundCoordinate(z_column / 1000.),
exp_vort.T - vort_data['sndr0h=50km'].T,
cmap=cm.get_cmap('RdBu_r'),
vmin=-max_vorticity / 2,
vmax=max_vorticity / 2)
layout_r, layout_c = layout
if layout_r == 2 and layout_c == 1 or layout_r == -1 and layout_c == -1:
pylab.xlabel("Time (UTC)", size='large')
pylab.ylabel("Height (km MSL)", size='large')
pylab.xticks(temp.getTimes(),
temp.getStrings('%H%M', aslist=True),
size='large')
pylab.yticks(size='large')
pylab.xlim(temp.getTimes()[0], temp.getTimes()[3])
pylab.ylim([z_column[1] / 1000, 6])
# pylab.title(exp)
return
return doSubplot
subplots = []
diff_subplots = []
for exp in experiments.keys():
subplots.append(subplotFactory(exp))
# if exp != 'sndr0h=50km':
# diff_subplots.append(diffSubplotFactory(exp))
# pylab.figure(figsize=(12, 9))
pylab.figure(figsize=(8.5, 9))
pylab.subplots_adjust(left=0.05,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.1,
wspace=0.1)
ticks = np.arange(min_vorticity, max_vorticity + 0.0024, 0.0025)
publicationFigure(
subplots, (2, 2),
corner='ur',
colorbar=(r"Vertical Vorticity ($\times$ 10$^{-3}$ s$^{-1}$)", '%.1f',
ticks, 1000 * ticks))
# pylab.suptitle("Ensemble Mean of Max $\zeta$")
pylab.savefig("vort_time_height_four.png")
pylab.close()
return
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--ens-time', dest='ens_time', required=True, type=int)
args = ap.parse_args()
base_path="/caps2/tsupinie/"
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM'), ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
domain_bounds = (slice(105, 155), slice(110, 160))
grid = goshen_1km_grid(bounds=domain_bounds)
domain_bounds = grid.getBounds()
temporal = goshen_1km_temporal(start=14400)
tornado_track = zip(*((41.63, -104.383), (41.6134, -104.224)))
track_xs, track_ys = grid(*[ np.array(list(t)) for t in reversed(tornado_track) ])
t_ens = args.ens_time
def subplotFactory(exp, time_sec):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
data = cPickle.load(open("cold_pool_%s.pkl" % exp, 'r'))
wdt = temporal.getTimes().index(time_sec)
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" % (base_path, exp, time_sec), mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
cmap = matplotlib.cm.get_cmap('Blues_r')
cmap.set_over('#ffffff')
# cmap.set_under(tuple( cmap._segmentdata[c][0][-1] for c in ['red', 'green', 'blue'] ))
# cmap.set_under(cmap[0])
xs, ys = grid.getXY()
# pylab.pcolormesh(xs, ys, data['t'][2][domain_bounds], cmap=cmap, vmin=288., vmax=295.)
pylab.contour(xs, ys, mo['Z'][0][domain_bounds], levels=np.arange(10, 80, 10), colors='k', zorder=10)
pylab.contourf(xs, ys, data['t'][wdt][domain_bounds], levels=range(289, 296), cmap=cmap)
grid.drawPolitical(scale_len=10)
# pylab.plot(track_xs, track_ys, 'mv-', lw=2.5, mfc='k', ms=8)
pylab.text(0.05, 0.95, experiments[exp], ha='left', va='top', transform=pylab.gca().transAxes, size=14 * multiplier)
return
return doSubplot
subplots = []
for exp in experiments.iterkeys():
subplots.append(subplotFactory(exp, t_ens))
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.025, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
publicationFigure(subplots, (2, 3), corner='ur')
cax = pylab.axes((0.90, 0.1125, 0.020, 0.825))
bar = pylab.colorbar(cax=cax)
bar.set_ticks(range(287, 296))
bar.ax.text(3.5, 0.5, r"Temperature (K)", rotation=90, transform=bar.ax.transAxes, size='large', va='center')
pylab.savefig("cold_pool_%d.png" % t_ens)
return
def main():
base_path = "/caps2/tsupinie/"
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'),
('1kmf-zs25-no-05XP', 'NO_MWR'),
('1kmf-z-no-snd', 'NO_SND'),
('1kmf-zs25-no-mm', 'NO_MM'),
('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'),
('1kmf-z-no-v2', 'NO_V2')])
pkl_path = "vort_gen/500m"
vector_thin = 1
thin = tuple([slice(None, None, vector_thin)] * 2)
domain_bounds = (slice(110, 135), slice(118, 143))
grid = goshen_1km_grid(bounds=domain_bounds)
domain_bounds = grid.getBounds()
temp = goshen_1km_temporal(start=14400)
exp_vort = []
exp_refl = []
for exp in experiments.iterkeys():
exp_vort.append(
cPickle.load(open("%s/vort_gen_mean_%s.pkl" % (pkl_path, exp),
'r')))
exp_vort[-1] = exp_vort[-1] + (cPickle.load(
open("%s/vort_gen_baroc_mean_%s.pkl" % (pkl_path, exp), 'r')), )
refl = []
for time_sec in temp:
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" %
(base_path, exp, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" %
(base_path, exp, time_sec),
mpi_config=(2, 12))
except:
mo = {'Z': np.zeros((1, 255, 255), dtype=np.float32)}
refl.append(mo['Z'][0])
exp_refl.append(np.array(refl))
v_stretching, tilting, h_stretching, u_mean, v_mean, baroclinic = zip(
*exp_vort)
v_stretching_max = [vs.max(axis=0) for vs in v_stretching]
tilting_max = [tl.max(axis=0) for tl in tilting]
h_stretching_max = [hs.max(axis=0) for hs in h_stretching]
baroclinic_max = [bc.max(axis=0) for bc in baroclinic]
v_stretching = [vs.mean(axis=0) for vs in v_stretching]
tilting = [tl.mean(axis=0) for tl in tilting]
h_stretching = [hs.mean(axis=0) for hs in h_stretching]
baroclinic = [bc.mean(axis=0) for bc in baroclinic]
xs, ys = grid.getXY()
def subplotFactory(exp, vgen, vgen_max, refl, u, v, levels):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
pylab.contour(xs,
ys,
refl[domain_bounds],
levels=np.arange(20, 80, 20),
colors='#666666')
pylab.quiver(xs[thin], ys[thin], u[domain_bounds][thin],
v[domain_bounds][thin])
c_level = 4 * len(levels) / 5
print "Contours at %e s^-2" % (levels[c_level])
pylab.contour(xs,
ys,
vgen_max[domain_bounds],
levels=[levels[c_level]],
colors='k',
linestyles='-',
linewidths=1.5)
pylab.contour(xs,
ys,
vgen[domain_bounds],
levels=[levels[c_level]],
colors='k',
linestyles='--',
linewidths=1.5)
pylab.contourf(xs,
ys,
vgen[domain_bounds],
levels=levels,
cmap=matplotlib.cm.get_cmap('RdBu_r'),
zorder=-10)
grid.drawPolitical()
pylab.text(0.05,
0.95,
experiments[exp],
transform=pylab.gca().transAxes,
ha='left',
va='top',
size=14 * multiplier)
return
return doSubplot
levels = np.arange(-0.0001, 0.000105, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.1,
wspace=0.1)
for exp, strt, strt_max, refl, u, v in zip(experiments.iterkeys(),
v_stretching,
v_stretching_max, exp_refl,
u_mean, v_mean):
subplots.append(
subplotFactory(exp, strt[wdt], strt_max[wdt], refl[wdt],
u[wdt], v[wdt], levels))
publicationFigure(
subplots, (2, 3),
corner='ur',
colorbar=(r"Vertical Stretching ($\times$ 10$^3$ s$^{-2}$)",
"%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/stretching_%d.png" % (pkl_path, time_sec))
pylab.close()
levels = np.arange(-0.00007, 0.000075, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.1,
wspace=0.1)
for exp, tilt, tilt_max, refl, u, v in zip(experiments.iterkeys(),
tilting, tilting_max,
exp_refl, u_mean, v_mean):
subplots.append(
subplotFactory(exp, tilt[wdt], tilt_max[wdt], refl[wdt],
u[wdt], v[wdt], levels))
publicationFigure(subplots, (2, 3),
corner='ur',
colorbar=(r"Tilting ($\times$ 10$^3$ s$^{-2}$)",
"%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/tilting_%d.png" % (pkl_path, time_sec))
pylab.close()
levels = np.arange(-0.0001, 0.000105, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.1,
wspace=0.1)
for exp, strt, strt_max, refl, u, v in zip(experiments.iterkeys(),
h_stretching,
h_stretching_max, exp_refl,
u_mean, v_mean):
subplots.append(
subplotFactory(exp, strt[wdt], strt_max[wdt], refl[wdt],
u[wdt], v[wdt], levels))
publicationFigure(
subplots, (2, 3),
corner='ur',
colorbar=(
r"Horizontal Streamwise Stretching ($\times$ 10$^3$ s$^{-2}$)",
"%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/horiz_stretching_%d.png" % (pkl_path, time_sec))
pylab.close()
levels = np.arange(-0.00005, 0.000055, 0.000005)
for wdt, time_sec in enumerate(temp):
subplots = []
pylab.figure(figsize=(12, 8))
pylab.subplots_adjust(left=0.05,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.1,
wspace=0.1)
for exp, brcl, brcl_max, refl, u, v in zip(experiments.iterkeys(),
baroclinic, baroclinic_max,
exp_refl, u_mean, v_mean):
subplots.append(
subplotFactory(exp, brcl[wdt], brcl_max[wdt], refl[wdt],
u[wdt], v[wdt], levels))
publicationFigure(
subplots, (2, 3),
corner='ur',
colorbar=(
r"Streamwise Baroclinic Generation ($\times$ 10$^3$ s$^{-2}$)",
"%.2f", levels[::2], levels[::2] * 1000))
pylab.savefig("%s/baroclinic_%d.png" % (pkl_path, time_sec))
pylab.close()
return
def main():
base_path = "/caps2/tsupinie/"
min_ens = 17
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'),
('1kmf-zs25-no-05XP', 'NO_MWR'),
('1kmf-z-no-snd', 'NO_SND'),
('1kmf-zs25-no-mm', 'NO_MM'),
('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'),
('1kmf-z-no-v2', 'NO_V2')])
temp = goshen_1km_temporal(start=14400, end=18000)
bounds = (slice(120, 195), slice(95, 170))
grid = goshen_1km_grid(bounds)
bounds = grid.getBounds()
obs = cPickle.load(open('soundings.pkl', 'r'))[2]
u_obs, v_obs, alt = obs['u_wind'], obs['v_wind'], obs['altitude']
good_uv = np.where((u_obs != 9999.0) & (v_obs != 9999.0)
& (alt != 99999.0))
u_obs, v_obs, alt = u_obs[good_uv], v_obs[good_uv], alt[good_uv]
hodo_data = []
z_axes = []
for exp in experiments.iterkeys():
hodo_data.append(cPickle.load(open("hodo_pkl/%s_hodo.pkl" % exp, 'r')))
z_axes.append(
getAxes("%s%s" % (base_path, exp), agl=False)['z'][:, 105, 180])
def subplotFactory(exp, hodo_data, z_axis):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
plt_points = np.where(z_axis < 10000.)[0]
for n_ens in xrange(hodo_data.shape[0]):
pylab.plot(hodo_data['u'][n_ens, plt_points],
hodo_data['v'][n_ens, plt_points],
color='b',
zorder=-1)
pylab.plot(hodo_data['u'][:, plt_points].mean(axis=0),
hodo_data['v'][:, plt_points].mean(axis=0),
color='k',
lw=1.5,
zorder=-1)
plotHodoBackground()
return
return doSubplot
# for wdt, time_sec in enumerate(temp):
# subplots = []
# for exp, hodo, z_axis in zip(experiments.iterkeys(), hodo_data, z_axes):
# subplots.append(subplotFactory(exp, hodo[:, wdt], z_axis))
#
# pylab.figure(figsize=(12, 8))
# pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
# publicationFigure(subplots, (2, 3), corner='ur')
# pylab.savefig("hodographs_%d.png" % time_sec)
xs, ys = grid.getXY()
colors = dict(zip(experiments.keys(), ['k', 'r', 'g', 'b', 'c', 'm']))
for wdt, time_sec in enumerate(temp):
try:
mo = ARPSModelObsFile(
"%s/%s/KCYS%03dan%06d" %
(base_path, experiments.keys()[0], min_ens, time_sec))
except AssertionError:
mo = ARPSModelObsFile(
"%s/%s/KCYS%03dan%06d" %
(base_path, experiments.keys()[0], min_ens, time_sec),
mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z': np.zeros((1, 255, 255), dtype=np.float32)}
pylab.figure(figsize=(12, 12))
plt_obs = np.where((alt - alt[0] >= 50) & (alt < 10000.))[0]
obs_u_marker = interp1d(alt, u_obs)(1000 * np.arange(2, 10, 2))
obs_v_marker = interp1d(alt, v_obs)(1000 * np.arange(2, 10, 2))
pylab.plot(u_obs[plt_obs],
v_obs[plt_obs],
color='#333333',
lw=3,
ls='--',
label='Observed')
pylab.plot(u_obs[plt_obs],
v_obs[plt_obs],
color='#333333',
lw=1,
ls='-')
pylab.plot(obs_u_marker,
obs_v_marker,
marker='o',
color="#333333",
linestyle='none',
markersize=12)
for exp, hodo, z_axis in zip(experiments.iterkeys(), hodo_data,
z_axes):
u_mean = hodo['u'][:, wdt].mean(axis=0)
v_mean = hodo['v'][:, wdt].mean(axis=0)
u_marker = interp1d(z_axis, u_mean)(1000 * np.arange(2, 10, 2))
v_marker = interp1d(z_axis, v_mean)(1000 * np.arange(2, 10, 2))
plt_points = np.where((z_axis - z_axis[0] >= 50)
& (z_axis < 10000.))[0]
pylab.plot(u_mean[plt_points],
v_mean[plt_points],
color=colors[exp],
label=experiments[exp],
lw=2,
zorder=-1)
pylab.plot(u_marker, v_marker, "%so" % colors[exp], ms=12)
plotHodoBackground()
pylab.legend(loc=2, prop={'size': 18})
pylab.xlabel('u (m s$^{-1}$)', size=18)
pylab.ylabel('v (m s$^{-1}$)', size=18)
par_ax = pylab.gca()
ax_width_inches, ax_height_inches = [
f * a for f, a in zip(pylab.gcf().get_size_inches(),
par_ax.get_position().size)
]
ins_ax = inset_axes(pylab.gca(),
0.3 * ax_width_inches,
0.3 * ax_width_inches,
loc=1)
pylab.contourf(xs,
ys,
mo['Z'][0][bounds],
cmap=NWSRef,
levels=np.arange(5, 80, 5))
pylab.plot(1000 * (164 - bounds[1].start),
1000 * (103 - bounds[0].start),
'k*',
ms=24)
grid.drawPolitical()
pylab.savefig("hodographs_comb_%d.png" % time_sec)
return
def main():
base_path = "/caps2/tsupinie/"
min_ens = 17
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'), ('1kmf-zs25-no-05XP', 'NO_MWR'), ('1kmf-z-no-snd', 'NO_SND'), ('1kmf-zs25-no-mm', 'NO_MM'), ('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'), ('1kmf-z-no-v2', 'NO_V2')])
temp = goshen_1km_temporal(start=14400, end=18000)
bounds = (slice(120, 195), slice(95, 170))
grid = goshen_1km_grid(bounds)
bounds = grid.getBounds()
obs = cPickle.load(open('soundings.pkl', 'r'))[2]
u_obs, v_obs, alt = obs['u_wind'], obs['v_wind'], obs['altitude']
good_uv = np.where((u_obs != 9999.0) & (v_obs != 9999.0) & (alt != 99999.0))
u_obs, v_obs, alt = u_obs[good_uv], v_obs[good_uv], alt[good_uv]
hodo_data = []
z_axes = []
for exp in experiments.iterkeys():
hodo_data.append(cPickle.load(open("hodo_pkl/%s_hodo.pkl" % exp, 'r')))
z_axes.append(getAxes("%s%s" % (base_path, exp), agl=False)['z'][:, 105, 180])
def subplotFactory(exp, hodo_data, z_axis):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
plt_points = np.where(z_axis < 10000.)[0]
for n_ens in xrange(hodo_data.shape[0]):
pylab.plot(hodo_data['u'][n_ens, plt_points], hodo_data['v'][n_ens, plt_points], color='b', zorder=-1)
pylab.plot(hodo_data['u'][:, plt_points].mean(axis=0), hodo_data['v'][:, plt_points].mean(axis=0), color='k', lw=1.5, zorder=-1)
plotHodoBackground()
return
return doSubplot
# for wdt, time_sec in enumerate(temp):
# subplots = []
# for exp, hodo, z_axis in zip(experiments.iterkeys(), hodo_data, z_axes):
# subplots.append(subplotFactory(exp, hodo[:, wdt], z_axis))
#
# pylab.figure(figsize=(12, 8))
# pylab.subplots_adjust(left=0.05, bottom=0.1, right=0.875, top=0.975, hspace=0.1, wspace=0.1)
# publicationFigure(subplots, (2, 3), corner='ur')
# pylab.savefig("hodographs_%d.png" % time_sec)
xs, ys = grid.getXY()
colors = dict(zip(experiments.keys(), ['k', 'r', 'g', 'b', 'c', 'm']))
for wdt, time_sec in enumerate(temp):
try:
mo = ARPSModelObsFile("%s/%s/KCYS%03dan%06d" % (base_path, experiments.keys()[0], min_ens, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYS%03dan%06d" % (base_path, experiments.keys()[0], min_ens, time_sec), mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z':np.zeros((1, 255, 255), dtype=np.float32)}
pylab.figure(figsize=(12, 12))
plt_obs = np.where((alt - alt[0] >= 50) & (alt < 10000.))[0]
obs_u_marker = interp1d(alt, u_obs)(1000 * np.arange(2, 10, 2))
obs_v_marker = interp1d(alt, v_obs)(1000 * np.arange(2, 10, 2))
pylab.plot(u_obs[plt_obs], v_obs[plt_obs], color='#333333', lw=3, ls='--', label='Observed')
pylab.plot(u_obs[plt_obs], v_obs[plt_obs], color='#333333', lw=1, ls='-')
pylab.plot(obs_u_marker, obs_v_marker, marker='o', color="#333333", linestyle='none', markersize=12)
for exp, hodo, z_axis in zip(experiments.iterkeys(), hodo_data, z_axes):
u_mean = hodo['u'][:, wdt].mean(axis=0)
v_mean = hodo['v'][:, wdt].mean(axis=0)
u_marker = interp1d(z_axis, u_mean)(1000 * np.arange(2, 10, 2))
v_marker = interp1d(z_axis, v_mean)(1000 * np.arange(2, 10, 2))
plt_points = np.where((z_axis - z_axis[0] >= 50) & (z_axis < 10000.))[0]
pylab.plot(u_mean[plt_points], v_mean[plt_points], color=colors[exp], label=experiments[exp], lw=2, zorder=-1)
pylab.plot(u_marker, v_marker, "%so" % colors[exp], ms=12)
plotHodoBackground()
pylab.legend(loc=2, prop={'size':18})
pylab.xlabel('u (m s$^{-1}$)', size=18)
pylab.ylabel('v (m s$^{-1}$)', size=18)
par_ax = pylab.gca()
ax_width_inches, ax_height_inches = [ f * a for f, a in zip(pylab.gcf().get_size_inches(), par_ax.get_position().size) ]
ins_ax = inset_axes(pylab.gca(), 0.3 * ax_width_inches, 0.3 * ax_width_inches, loc=1)
pylab.contourf(xs, ys, mo['Z'][0][bounds], cmap=NWSRef, levels=np.arange(5, 80, 5))
pylab.plot(1000 * (164 - bounds[1].start), 1000 * (103 - bounds[0].start), 'k*', ms=24)
grid.drawPolitical()
pylab.savefig("hodographs_comb_%d.png" % time_sec)
return
def main():
base_path = "/caps2/tsupinie/"
ap = argparse.ArgumentParser()
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
n_ens_members = 40
exp_name = args.exp_name
bounds_obs = (slice(100, 180), slice(90, 170))
grid_obs = goshen_1km_grid(bounds=bounds_obs)
bounds = (slice(None), slice(None))
grid = goshen_1km_grid(bounds=bounds)
temp = goshen_1km_temporal(start=14400)
obs_file_names = ['psu_straka_mesonet.pkl', 'ttu_sticknet.pkl', 'asos.pkl']
all_obs = loadObs(obs_file_names, temp.getDatetimes(aslist=True), grid_obs,
grid_obs.getWidthHeight())
obs_xy = np.vstack(grid(all_obs['longitude'], all_obs['latitude'])).T
ens = loadEnsemble("/caps2/tsupinie/%s/" % exp_name,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'pt', 'p', 'qv'], getTempDewpRefl),
{'sigma': 2},
agl=True,
wrap=True)
grid_xs, grid_ys = grid.getXY()
obs_t_verif = []
for wdt, (time_sec, time_epoch) in enumerate(zip(temp, temp.getEpochs())):
try:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" %
(base_path, exp_name, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYSan%06d" %
(base_path, exp_name, time_sec),
mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z': np.zeros((1, 255, 255), dtype=np.float32)}
time_ob_idxs = np.where(all_obs['nom_time'] == time_epoch)[0]
time_obs = all_obs[time_ob_idxs]
time_obs_xy = obs_xy[time_ob_idxs]
obs_intrp = griddata(time_obs_xy,
5. / 9. * (time_obs['temp'] - 32) + 273.15,
(grid_xs, grid_ys))
print np.isfinite(obs_intrp).sum()
pylab.figure()
pylab.contourf(grid_xs,
grid_ys,
ens['t'][:, wdt].mean(axis=0)[bounds] - obs_intrp,
levels=np.arange(-6, 6.5, 0.5),
cmap=matplotlib.cm.get_cmap("RdBu_r"))
pylab.colorbar()
pylab.contour(grid_xs,
grid_ys,
mo['Z'][0][tuple(reversed(bounds))],
levels=np.arange(10, 80, 10),
colors='k')
grid.drawPolitical()
pylab.savefig("obs_verif/obs_%s_t_grid_%06d.png" %
(exp_name[5:], time_sec))
pylab.close()
obs_t_verif.append(ens['t'][:, wdt].mean(axis=0) - obs_intrp)
cPickle.dump(np.array(obs_t_verif),
open("obs_verif/obs_verif_%s.pkl" % exp_name, 'w'), -1)
return
def main():
base_path = "/caps2/tsupinie/"
exp_names = {
'1kmf-sndr0h=25km': "CTRL",
'1kmf-zs25-no-05XP': "NO_MWR",
'1kmf-zs25-no-mm-05XP': "NO_MWR_MM",
'1kmf-zs25-no-mm': "NO_MM",
'1kmf-z-no-snd': "NO_SND",
'1kmf-z-no-v2': "NO_V2"
}
experiments = [
'1kmf-sndr0h=25km', '1kmf-zs25-no-05XP', '1kmf-z-no-snd',
'1kmf-zs25-no-mm'
] #, '1kmf-zs25-no-mm-05XP', '1kmf-z-no-v2']
min_ens_members = [17, 31, 31,
31] #, 36, 1 ]
bounds_1sthalf = (slice(105, 160), slice(105, 160))
bounds_2ndhalf = (slice(130, 185), slice(105, 160))
grid_1 = goshen_1km_grid(bounds=bounds_1sthalf)
grid_2 = goshen_1km_grid(bounds=bounds_2ndhalf)
bounds_1sthalf = grid_1.getBounds()
bounds_2ndhalf = grid_2.getBounds()
xs_1, ys_1 = grid_1.getXY()
xs_2, ys_2 = grid_2.getXY()
thin_factor = 2
thin = tuple([slice(None, None, thin_factor)] * 2)
temp = goshen_1km_temporal(start=14400)
wind = {}
for exp, min_ens in zip(experiments, min_ens_members):
wind[exp] = loadEnsemble("%s%s" % (base_path, exp), [min_ens],
temp.getTimes(),
(['u', 'v', 'w'], toRecArray), {'z': 1000},
agl=True)[0]
def modelSubplotFactory(exp, min_ens, time_sec):
wdt = temp.getTimes().index(time_sec)
def doSubplot(multiplier=1.0, layout=(-1, -1)):
if time_sec < 16200:
xs, ys = xs_1, ys_1
domain_bounds = bounds_1sthalf
grid = grid_1
else:
xs, ys = xs_2, ys_2
domain_bounds = bounds_2ndhalf
grid = grid_2
try:
mo = ARPSModelObsFile("%s/%s/KCYS%03dan%06d" %
(base_path, exp, min_ens, time_sec))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/KCYS%03dan%06d" %
(base_path, exp, min_ens, time_sec),
mpi_config=(2, 12))
except:
print "Can't load reflectivity ..."
mo = {'Z': np.zeros((1, 255, 255), dtype=np.float32)}
pylab.contour(xs,
ys,
wind[exp]['w'][wdt][domain_bounds],
levels=np.arange(2, 102, 2),
styles='-',
colors='k')
pylab.contour(xs,
ys,
wind[exp]['w'][wdt][domain_bounds],
levels=np.arange(-100, 0, 2),
styles='--',
colors='k')
pylab.quiver(xs[thin], ys[thin],
wind[exp]['u'][wdt][domain_bounds][thin],
wind[exp]['v'][wdt][domain_bounds][thin])
pylab.contourf(xs,
ys,
mo['Z'][0][domain_bounds],
levels=np.arange(10, 85, 5),
cmap=NWSRef,
zorder=-10)
grid.drawPolitical(scale_len=10)
row, col = layout
if col == 1:
pylab.text(-0.075,
0.5,
exp_names[exp],
transform=pylab.gca().transAxes,
rotation=90,
ha='center',
va='center',
size=12 * multiplier)
return doSubplot
def obsSubplotFactory(time):
def doSubplot(multiplier=1.0, layout=(-1, -1)):
if (time - datetime(2009, 6, 5, 18, 0, 0)).total_seconds() < 16200:
xs, ys = xs_1, ys_1
domain_bounds = bounds_1sthalf
grid = grid_1
else:
xs, ys = xs_2, ys_2
domain_bounds = bounds_2ndhalf
grid = grid_2
try:
erf = RadarObsFile("qc/1km/KCYS.20090605.%s" %
time.strftime("%H%M%S"))
except:
print "Can't load reflectivity ..."
erf = {'Z': np.zeros((1, 255, 255), dtype=np.float32)}
pylab.contourf(xs,
ys,
erf['Z'][0][domain_bounds],
levels=np.arange(10, 85, 5),
cmap=NWSRef)
grid.drawPolitical(scale_len=10)
row, col = layout
if col == 1:
pylab.text(-0.075,
0.5,
"Observations",
transform=pylab.gca().transAxes,
rotation=90,
ha='center',
va='center',
size=12 * multiplier)
pylab.text(0.5,
1.075,
"%s UTC" % time.strftime("%H%M"),
transform=pylab.gca().transAxes,
ha='center',
va='center',
size=12 * multiplier)
return doSubplot
pylab.figure(figsize=(18, 21))
pylab.subplots_adjust(left=0.025,
bottom=0.1,
right=0.875,
top=0.975,
hspace=0.05,
wspace=0.05)
subplots = []
for dt in temp.getDatetimes(aslist=True)[::4]:
subplots.append(obsSubplotFactory(dt))
for exp, min_ens in zip(experiments, min_ens_members):
for time_sec in temp.getTimes()[::4]:
subplots.append(modelSubplotFactory(exp, min_ens, time_sec))
publicationFigure(subplots, (5, 4),
corner='ur',
colorbar=("Reflectivity (dBZ)", "%d",
np.arange(10, 85, 5)))
pylab.savefig("closest/bref.png")
pylab.close()
return
def main():
radar_path = "/data6/tsupinie/goshen/qc/1km/"
nom_2_real = {'2100': '2058', '2200': '2158', '2300': '2257'}
radar_locations = {
'KCYS': ((41.15194, -104.80611), 230),
'KFTG': ((39.78667, -104.54583), 230),
'KRIW': ((43.06611, -108.47722), 230),
'MWR-05XP': ((41.56150, -104.298996), 40),
}
boxes = (
(slice(65, 105), slice(115, 155)),
(slice(105, 145), slice(115, 155)),
(slice(140, 180), slice(110, 150)),
)
refl = tuple(
RadarObsFile(f)['Z'][0]
for f in sorted(glob.glob("%s/KCYS.20090605.2[123]00*" % radar_path)))
buffer_1km = 0
grid_1km_plot = goshen_1km_grid(buffer=buffer_1km)
grid_1km = goshen_1km_grid()
grid_1km_lats, grid_1km_lons = grid_1km.getBoundaryCoords()
grid_3km_plot = goshen_3km_grid() #buffer=40)
grid_3km = goshen_3km_grid()
grid_3km_lats, grid_3km_lons = grid_3km.getBoundaryCoords()
temp = goshen_1km_temporal(step=3600)
temp_1km = goshen_1km_temporal()
temp_3km = goshen_3km_temporal()
def sf_3km_domain(multiplier=1.0, layout=(-1, -1)):
pylab.plot(*grid_3km_plot(grid_3km_lons, grid_3km_lats),
color='k',
lw=multiplier)
pylab.plot(*grid_3km_plot(grid_1km_lons, grid_1km_lats),
color='k',
lw=2 * multiplier)
width, height = grid_3km_plot.getWidthHeight()
pylab.xlim(0, width)
pylab.ylim(0, height)
for radar_id, ((radar_lat, radar_lon),
radar_range) in radar_locations.iteritems():
radar_x, radar_y = grid_3km_plot(radar_lon, radar_lat)
if radar_id == "MWR-05XP":
offset_sign = 1
h_align, v_align = 'left', 'bottom'
else:
offset_sign = -1
h_align, v_align = 'right', 'top'
ax_trans = pylab.gca().transData + pylab.gca().transAxes.inverted()
label_x, label_y = ax_trans.transform(
np.array([[radar_x, radar_y]]))[0] + offset_sign * 0.0125
if radar_id not in ['MWR-05XP']:
pylab.plot(radar_x, radar_y, 'k^', ms=6 * multiplier)
pylab.text(label_x,
label_y,
radar_id,
color='k',
clip_box=pylab.gca().bbox,
size=12 * multiplier,
clip_on=True,
ha=h_align,
va=v_align,
transform=pylab.gca().transAxes)
pylab.gca().add_patch(
Circle((radar_x, radar_y),
1000 * radar_range,
fc='none',
lw=multiplier,
zorder=10))
grid_3km_plot.drawPolitical(color='#999999', lw=1.5 * multiplier)
def sf_1km_domain(multiplier=1.0, layout=(-1, -1)):
pylab.plot(*grid_1km_plot(grid_1km_lons, grid_1km_lats),
color='k',
lw=multiplier)
width, height = grid_1km_plot.getWidthHeight()
x, y = grid_1km_plot.getXY()
for r, b, t in zip(refl, boxes, temp.getStrings("%H%M")):
bx, by = b
plot_r = np.zeros(r.shape, dtype=r.dtype)
plot_r[b[::-1]] = r[b[::-1]]
if buffer_1km == 0:
buffer_slc = slice(None, None)
else:
buffer_slc = slice(buffer_1km, buffer_1km)
pylab.contour(x[buffer_slc, buffer_slc],
y[buffer_slc, buffer_slc],
plot_r,
levels=[40.],
colors='k',
linewidths=multiplier,
zorder=10)
pylab.text((bx.stop + buffer_1km) * 1000,
(by.stop + buffer_1km) * 1000,
nom_2_real[t],
color='k',
size=12 * multiplier,
ha='right',
va='top')
pylab.xlim(0, width)
pylab.ylim(0, height)
for radar_id, ((radar_lat, radar_lon),
radar_range) in radar_locations.iteritems():
radar_x, radar_y = grid_1km_plot(radar_lon, radar_lat)
offset_sign = -1
ax_trans = pylab.gca().transData + pylab.gca().transAxes.inverted()
label_x, label_y = ax_trans.transform(
np.array([[radar_x, radar_y]]))[0] + offset_sign * 0.0125
if radar_id not in ['KRIW']:
pylab.plot(radar_x, radar_y, 'k^', ms=6 * multiplier)
pylab.text(label_x,
label_y,
radar_id,
color='k',
clip_box=pylab.gca().bbox,
clip_on=True,
size=12 * multiplier,
ha='right',
va='top',
transform=pylab.gca().transAxes)
pylab.gca().add_patch(
Circle((radar_x, radar_y),
1000 * radar_range,
fc='none',
lw=multiplier,
zorder=10))
grid_1km_plot.drawPolitical(color='#999999', lw=1.5 * multiplier)
pylab.figure(figsize=(16, 12))
pylab.subplots_adjust(left=0.05,
bottom=0.375,
right=0.95,
top=0.975,
hspace=0.1,
wspace=0.1)
publicationFigure([sf_3km_domain, sf_1km_domain], (1, 2))
tl_ax = pylab.axes((0.05, 0.025, 0.9, 0.325))
tl_ax.xaxis.set_ticks([])
tl_ax.yaxis.set_visible(False)
center_3km = 0.65
center_1km = 0.35
rad_spacing = 0.05
tl_ax.arrow(0,
center_3km,
18300,
0,
head_width=0.025,
head_length=300,
fc='k')
pylab.text(-300,
center_3km,
"Outer Domain",
ha='right',
va='center',
size=18)
for t_ens, t_str in zip(temp_3km, temp_3km.getStrings("%H%M")):
if t_ens % 3600:
tick_size = 0.0125
else:
tick_size = 0.025
pylab.text(t_ens,
0.9,
"%s UTC" % t_str,
size=22,
ha='center',
va='center')
tl_ax.add_line(
Line2D([t_ens, t_ens],
[center_3km - tick_size, center_3km + tick_size],
color='k',
lw=2))
for idx, (t_st, t_en, rad, c) in enumerate([[1800, 14400, 'KRIW', 'r'],
[5400, 14400, 'KCYS', 'g'],
[5400, 14400, 'KFTG', 'b']]):
tl_ax.add_line(
Line2D([t_st, t_en], [center_3km + (idx + 1) * rad_spacing] * 2,
color=c,
lw=5))
pylab.text(t_st - 300,
center_3km + (idx + 1) * rad_spacing,
rad,
ha='right',
va='center',
color=c,
size=18)
tl_ax.arrow(10800,
center_1km,
7500,
0,
head_width=0.025,
head_length=300,
fc='k')
pylab.text(-300,
center_1km,
"Inner Domain",
ha='right',
va='center',
size=18)
for t_ens in temp_1km:
if t_ens % 3600:
tick_size = 0.0125
else:
tick_size = 0.025
tl_ax.add_line(
Line2D([t_ens, t_ens],
[center_1km - tick_size, center_1km + tick_size],
color='k',
lw=2))
for idx, (t_st, t_en, rad,
c) in enumerate([[11100, 14400, 'KCYS', 'g'],
[11700, 14400, 'KFTG', 'b'],
[13500, 14400, 'MWR-05XP', 'k']]):
tl_ax.add_line(
Line2D([t_st, t_en], [center_1km - (idx + 1) * rad_spacing] * 2,
color=c,
lw=5))
pylab.text(t_st - 300,
center_1km - (idx + 1) * rad_spacing,
rad,
ha='right',
va='center',
color=c,
size=18)
tl_ax.arrow(10800,
center_3km - rad_spacing,
0,
-(center_3km - rad_spacing) + (center_1km + rad_spacing),
head_width=150,
head_length=0.025,
length_includes_head=True,
fc='k')
tl_ax.add_line(Line2D([13920, 16230], [0.5, 0.5], color='m', lw=5))
pylab.text(13620,
0.5,
"Tornado",
ha='right',
va='center',
size=18,
color='m')
base_diag = np.hypot(6, 12)
size_x, size_y = pylab.gcf().get_size_inches()
fig_diag = np.hypot(size_x, size_y)
multiplier = fig_diag / base_diag
corner = 'ul'
bbox = {'ec': 'k', 'fc': 'w', 'pad': 10, 'lw': multiplier}
loc = {'ul': (0.0, 1.0), 'ur': (1.0, 1.0)}
align = {'ul': ('left', 'top'), 'ur': ('right', 'top')}
pad_signs = {'l': 1, 'r': -1, 'u': -1}
offset = transforms.ScaledTranslation(
pad_signs[corner[1]] * ((bbox['pad'] + bbox['lw']) / (2 * 72.)),
pad_signs[corner[0]] * (bbox['pad'] + bbox['lw']) / (2 * 72.),
pylab.gcf().dpi_scale_trans)
text_transform = pylab.gca().transAxes + offset
text_x, text_y = loc[corner]
h_align, v_align = align[corner]
pylab.text(text_x,
text_y,
"(c)",
transform=text_transform,
bbox=bbox,
ha=h_align,
va=v_align,
fontsize=16 * multiplier,
fontweight='bold',
zorder=1000)
pylab.xlim(-3300, 19200)
pylab.ylim(0, 1)
pylab.savefig("domain_plan.png")
pylab.close()
return
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--data-path',
dest='data_path',
default="/caps2/tsupinie/")
ap.add_argument('--exp-name', dest='exp_name', required=True)
args = ap.parse_args()
data_path = args.data_path
exp_name = args.exp_name
base_path = "%s/%s/" % (data_path, exp_name)
n_ens_members = 40
domain_bounds = (slice(90, 160), slice(90, 160))
grid = goshen_1km_grid(bounds=domain_bounds)
temp = goshen_1km_temporal(start=14400)
tornado_track = zip(*((41.63, -104.383), (41.6134, -104.224)))
track_xs, track_ys = grid(
*[np.array(list(t)) for t in reversed(tornado_track)])
updraft_lb = 0
updraft_ub = 3000
updraft_hel_thresh = 125.
vert_hel = loadEnsemble(base_path,
n_ens_members,
temp.getTimes(),
(['u', 'v', 'w', 'dx', 'dy'], computeVH),
agl=True)
cPickle.dump(vert_hel[3], open("updraft_hel/VH_%s.pkl" % exp_name, 'w'),
-1)
axes = getAxes(base_path, agl=True)
interp_func, bounds_func = getInterpFunctions(axes, {'z': updraft_lb})
updraft_hel = np.empty(vert_hel.shape[:2] + vert_hel.shape[-2:],
dtype=vert_hel.dtype)
n_ens_members, n_times = vert_hel.shape[:2]
for wdt in xrange(n_times):
print "Integrating time %06d ..." % temp[wdt]
vh_members = [vert_hel[(lde, wdt)] for lde in xrange(n_ens_members)]
timestep = runConcurrently(integrateUH,
vh_members,
args=("__placeholder__", (updraft_lb,
updraft_ub), axes,
interp_func))
for lde in xrange(n_ens_members):
updraft_hel[(lde, wdt)] = timestep[lde]
# print np.nanmax(updraft_hel)
# argmax_uh = np.unravel_index(np.nanargmax(updraft_hel), updraft_hel.shape)
# print argmax_uh
xs, ys = grid.getXY()
prob_color_map = matplotlib.cm.RdYlBu_r
prob_color_map.set_under('#ffffff')
for updraft_hel_thresh in range(75, 425, 25):
prob_updraft_hel = np.nansum(
np.nanmax(updraft_hel, axis=1) >= updraft_hel_thresh,
axis=0) / float(n_ens_members)
nep_updraft_hel = neighborhoodEnsembleProbability(
np.nanmax(updraft_hel, axis=1), updraft_hel_thresh)
pylab.figure()
pylab.pcolormesh(xs,
ys,
prob_updraft_hel[domain_bounds],
vmin=0.1,
vmax=1.0,
cmap=prob_color_map)
pylab.colorbar()
pylab.plot(track_xs, track_ys, 'mv-', lw=2.5, mfc='k', ms=8)
grid.drawPolitical()
pylab.savefig("updraft_hel/UH0-3_%dm2s2_%s.png" %
(int(updraft_hel_thresh), exp_name))
pylab.close()
pylab.figure()
pylab.pcolormesh(xs,
ys,
nep_updraft_hel[domain_bounds],
vmin=0.1,
vmax=1.0,
cmap=prob_color_map)
pylab.colorbar()
pylab.plot(track_xs, track_ys, 'mv-', lw=2.5, mfc='k', ms=8)
grid.drawPolitical()
pylab.savefig("updraft_hel/NEPcirc_UH0-3_%dm2s2_%s.png" %
(int(updraft_hel_thresh), exp_name))
pylab.close()
if updraft_hel_thresh == 75:
cPickle.dump(
nep_updraft_hel,
open(
"updraft_hel/NEPcirc_UH0-3_%dm2s2_%s.pkl" %
(int(updraft_hel_thresh), exp_name), 'w'), -1)
# for lde in xrange(n_ens_members):
# pylab.figure()
# pylab.pcolormesh(xs, ys, updraft_hel[lde, 0], vmin=25, vmax=125, cmap=prob_color_map)
# pylab.colorbar()
# grid.drawPolitical()
# pylab.savefig("updraft_hel/UH%03d_%s_%06d.png" % (lde + 1, exp_name, 14400))
# pylab.close()
return
def main():
temp = goshen_1km_temporal(start=14400)
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'),
('1kmf-zs25-no-05XP', 'NO_MWR'),
('1kmf-z-no-snd', 'NO_SND'),
('1kmf-zs25-no-mm', 'NO_MM'),
('1kmf-zs25-no-mm-05XP', 'NO_MWR_MM'),
('1kmf-z-no-v2', 'NO_V2')])
refl_thresh = [25, 45]
all_AUCs = []
for thresh in refl_thresh:
rocs = []
for exp in experiments.iterkeys():
pkl_name = "roc_pkl/%s_%02ddBZ_roc.pkl" % (exp, thresh)
roc = cPickle.load(open(pkl_name, 'r'))
rocs.append(roc)
rocs = zip(*rocs)
AUCs = []
for time, roc_group in zip(temp, rocs):
AUC = [computeAUC(r[0]) for r in roc_group]
AUCs.append(AUC)
all_AUCs.append(AUCs)
all_AUCs = [zip(*a) for a in all_AUCs]
def subplotFactory(AUC_group, thresh):
colors = dict(
zip(experiments.iterkeys(), ['k', 'r', 'g', 'b', 'c', 'm']))
def doSubplot(multiplier=1.0, layout=(-1, -1)):
for idx, (exp, exp_name) in enumerate(experiments.iteritems()):
pylab.plot(temp.getTimes(),
AUC_group[idx],
label=exp_name,
color=colors[exp])
pylab.axhline(y=0.5, color='k', linestyle=':')
n_row, n_col = layout
if n_row == 2:
pylab.xlabel("Time (UTC)", size='large')
pylab.xlim(temp.getTimes()[0], temp.getTimes()[-1])
pylab.xticks(temp.getTimes(),
temp.getStrings("%H%M", aslist=True),
rotation=30,
size='x-large')
pylab.legend(loc=3)
else:
pylab.xlim(temp.getTimes()[0], temp.getTimes()[-1])
pylab.xticks(temp.getTimes(), ["" for t in temp])
pylab.ylabel(r"AUC (Reflectivity $\geq$ %d dBZ)" % thresh,
size='large')
pylab.ylim(0.4, 1.0)
pylab.yticks(size='x-large')
return
return doSubplot
subplots = []
for AUC_group, thresh in zip(all_AUCs, refl_thresh):
subplots.append(subplotFactory(AUC_group, thresh))
pylab.figure(figsize=(8, 9.5))
pylab.subplots_adjust(left=0.1,
right=0.95,
top=0.95,
bottom=0.1,
hspace=0.05)
publicationFigure(subplots, (2, 1), corner='ur')
pylab.savefig("roc_AUC.png")
pylab.close()
return
