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 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
def doMInnov(radar, model_path, obs_path, t_ens, base_time, analysis=True):
if analysis:
state = "an"
else:
state = "bg"
try:
model_obs = ARPSModelObsFile("%s/%s%s%06d" %
(model_path, radar, state, t_ens))
except AssertionError:
model_obs = ARPSModelObsFile("%s/%s%s%06d" %
(model_path, radar, state, t_ens),
mpi_config=(2, 12))
except IOError:
return np.nan, np.nan
radar_obs = RadarObsFile(
"%s/%s.%s" %
(obs_path, radar,
(base_time + timedelta(seconds=t_ens)).strftime("%Y%m%d.%H%M%S")))
good_idxs_refl = np.where((radar_obs['Z'] > -90) & (model_obs['Z'] > -90)
& ((radar_obs['Z'] > 15)
| (model_obs['Z'] > 15)))
good_idxs_vel = np.where((radar_obs['vr'] > -90) & (model_obs['vr'] > -90)
& ((radar_obs['Z'] > 15) | (model_obs['Z'] > 15)))
minnov_refl = minnov(model_obs['Z'][good_idxs_refl],
radar_obs['Z'][good_idxs_refl])
minnov_vel = minnov(model_obs['vr'][good_idxs_vel],
radar_obs['vr'][good_idxs_vel])
return minnov_refl, minnov_vel
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)
def findROCs(base_path, obs_path, t_ens, base_time, radar, n_ens_members, prob_thresholds, refl_thresholds):
ens_obs = []
state = "an"
print "Working on time %06d ..." % t_ens
try:
for n_ens in range(n_ens_members):
# print "Loading member %d ..." % (n_ens + 1)
model_obs = ARPSModelObsFile("%s/%s%03d%s%06d" % (base_path, radar, n_ens + 1, state, t_ens))
ens_obs.append(model_obs)
except AssertionError:
for n_ens in range(n_ens_members):
print "Loading member %d ..." % (n_ens + 1)
model_obs = ARPSModelObsFile("%s/%s%03d%s%06d" % (base_path, radar, n_ens + 1, state, t_ens), mpi_config=(2, 12))
ens_obs.append(model_obs)
except IOError as e:
print "IOError:", e
return [ [ (np.nan, np.nan), (np.nan, np.nan) ] ]
ens_refl = np.empty((len(ens_obs),) + ens_obs[0]['Z'].shape, dtype=float)
for idx in range(len(ens_obs)):
ens_refl[idx] = ens_obs[idx]['Z']
rof_name = "%s/%s.%s" % (obs_path, radar, (base_time + timedelta(seconds=t_ens)).strftime("%Y%m%d.%H%M%S"))
radar_obs = RadarObsFile(rof_name)
obs_refl = radar_obs['Z']
good_obs = (obs_refl >= 15) & np.any(ens_refl >= 15, axis=0) #& ((obs_refl[np.newaxis, ...] >= 15) | (ens_refl >= 15))
rocs = []
for r_thresh in refl_thresholds:
ens_prob = ensembleProbability(ens_refl, r_thresh)
roc = [(1., 1.)]
for p_thresh in prob_thresholds:
pod = POD(ens_prob, obs_refl, p_thresh, r_thresh, good_obs)
pofd = POFD(ens_prob, obs_refl, p_thresh, r_thresh, good_obs)
if np.isnan(pod): pod = 0.
if np.isnan(pofd): pofd = 1.
roc.append((pod, pofd))
roc.append((0., 0.))
rocs.append(roc)
return rocs
def doETS(radar, model_path, obs_path, t_ens, base_time, refl_threshold, vel_threshold, grid, n_ens_members=-1, prob_threshold=0.5, bbox=(slice(None), slice(None), slice(None))):
try:
radar_obs = RadarObsFile("%s/%s.%s" % (obs_path, radar, (base_time + timedelta(seconds=t_ens)).strftime("%Y%m%d.%H%M%S")))
except IOError:
return np.nan, np.nan, np.nan, np.nan
if n_ens_members <= 0:
try:
model_obs = ARPSModelObsFile("%s/%san%06d" % (model_path, radar, t_ens))
except AssertionError:
model_obs = ARPSModelObsFile("%s/%san%06d" % (model_path, radar, t_ens), mpi_config=(2, 12))
except IOError:
return np.nan, np.nan, np.nan, np.nan
good_markers_refl = (model_obs['vr'] > -90)
good_markers_vel = (model_obs['Z'] > 15) & (radar_obs['Z'] > 15)# & ((model_obs['Z'] > 15) | (obs_refl > 15))
ets_refl, confusion_refl = ETS(model_obs['Z'], radar_obs['Z'], refl_threshold, good_markers_refl, bbox=bbox)
ets_vel, confusion_vel = ETS(np.abs(model_obs['vr']), np.abs(radar_obs['vr']), vel_threshold, good_markers_vel, bbox=bbox)
else:
model_obs = []
for n_ens in range(n_ens_members):
try:
model_obs.append(ARPSModelObsFile("%s/%s%03dan%06d" % (model_path, radar, n_ens + 1, t_ens)))
except AssertionError:
model_obs.append(ARPSModelObsFile("%s/%s%03dan%06d" % (model_path, radar, n_ens + 1, t_ens), mpi_config=(2, 12)))
except IOError:
return np.nan, np.nan, np.nan, np.nan
model_refl = np.array([ m['Z'] for m in model_obs ])
model_vel = np.array([ m['vr'] for m in model_obs ])
good_markers_refl = (model_vel.mean(axis=0) > -90)
good_markers_vel = (model_refl.mean(axis=0) > 15) & (radar_obs['Z'] > 15)# & ((model_obs['Z'] > 15) | (obs_refl > 15))
ets_refl, confusion_refl = ETSens(model_refl, radar_obs['Z'], prob_threshold, refl_threshold, good_markers_refl, bbox=bbox)
ets_vel, confusion_vel = ETSens(np.abs(model_vel), np.abs(radar_obs['vr']), prob_threshold, vel_threshold, good_markers_vel, bbox=bbox)
# if radar == "KCYS":
# plotConfusion(confusion_refl[0], grid, "Contingency for %s" % radar, "confusion_%s_tilt00_%06d.png" % (radar, t_ens))
return ets_refl, ets_vel, confusion_refl, confusion_vel
def main():
arps_mo = ARPSModelObsFile("/caps1/tsupinie/3km-fixed-radar/KCYSan014400", (2, 12))
python_mo = cPickle.load(open("3km-fixed-radar/eomean.pkl014400", 'r'))
grid = goshen_3km_grid()#bounds=(slice(242, 327), slice(199, 284)))
radar_x, radar_y = grid(arps_mo._radar_lon, arps_mo._radar_lat)
print radar_x, arps_mo._radar_x
print radar_y, arps_mo._radar_y
xs, ys = grid.getXY()
bounds = grid.getBounds()
Re = 6371000.
range = np.hypot(xs - radar_x, ys - radar_y)
slant_range = Re * np.tan(range / Re)
range_mask = (range < arps_mo._range_max) & (range > arps_mo._range_min)
height_error = arps_mo._height[0][bounds] - coneHeight(range, arps_mo._elev_angles[0] + 0.06, 1867.)
height_error_masked = np.where(range < arps_mo._range_max - 12000, height_error, np.nan)
print np.nanmin(height_error_masked), np.nanmax(height_error_masked)
pylab.figure(figsize=(12,6))
pylab.subplot(121)
pylab.pcolormesh(xs, ys, arps_mo['Z'][0][bounds], vmin=10, vmax=80, cmap=pylab.jet())
# pylab.pcolormesh(xs, ys, height_error_masked, vmin=-200, vmax=200, cmap=matplotlib.cm.get_cmap('RdBu'))
pylab.colorbar()
pylab.title("ARPS")
grid.drawPolitical()
pylab.subplot(122)
pylab.pcolormesh(xs, ys, python_mo['Z'][0, 0][bounds], vmin=10, vmax=80, cmap=matplotlib.cm.get_cmap('jet'))
pylab.title("Python")
grid.drawPolitical()
pylab.savefig("model_obs_comparison.png")
pylab.close()
cPickle.dump(arps_mo._height, open("beam_height.pkl", 'w'), -1)
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/"
experiments = OrderedDict([('1kmf-sndr0h=25km', 'CTRL'),
('1kmf-zs25-offtime-05XP', 'CTRL_OFF')])
times = {'1kmf-sndr0h=25km': '220000', '1kmf-zs25-offtime-05XP': '215719'}
bounds = (slice(110, 135), slice(118, 143))
grid = goshen_1km_grid(bounds)
bounds = grid.getBounds()
radar_obs = []
model_obs = []
for exp in experiments.iterkeys():
radar_obs.append(
RadarObsFile("qc/1km/vols/05XP.20090605.%s" % times[exp]))
try:
mo = ARPSModelObsFile("%s/%s/05XPbg014400" % (base_path, exp))
except AssertionError:
mo = ARPSModelObsFile("%s/%s/05XPbg014400" % (base_path, exp),
mpi_config=(2, 12))
except:
print "Couldn't load radial velocity."
mo = {'vr': np.zeros((1, 255, 255), dtype=np.float32)}
model_obs.append(mo)
xs, ys = grid.getXY()
def subplotFactory(radar_obs, model_obs):
vr_obs = np.where(radar_obs['Z'] < 15, np.nan, radar_obs['vr'])
def doSubplot(multiplier=1.0, layout=(-1, -1)):
pylab.contour(xs,
ys,
vr_obs[0][bounds],
colors='k',
linestyles='-',
levels=np.arange(-50, 60, 10))
pylab.contour(xs,
ys,
model_obs['vr'][0][bounds],
colors='k',
linestyles='--',
levels=np.arange(-50, 60, 10))
pylab.contourf(xs,
ys, (model_obs['vr'][0] - vr_obs[0])[bounds],
cmap=matplotlib.cm.get_cmap('RdBu_r'),
zorder=-1)
grid.drawPolitical()
return
return doSubplot
subplots = []
for robs, mobs in zip(radar_obs, model_obs):
subplots.append(subplotFactory(robs, mobs))
pylab.figure(figsize=(12, 8))
publicationFigure(subplots, (1, 2),
corner='ur',
colorbar=("$v_r$ difference (m s$^{-1}$)", "%d",
np.arange(-10, 11, 1)))
pylab.savefig("radar_obs_comparison.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():
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 computeReliability(base_path, obs_path, t_ens, base_time, radar,
n_ens_members, prob_bins, refl_thresholds):
ens_obs = []
state = "an"
print "Working on time %06d ..." % t_ens
try:
for n_ens in range(n_ens_members):
# print "Loading member %d ..." % (n_ens + 1)
model_obs = ARPSModelObsFile(
"%s/%s%03d%s%06d" %
(base_path, radar, n_ens + 1, state, t_ens))
ens_obs.append(model_obs)
except AssertionError:
for n_ens in range(n_ens_members):
# print "Loading member %d ..." % (n_ens + 1)
model_obs = ARPSModelObsFile(
"%s/%s%03d%s%06d" %
(base_path, radar, n_ens + 1, state, t_ens),
mpi_config=(2, 12))
ens_obs.append(model_obs)
except IOError:
return np.nan
ens_refl = np.empty((len(ens_obs), ) + ens_obs[0]['Z'].shape, dtype=float)
for idx in range(len(ens_obs)):
ens_refl[idx] = ens_obs[idx]['Z']
radar_obs = RadarObsFile(
"%s/%s.%s" %
(obs_path, radar,
(base_time + timedelta(seconds=t_ens)).strftime("%Y%m%d.%H%M%S")))
obs_refl = radar_obs['Z']
reliabilities = []
samples = []
for r_thresh in refl_thresholds:
reliability = np.empty((prob_bins.shape[0] - 1, ), dtype=float)
sample = np.empty((prob_bins.shape[0] - 1, ), dtype=float)
ens_prob = ensembleProbability(ens_refl, r_thresh)
for bin_no in range(prob_bins.shape[0] - 1):
bin_lb = prob_bins[bin_no]
bin_ub = prob_bins[bin_no + 1]
if bin_no < prob_bins.shape[0] - 2:
bin_points = ((ens_prob >= bin_lb) & (ens_prob < bin_ub))
else:
bin_points = ((ens_prob >= bin_lb) & (ens_prob <= bin_ub))
verif_bin_points = (obs_refl >= r_thresh) & bin_points
n_points = bin_points.sum()
n_verif_points = verif_bin_points.sum()
reliability[bin_no] = float(n_verif_points) / n_points
sample[bin_no] = n_points
reliabilities.append(reliability)
samples.append(sample)
return reliabilities, samples
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