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 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),