def load_my_data_alt(data_path=None):
if data_path is None:
data_path = data_in
ca = utils.loadmat(os.path.join(data_path, 'C_alt.mat'))
cw = utils.loadmat(os.path.join(data_path, 'C_altw.mat'))
ca['tdt'] = utils.datenum_to_datetime(ca['t'])
cw['tdt'] = utils.datenum_to_datetime(cw['t'])
return ca, cw
def scatter_section(Float, hpids, var, x_var='dist', cmap=plt.get_cmap('jet')):
z_vals = np.arange(-1500., -40., 20.)
__, z, var = Float.get_interp_grid(hpids, z_vals, 'z', var)
if x_var == 'dist':
__, __, d = Float.get_interp_grid(hpids, z_vals, 'z', 'dist_ctd')
d = d.flatten(order='F')
elif x_var == 'time':
__, __, d = Float.get_interp_grid(hpids, z_vals, 'z', 'UTC')
d = d.flatten(order='F')
d = utils.datenum_to_datetime(d)
else:
raise ValueError("Input x_var should be 'dist' or 'time'.")
z = z.flatten(order='F')
var = var.flatten(order='F')
plt.figure()
plt.scatter(d, z, c=var, edgecolor='none', cmap=cmap)
plt.ylim(np.min(z), np.max(z))
plt.xlim(np.min(d), np.max(d))
plt.colorbar(orientation='horizontal', extend='both')
def scatter_section(Float, hpids, var, x_var='dist', cmap=plt.get_cmap('jet')):
z_vals = np.arange(-1500., -40., 20.)
__, z, var = Float.get_interp_grid(hpids, z_vals, 'z', var)
if x_var == 'dist':
__, __, d = Float.get_interp_grid(hpids, z_vals, 'z', 'dist_ctd')
d = d.flatten(order='F')
elif x_var == 'time':
__, __, d = Float.get_interp_grid(hpids, z_vals, 'z', 'UTC')
d = d.flatten(order='F')
d = utils.datenum_to_datetime(d)
else:
raise ValueError("Input x_var should be 'dist' or 'time'.")
z = z.flatten(order='F')
var = var.flatten(order='F')
plt.figure()
plt.scatter(d, z, c=var, edgecolor='none', cmap=cmap)
plt.ylim(np.min(z), np.max(z))
plt.xlim(np.min(d), np.max(d))
plt.colorbar(orientation='horizontal', extend='both')
def load_my_data(data_path=None, ret_extras=False):
if data_path is None:
data_path = data_in
cc = utils.loadmat(os.path.join(data_path, 'C_raw.mat'))
nw = utils.loadmat(os.path.join(data_path, 'NW_raw.mat'))
ne = utils.loadmat(os.path.join(data_path, 'NE_raw.mat'))
se = utils.loadmat(os.path.join(data_path, 'SE_raw.mat'))
sw = utils.loadmat(os.path.join(data_path, 'SW_raw.mat'))
moorings = [cc, nw, ne, se, sw]
for m in moorings:
m['tdt'] = utils.datenum_to_datetime(m['t'])
if ret_extras:
dt_min = 15.
extras = {
"dt_min": dt_min,
"dt_sec": dt_min*60.,
"dt_day": dt_min/1440.,
"N_per_day": 96,
}
return moorings, extras
else:
return moorings
bbox=dict(facecolor="w", edgecolor="w", boxstyle="square", alpha=0.8),
dx=0.01,
dy=-0.02,
)
cfs.axes_labels(
fig,
axp,
i0=4,
bbox=dict(facecolor="w", edgecolor="w", boxstyle="square", alpha=0.8),
dx=0.1,
dy=-0.03,
)
axs[0].fill_betweenx(
axs[0].get_ylim(),
utils.datenum_to_datetime(t0),
utils.datenum_to_datetime(t1),
color="k",
alpha=0.2,
linewidth=0,
)
plt.setp(axs[-1].xaxis.get_majorticklabels(),
rotation=-45,
ha="left",
rotation_mode="anchor")
if save_figs:
fig_name = "horizontal_energy_flux_all_levels.pdf"
fig.savefig(os.path.join(fsd, fig_name),
dpi=300,
bbox_inches="tight",
def spew_track(Floats, dt=12., fstr='test'):
"""Given a sequence of floats this function plots a time-lapse of
their tracks onto bathymetry
If you want it to work for one float you must put it in a sequence.
"""
t_mins, t_maxs = [], []
for Float in Floats:
t_mins.append(np.min(Float.UTC_start))
t_maxs.append(np.max(Float.UTC_start))
t_min = np.min(t_mins)
t_max = np.max(t_maxs)
ti = np.arange(t_min, t_max, dt / 24.)
lons = np.empty((ti.size, len(Floats)))
lats = np.empty((ti.size, len(Floats)))
for i, Float in enumerate(Floats):
lon = Float.lon_start
lat = Float.lat_start
t = Float.UTC_start
lons[:, i] = np.interp(ti, t, lon, left=np.nan, right=np.nan)
lats[:, i] = np.interp(ti, t, lat, left=np.nan, right=np.nan)
llcrnrlon = np.floor(np.nanmin(lons)) - 1.
llcrnrlat = np.floor(np.nanmin(lats)) - 1.
urcrnrlon = np.ceil(np.nanmax(lons)) + 1.
urcrnrlat = np.ceil(np.nanmax(lats)) + 1.
lon_lat = np.array([llcrnrlon, -30., -70, urcrnrlat])
lon_grid, lat_grid, bathy_grid = sandwell.read_grid(lon_lat)
bathy_grid[bathy_grid > 0] = 0
m = bm.Basemap(projection='tmerc',
llcrnrlon=llcrnrlon,
llcrnrlat=llcrnrlat,
urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat,
lon_0=0.5 * (llcrnrlon + urcrnrlon),
lat_0=0.5 * (llcrnrlat + urcrnrlat),
resolution='f')
plt.figure(figsize=(10, 10))
x, y = m(lon_grid, lat_grid)
m.pcolormesh(x, y, bathy_grid, cmap=plt.get_cmap('binary_r'))
m.fillcontinents()
m.drawcoastlines()
r = np.abs((urcrnrlon - llcrnrlon) / (urcrnrlat - llcrnrlat))
if r > 1.:
Nm = 8
Np = max(3, np.round(Nm / r))
elif r < 1.:
Np = 8
Nm = max(3, np.round(Nm / r))
parallels = np.round(np.linspace(llcrnrlat, urcrnrlat, Np), 1)
m.drawparallels(parallels, labels=[1, 0, 0, 0])
meridians = np.round(np.linspace(llcrnrlon, urcrnrlon, Nm), 1)
m.drawmeridians(meridians, labels=[0, 0, 0, 1])
colours = ['b', 'r', 'm', 'c', 'g', 'y']
for i, (time, lonr, latr) in enumerate(zip(ti, lons, lats)):
print('Creating... {i:03d}'.format(i=i))
plt.title(utils.datenum_to_datetime(time).strftime('%Y-%m-%d %H:%M'))
for j, (lon, lat) in enumerate(zip(lonr, latr)):
x, y = m(lon, lat)
m.plot(x, y, '.', color=colours[j])
if i == 0:
leg_str = [str(Float.floatID) for Float in Floats]
plt.legend(leg_str, loc=0)
save_name = '../figures/animated_tracks/{}{i:03d}.png'.format(fstr,
i=i)
plt.savefig(save_name, bbox_inches='tight')
print('Finished.')
m.drawcoastlines()
r = np.abs((urcrnrlon - llcrnrlon) / (urcrnrlat - llcrnrlat))
if r > 1.:
Nm = 8
Np = max(3, np.round(Nm / r))
elif r < 1.:
Np = 8
Nm = max(3, np.round(Nm / r))
parallels = np.round(np.linspace(llcrnrlat, urcrnrlat, Np), 1)
m.drawparallels(parallels, labels=[1, 0, 0, 0])
meridians = np.round(np.linspace(llcrnrlon, urcrnrlon, Nm), 1)
m.drawmeridians(meridians, labels=[0, 0, 0, 1])
for i, (time, lonr, latr) in enumerate(zip(ti, lons, lats)):
print('Creating... {i:03d}'.format(i=i))
plt.title(utils.datenum_to_datetime(time).strftime('%Y-%m-%d %H:%M'))
for j, (lon, lat) in enumerate(zip(lonr, latr)):
x, y = m(lon, lat)
m.plot(x, y, '.', color='r')
save_name = '../figures/animated_tracks/{}{i:03d}.png'.format(fstr, i=i)
plt.savefig(save_name, bbox_inches='tight')
print('Finished.')
def spew_track(Floats, dt=12., fstr='test'):
"""Given a sequence of floats this function plots a time-lapse of
their tracks onto bathymetry
If you want it to work for one float you must put it in a sequence.
"""
t_mins, t_maxs = [], []
for Float in Floats:
t_mins.append(np.min(Float.UTC_start))
t_maxs.append(np.max(Float.UTC_start))
t_min = np.min(t_mins)
t_max = np.max(t_maxs)
ti = np.arange(t_min, t_max, dt/24.)
lons = np.empty((ti.size, len(Floats)))
lats = np.empty((ti.size, len(Floats)))
for i, Float in enumerate(Floats):
lon = Float.lon_start
lat = Float.lat_start
t = Float.UTC_start
lons[:, i] = np.interp(ti, t, lon, left=np.nan, right=np.nan)
lats[:, i] = np.interp(ti, t, lat, left=np.nan, right=np.nan)
llcrnrlon = np.floor(np.nanmin(lons)) - 1.
llcrnrlat = np.floor(np.nanmin(lats)) - 1.
urcrnrlon = np.ceil(np.nanmax(lons)) + 1.
urcrnrlat = np.ceil(np.nanmax(lats)) + 1.
lon_lat = np.array([llcrnrlon, -30., -70, urcrnrlat])
lon_grid, lat_grid, bathy_grid = sandwell.read_grid(lon_lat)
bathy_grid[bathy_grid > 0] = 0
m = bm.Basemap(projection='tmerc', llcrnrlon=llcrnrlon,
llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat, lon_0=0.5*(llcrnrlon+urcrnrlon),
lat_0=0.5*(llcrnrlat+urcrnrlat), resolution='f')
plt.figure(figsize=(10, 10))
x, y = m(lon_grid, lat_grid)
m.pcolormesh(x, y, bathy_grid, cmap=plt.get_cmap('binary_r'))
m.fillcontinents()
m.drawcoastlines()
r = np.abs((urcrnrlon-llcrnrlon)/(urcrnrlat-llcrnrlat))
if r > 1.:
Nm = 8
Np = max(3, np.round(Nm/r))
elif r < 1.:
Np = 8
Nm = max(3, np.round(Nm/r))
parallels = np.round(np.linspace(llcrnrlat, urcrnrlat, Np), 1)
m.drawparallels(parallels, labels=[1, 0, 0, 0])
meridians = np.round(np.linspace(llcrnrlon, urcrnrlon, Nm), 1)
m.drawmeridians(meridians, labels=[0, 0, 0, 1])
colours = ['b', 'r', 'm', 'c', 'g', 'y']
for i, (time, lonr, latr) in enumerate(zip(ti, lons, lats)):
print('Creating... {i:03d}'.format(i=i))
plt.title(utils.datenum_to_datetime(time).strftime('%Y-%m-%d %H:%M'))
for j, (lon, lat) in enumerate(zip(lonr, latr)):
x, y = m(lon, lat)
m.plot(x, y, '.', color=colours[j])
if i == 0:
leg_str = [str(Float.floatID) for Float in Floats]
plt.legend(leg_str, loc=0)
save_name = '../figures/animated_tracks/{}{i:03d}.png'.format(fstr,
i=i)
plt.savefig(save_name, bbox_inches='tight')
print('Finished.')
t, w = t[use], w[use]
posidxs = detect_peaks(w, mph=0.05, mpd=100.)
negidxs = detect_peaks(w, mph=0.05, mpd=100., valley=True)
pidxs = np.sort(np.hstack((negidxs, posidxs)))
# TF = np.arange(len(pidxs))
# tpeaks = t[pidxs]
# pidxsef = np.searchsorted(tef, tpeaks)
# t = utils.datenum_to_datetime(t)
# tef = utils.datenum_to_datetime(tef)
fig, ax = plt.subplots(1, 1, figsize=(6, 2.5))
ax.plot(utils.datenum_to_datetime(t), w)
ax.plot(utils.datenum_to_datetime(t[pidxs]), w[pidxs], 'ro')
ax.set_ylabel('$w$ (m s$^{-1}$)')
ax.set_xlabel('Time (month-day hour)')
fig.savefig(os.path.join(sdir, 'peak_finding_example.pdf'), bbox_inches='tight', pad_inches=0.)
# %% NOTE: THIS METHOD IS OBSOLETE AND PROVEN NOT TO WORK
# Estimate position (x, z, t) of wave peaks from combination of profiles 31 and
# 32 from float 4976.
xq = np.array([0., 516.66576652, 882., 1512.23911972, 1994.01441055, 2825.66675334,
3584.75880071, 4620.14505228, 5247.30421987, 5964.80873041])
zq = np.array([-602.50953952, -788.92712687, -1000., -1246.54503641, -1376.43262381, -1573.86360897,
-1352.10223918, -1026.39032746, -807.29489018, -567.31845563,])
tq = np.array([0., 1081., 2000., 3164.00000763, 4172., 5911.99999237,
ctd = CTD.apply_thermodynamics(ctd)
ctd = CTD.apply_adiabatic_level(ctd, bin_width)
ctd.depth_max = CTD.depth_max(ctd.depth, np.isfinite(ctd.t))
ctd = utils.apply_utm(ctd)
insection = np.full((len(secs), vmp.time.size), False)
section = np.arange(len(secs)) + 1
for i, sec in enumerate(secs):
insection[i, sec.profiles.index.astype(int) - 1] = True
time_start = np.hstack(
[utils.datenum_to_datetime(sec.starttime) for sec in secs])
time_end = np.hstack([utils.datenum_to_datetime(sec.endtime) for sec in secs])
lon_start = np.hstack([sec.startlon for sec in secs])
lon_end = np.hstack([sec.endlon for sec in secs])
lat_start = np.hstack([sec.startlat for sec in secs])
lat_end = np.hstack([sec.endlat for sec in secs])
section_description = np.hstack([sec.description for sec in secs])
ctd_datavars = {
"SP": (["depth", "profile"], ctd.SP, {
"Variable": "Practical salinity"
}),
"t": (["depth", "profile"], ctd.t, {
"Variable": "Temperature (in situ)"
}),
"CT": (["depth", "profile"], ctd.CT, {
tctd = getattr(Float, 'UTC')[:, idxs].flatten(order='F')
nans = np.isnan(d) | np.isnan(tctd)
tctd = tctd[~nans]
dctd = d[~nans]
lonctd = np.interp(tctd, tgps, lon)
latctd = np.interp(tctd, tgps, lat)
bathy = sandwell.interp_track(lonctd, latctd, bf)
# Zero the distances at the top of the sea mount.
d -= dctd[bathy.argmax()]
for ax, dmin, dmax in zip(axs, depth_mins, depth_maxs):
in_range = (z > dmin) & (z < dmax)
C = ax.scatter(d[in_range], utils.datenum_to_datetime(t[in_range]),
c=Ww[in_range], s=30, cmap=bwr, vmin=-0.08, vmax=0.08)
ax.set_ylim(datetime.datetime(2011, 1, 2, 12),
datetime.datetime(2011, 1, 4, 6))
ax.set_xlim(-20, 40)
ax.set_xlabel('Distance (km)')
ax.set_title("{} to {} m".format(dmin, dmax))
#divider2 = make_axes_locatable(axs[2])
#cax2 = divider2.append_axes("right", size="10%", pad=0.4)
#cbar = plt.colorbar(C, cax=cax2, extend='both')
fmt = mdates.DateFormatter('%j %Hh')
axs[0].yaxis.set_major_formatter(fmt)
axs[0].set_ylabel('Time')
cbar = plt.colorbar(C, extend='both')
"Variable": "Absolute salinity"
}),
"ba": (["depth_adcp", "time"], adcp.b, {
"Variable": "Buoyancy"
}),
"sig0a": (
["depth_adcp", "time"],
adcp.sig0,
{
"Variable": "Potential density referenced to 0 dbar"
},
),
}
coords = {
"time": (["time"], utils.datenum_to_datetime(ctd.time)),
"depth": (["i", "time"], ctd.depth),
"depth_adcp": (["depth_adcp"], adcp.depth),
"depth_nominal": (["i"], ctd.depth_nominal),
"lon": ([], ctd.lon),
"lat": ([], ctd.lat),
"x": ([], ctd.x),
"y": ([], ctd.y),
"zone_letter": ([], ctd.zone_letter),
"zone_number": ([], ctd.zone_number),
"p": (["i", "time"], ctd.p),
"p_mid": (["i_mid", "time"], ctd.p_mid),
}
ds = xr.Dataset(datavars, coords)
file = "deep_mooring_sep_2018.nc"
elif a.size == 1:
sec_tstart.append(ctd.time[a - 1] - 60 / 86400)
sec_tend.append(ctd.time[a - 1] + 60 / 86400)
else:
sec_tstart.append(ctd.time[a[0] - 1] - 60 / 86400)
sec_tend.append(ctd.time[a[-1] - 1] + 60 / 86400)
ctd.SA = gsw.SA_from_SP(ctd.S, ctd.P, ctd.lon[np.newaxis, :],
ctd.lat[np.newaxis, :])
ctd.CT = gsw.CT_from_t(ctd.SA, ctd.T, ctd.P)
ctd.sig0 = gsw.pot_rho_t_exact(ctd.SA, ctd.T, ctd.P, 0)
ctd_datavars = {
"times": (
["depth", "profile"],
utils.datenum_to_datetime(ctd.time_full),
{
"Variable": "Measurement time"
},
),
"p": (["depth", "profile"], ctd.P, {
"Variable": "Pressure"
}),
"SP": (["depth", "profile"], ctd.S, {
"Variable": "Practical salinity"
}),
"t": (["depth", "profile"], ctd.T, {
"Variable": "Temperature (in situ)"
}),
"CT": (["depth", "profile"], ctd.CT, {
"Variable": "Conservative temperature"
pf.my_savefig(fig,
'both',
'w_hist',
sdir,
ftype=('png', 'pdf'),
fsize='single_col')
# %% Ws Wf W time series ######################################################
hpids = np.arange(51, 59)
pfls = E76.get_profiles(hpids)
fig, ax = plt.subplots(1, 1, figsize=(6, 3))
for i, pfl in enumerate(pfls):
t = utils.datenum_to_datetime(pfl.UTC)
wf = pfl.Wz
ws = pfl.Ws
ww = pfl.Ww
use = pfl.P > 60
if i == 0:
ax.plot(t[use], wf[use], 'g', label='$w_f$')
ax.plot(t[use], ws[use], 'r', label='$w_s$')
ax.plot(t[use], ww[use], 'b', label='$w$')
else:
ax.plot(t[use], wf[use], 'g', label=None)
ax.plot(t[use], ws[use], 'r', label=None)
ax.plot(t[use], ww[use], 'b', label=None)
{
"Variable":
"Adiabatically leveled buoyancy frequency, using {:1.0f} dbar bin".
format(bin_width)
},
),
"depth_max": (["profile"], ctd.depth_max, {
"Variable": "Maximum valid data depth"
}),
}
ctd_coords = {
"profile": (["profile"], np.arange(ctd.time.size) + 1),
"depth": (["depth"], ctd.depth),
"depth_mid": (["depth_mid"], utils.mid(ctd.depth)),
"time": (["profile"], utils.datenum_to_datetime(ctd.time)),
"lon": (["profile"], ctd.lon),
"lat": (["profile"], ctd.lat),
"x": (["profile"], ctd.x),
"y": (["profile"], ctd.y),
"zone_letter": ([], ctd.zone_letter),
"zone_number": ([], ctd.zone_number),
"p": (["depth"], ctd.p),
"p_mid": (["depth_mid"], ctd.p_mid),
}
ctd_ds = xr.Dataset(ctd_datavars, ctd_coords)
file = "ctd_aug_2016.nc"
print("Saving to '{}'".format(os.path.join(sdroot, file)))
ctd_ds.to_netcdf(os.path.join(sdroot, file))
Nbins = len(zbins) - 1
rho0 = 1025.
fig, axs = plt.subplots(2, 1, sharex='col', figsize=(6.5, 5))
for i, Float in enumerate([E76, E77]):
__, idxs = Float.get_profiles(hpid, ret_idxs=True)
__, idxs_d = Float.get_profiles(down_hpid, ret_idxs=True)
__, idxs_u = Float.get_profiles(up_hpid, ret_idxs=True)
U = Float.U_abs[:, idxs]
V = Float.V_abs[:, idxs]
z = Float.zef[:, idxs]
t = Float.UTC_start[idxs]
tp = (t[:-2] + t[2:]) / 2
tp = utils.datenum_to_datetime(tp)
Np = len(idxs)
Ubin = np.NaN * np.zeros((Nbins, Np))
Vbin = np.NaN * np.zeros((Nbins, Np))
for j in xrange(len(idxs)):
Ubin[:, j], __, __ = binned_statistic(z[:, j],
U[:, j],
statistic=np.nanmean,
bins=zbins)
Vbin[:, j], __, __ = binned_statistic(z[:, j],
V[:, j],
statistic=np.nanmean,
bins=zbins)
bbox=dict(facecolor="w", edgecolor="w", boxstyle="square", alpha=0.8),
dx=0.01,
dy=-0.02,
)
cfs.axes_labels(
fig,
axp,
i0=4,
bbox=dict(facecolor="w", edgecolor="w", boxstyle="square", alpha=0.8),
dx=0.0,
dy=-0.03,
)
axs[3].fill_betweenx(
axs[3].get_ylim(),
utils.datenum_to_datetime(t0),
utils.datenum_to_datetime(t1),
color="k",
alpha=0.2,
linewidth=0,
)
plt.setp(axs[-1].xaxis.get_majorticklabels(),
rotation=-45,
ha="left",
rotation_mode="anchor")
axs[-1].tick_params(axis="x", which="major", pad=25)
if save_figs:
fig_name = "vertical_energy_flux_all_levels.pdf"
fig.savefig(os.path.join(fsd, fig_name),
