From 5994999046b2dfae505c83ead81491e07e811dc3 Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Thu, 22 Jun 2023 17:40:33 +0200 Subject: [PATCH 01/12] initial quicklook commit --- src/halodrops/plotting/quicklooks.py | 167 +++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) create mode 100644 src/halodrops/plotting/quicklooks.py diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/plotting/quicklooks.py new file mode 100644 index 0000000..34c5f18 --- /dev/null +++ b/src/halodrops/plotting/quicklooks.py @@ -0,0 +1,167 @@ +from halodrops import sonde +from halodrops.helper import paths +from halodrops.qc import profile + +from importlib import reload +from gogoesgone import processing as pr +from gogoesgone import zarr_access as za + +reload(pr) +reload(za) + +import xarray as xr +import numpy as np +import cartopy as cp +import cartopy.crs as ccrs +from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER +from cartopy.feature import LAND +import cartopy.feature as cfeature +from matplotlib.offsetbox import AnchoredText +import matplotlib.pyplot as plt +import matplotlib.ticker as mticker +from mpl_toolkits.axes_grid1 import make_axes_locatable +import matplotlib.dates as mdates +from datetime import datetime, date +import s3fs +import pandas as pd + + +def get_mean_launch_time(ds_flight=None, time_format="%Y%m%d %H:%M:%S"): + + """ + Compute mean launch time from all sondes in the dataset. + """ + + mean_time = ds_flight.launch_time.mean().values + + return mean_time + + +def get_satellite_data( + satellite_time="mean_launch_time", + time_format="%Y%m%d %H:%M:%S", + satellite_name="goes16", + channel=13, + product="ABI-L2-CMIPF", + extent=(-62, -48, 10, 20), +): + + """ + Access satellite data for nearest time, map to lon/lat grid, and convert to dataset. + """ + + # Ensure time is in correct format + pd_time = pd.to_datetime(str(satellite_time)) + str_time = pd_time.strftime(time_format) + + # Get filepath to satellite data at nearest time. + flist = za.nearest_time_url(str_time, time_format, channel, product, satellite_name) + m = za.get_mapper_from_mzz(flist) + + # Select subset of satellite domain + img = pr.Image(m) + subset = img.subset_region_from_latlon_extents(extent, unit="degree") + + return subset + + +def launch_locations_map( + ds_flight=None, + save_filepath="/path/to/save/", + color_coding_var="IWV", + color_coding_cmap="gist_earth", + overlay_satellite=False, + satellite_data=None, + satellite_time=None, + extent=(-62, -48, 10, 20), + satellite_cmap="cubehelix_r", + satellite_vmin=280, + satellite_vmax=300, +): + + """ + Plot dropsonde launch locations, optionally over satellite images. + """ + + fig = plt.figure() + + ax = plt.axes(projection=ccrs.AzimuthalEquidistant()) + ax.coastlines(resolution="50m", linewidth=1.5) + ax.set_extent(extent, crs=ccrs.PlateCarree()) + + # Plot satellite image + if overlay_satellite == True: + sat_im = satellite_data.CMI.isel(t=0).plot( + ax=ax, + x="lon", + y="lat", + cmap=satellite_cmap, + add_colorbar=True, + cbar_kwargs={"pad": 0.15, "extend": "both", "aspect": 30}, + vmin=satellite_vmin, + vmax=satellite_vmax, + zorder=-1, + transform=ccrs.PlateCarree(), + ) + + # Plot flight path + ax.plot( + ds_flight["lon"].isel(alt=-700), + ds_flight["lat"].isel(alt=-700), + c="red", + linestyle=":", + transform=ccrs.PlateCarree(), + zorder=1, + ) + + # Plot launch locations + im_launches = ax.scatter( + ds_flight["lon"].isel(alt=-700), + ds_flight["lat"].isel(alt=-700), + marker="o", + edgecolor="grey", + s=60, + transform=ccrs.PlateCarree(), + c=ds_flight[color_coding_var], + cmap=color_coding_cmap, + ) + + # Assigning axes ticks + xticks = np.arange(-180, 180, 4) + yticks = np.arange(-90, 90, 4) + + # Setting up the gridlines + gl = ax.gridlines( + crs=ccrs.PlateCarree(), + draw_labels=True, + linewidth=1, + color="gray", + alpha=0.2, + linestyle="--", + ) + gl.xlocator = mticker.FixedLocator(xticks) + gl.ylocator = mticker.FixedLocator(yticks) + gl.xformatter = LONGITUDE_FORMATTER + gl.yformatter = LATITUDE_FORMATTER + gl.xlabel_style = {"size": 12, "color": "k"} + gl.ylabel_style = {"size": 12, "color": "k"} + + # Colorbar + cax = fig.add_axes([0.08, -0.05, 0.85, 0.02]) + g = fig.colorbar( + im_launches, + cax=cax, + orientation="horizontal", + shrink=0.5, + pad=0.02, + extend="both", + aspect=10, + ) + g.set_label(ds_flight[color_coding_var].long_name, fontsize=12) + plt.tick_params(labelsize=10) + + # Title + ax.set_title(f"Satellite Time = {satellite_image.t[0].values}", pad=10) + + # Save figure + plt.savefig(save_filepath, dpi=300, bbox_inches="tight") From 7ac95911000d193190ef541ffad4d443ce6c86f3 Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Thu, 22 Jun 2023 17:54:07 +0200 Subject: [PATCH 02/12] fix projection and adjust plot --- src/halodrops/plotting/quicklooks.py | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/plotting/quicklooks.py index 34c5f18..9768dc8 100644 --- a/src/halodrops/plotting/quicklooks.py +++ b/src/halodrops/plotting/quicklooks.py @@ -85,7 +85,7 @@ def launch_locations_map( fig = plt.figure() - ax = plt.axes(projection=ccrs.AzimuthalEquidistant()) + ax = plt.axes(projection=ccrs.PlateCarree()) ax.coastlines(resolution="50m", linewidth=1.5) ax.set_extent(extent, crs=ccrs.PlateCarree()) @@ -97,7 +97,7 @@ def launch_locations_map( y="lat", cmap=satellite_cmap, add_colorbar=True, - cbar_kwargs={"pad": 0.15, "extend": "both", "aspect": 30}, + cbar_kwargs={"pad": 0.15, "extend": "both", "aspect": 15, "shrink": 0.7}, vmin=satellite_vmin, vmax=satellite_vmax, zorder=-1, @@ -147,15 +147,9 @@ def launch_locations_map( gl.ylabel_style = {"size": 12, "color": "k"} # Colorbar - cax = fig.add_axes([0.08, -0.05, 0.85, 0.02]) + # cax = fig.add_axes([0.08, -0.05, 0.85, 0.02]) g = fig.colorbar( - im_launches, - cax=cax, - orientation="horizontal", - shrink=0.5, - pad=0.02, - extend="both", - aspect=10, + im_launches, orientation="horizontal", extend="both", aspect=30, pad=0.1 ) g.set_label(ds_flight[color_coding_var].long_name, fontsize=12) plt.tick_params(labelsize=10) From efaa98d5625132e1c48e2cf6678b59c45346e7ca Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Fri, 23 Jun 2023 12:00:16 +0200 Subject: [PATCH 03/12] fix satellite time selection and adjust plot --- src/halodrops/plotting/quicklooks.py | 39 +++++++++++++++++++++------- 1 file changed, 30 insertions(+), 9 deletions(-) diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/plotting/quicklooks.py index 9768dc8..7890492 100644 --- a/src/halodrops/plotting/quicklooks.py +++ b/src/halodrops/plotting/quicklooks.py @@ -26,13 +26,27 @@ import pandas as pd +def convert_time_to_str(time=None, time_format="%Y%m%d %H:%M:%S"): + + """ + Convert input time into desired string format. + """ + + # Ensure time is in correct format + timestamp = (time - np.datetime64("1970-01-01T00:00:00")) / np.timedelta64(1, "s") + datetime_time = datetime.utcfromtimestamp(timestamp) + str_time = datetime_time.strftime(time_format) + + return str_time + + def get_mean_launch_time(ds_flight=None, time_format="%Y%m%d %H:%M:%S"): """ Compute mean launch time from all sondes in the dataset. """ - mean_time = ds_flight.launch_time.mean().values + mean_time = convert_time_to_str(ds_flight.launch_time.mean().values, time_format) return mean_time @@ -40,6 +54,7 @@ def get_mean_launch_time(ds_flight=None, time_format="%Y%m%d %H:%M:%S"): def get_satellite_data( satellite_time="mean_launch_time", time_format="%Y%m%d %H:%M:%S", + ds_flight=None, satellite_name="goes16", channel=13, product="ABI-L2-CMIPF", @@ -48,14 +63,17 @@ def get_satellite_data( """ Access satellite data for nearest time, map to lon/lat grid, and convert to dataset. + By default use the mean launch time from dropsonde dataset. """ - # Ensure time is in correct format - pd_time = pd.to_datetime(str(satellite_time)) - str_time = pd_time.strftime(time_format) + # Get correct time for satellite data + if satellite_time == "mean_launch_time": + use_time = get_mean_launch_time(ds_flight=ds_flight) + else: + use_time = convert_time_to_str(time=satellite_time) # Get filepath to satellite data at nearest time. - flist = za.nearest_time_url(str_time, time_format, channel, product, satellite_name) + flist = za.nearest_time_url(use_time, time_format, channel, product, satellite_name) m = za.get_mapper_from_mzz(flist) # Select subset of satellite domain @@ -67,11 +85,11 @@ def get_satellite_data( def launch_locations_map( ds_flight=None, + satellite_data=None, save_filepath="/path/to/save/", color_coding_var="IWV", color_coding_cmap="gist_earth", overlay_satellite=False, - satellite_data=None, satellite_time=None, extent=(-62, -48, 10, 20), satellite_cmap="cubehelix_r", @@ -151,11 +169,14 @@ def launch_locations_map( g = fig.colorbar( im_launches, orientation="horizontal", extend="both", aspect=30, pad=0.1 ) - g.set_label(ds_flight[color_coding_var].long_name, fontsize=12) + g.set_label(ds_flight[color_coding_var].long_name, fontsize=10) plt.tick_params(labelsize=10) - # Title - ax.set_title(f"Satellite Time = {satellite_image.t[0].values}", pad=10) + # Format time stamp + title_time = convert_time_to_str( + time=satellite_data.t[0].values, time_format="%Y-%m-%d %H:%M:%S" + ) + ax.set_title(f"Satellite Time = {title_time}", pad=10) # Save figure plt.savefig(save_filepath, dpi=300, bbox_inches="tight") From 1328e86f17d8317d151bc71b05f4db7c456e8671 Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Mon, 26 Jun 2023 17:07:52 +0200 Subject: [PATCH 04/12] add more quicklook functions --- src/halodrops/plotting/quicklooks.py | 185 +++++++++++++++++++++++++-- 1 file changed, 172 insertions(+), 13 deletions(-) diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/plotting/quicklooks.py index 7890492..b8aa8ba 100644 --- a/src/halodrops/plotting/quicklooks.py +++ b/src/halodrops/plotting/quicklooks.py @@ -87,12 +87,11 @@ def launch_locations_map( ds_flight=None, satellite_data=None, save_filepath="/path/to/save/", - color_coding_var="IWV", - color_coding_cmap="gist_earth", - overlay_satellite=False, + color_coding_var="flight_altitude", + color_coding_cmap="magma", satellite_time=None, - extent=(-62, -48, 10, 20), - satellite_cmap="cubehelix_r", + extent=(-61, -52, 10, 16), + satellite_cmap="Greys", satellite_vmin=280, satellite_vmax=300, ): @@ -101,21 +100,27 @@ def launch_locations_map( Plot dropsonde launch locations, optionally over satellite images. """ - fig = plt.figure() + fig = plt.figure(figsize=(10, 8)) ax = plt.axes(projection=ccrs.PlateCarree()) ax.coastlines(resolution="50m", linewidth=1.5) ax.set_extent(extent, crs=ccrs.PlateCarree()) # Plot satellite image - if overlay_satellite == True: + if satellite_data: sat_im = satellite_data.CMI.isel(t=0).plot( ax=ax, x="lon", y="lat", cmap=satellite_cmap, add_colorbar=True, - cbar_kwargs={"pad": 0.15, "extend": "both", "aspect": 15, "shrink": 0.7}, + cbar_kwargs={ + "pad": 0.1, + "extend": "both", + "aspect": 15, + "shrink": 0.7, + "label": f"{satellite_data.CMI.name} / {satellite_data.CMI.units}", + }, vmin=satellite_vmin, vmax=satellite_vmax, zorder=-1, @@ -161,15 +166,17 @@ def launch_locations_map( gl.ylocator = mticker.FixedLocator(yticks) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER - gl.xlabel_style = {"size": 12, "color": "k"} - gl.ylabel_style = {"size": 12, "color": "k"} + gl.xlabel_style = {"size": 10, "color": "k"} + gl.ylabel_style = {"size": 10, "color": "k"} # Colorbar - # cax = fig.add_axes([0.08, -0.05, 0.85, 0.02]) g = fig.colorbar( im_launches, orientation="horizontal", extend="both", aspect=30, pad=0.1 ) - g.set_label(ds_flight[color_coding_var].long_name, fontsize=10) + g.set_label( + f"{ds_flight[color_coding_var].name} / {ds_flight[color_coding_var].units}", + fontsize=12, + ) plt.tick_params(labelsize=10) # Format time stamp @@ -179,4 +186,156 @@ def launch_locations_map( ax.set_title(f"Satellite Time = {title_time}", pad=10) # Save figure - plt.savefig(save_filepath, dpi=300, bbox_inches="tight") + save_filename = f"{save_filepath}launch-locations-{color_coding_var}-{satellite_data.platform_ID}.png" + plt.savefig(save_filename, dpi=300, bbox_inches="tight") + + +def plot_lat_time( + ds_flight, + color_coding_var="flight_altitude", + color_coding_cmap="magma", + save_filepath="/path/to/save/", +): + + """ + Plot spatio-temporal variation (lat v/s time) of selected variable. + """ + + ax = plt.figure(figsize=(12, 4)) + plt.scatter( + ds_flight["launch_time"].values, + ds_flight["lat"].isel(alt=-700).values, + s=90, + c=ds_flight[color_coding_var], + edgecolor="grey", + cmap=color_coding_cmap, + ) + plt.xlim( + np.min(ds_flight["launch_time"].values) - np.timedelta64(4, "m"), + np.max(ds_flight["launch_time"].values) + np.timedelta64(4, "m"), + ) + plt.gca().spines["right"].set_visible(False) + plt.gca().spines["top"].set_visible(False) + g = plt.colorbar() + g.set_label( + f"{ds_flight[color_coding_var].name} / {ds_flight[color_coding_var].units}", + fontsize=12, + ) + + myFmt = mdates.DateFormatter("%H:%M") + plt.gca().xaxis.set_major_formatter(myFmt) + plt.xlabel("Time / UTC", fontsize=12) + plt.ylabel("Latitude / $\degree$N", fontsize=12) + plt.title( + f"Sondes {ds_flight.sonde_id.values[0]} to {ds_flight.sonde_id.values[-1]}", + fontsize=12, + ) + + save_filename = f"{save_filepath}spatiotemporal-variation-{color_coding_var}.png" + + plt.savefig( + save_filename, + dpi=300, + bbox_inches="tight", + ) + + +def plot_profiles( + ds_flight, + r=["ta", "theta", "rh", "wspd", "wdir"], + r_titles=[ + "T / $\degree$C", + "$\\theta$ / K", + "RH / %", + "Wind speed / ms$^{-1}$", + "Wind direction / $\degree$", + ], + row=1, + col=4, + save_filepath="/path/to/save/", +): + + """ + Plot vertical profiles of specified variables. + """ + + f, ax = plt.subplots(row, col, sharey=True, figsize=(12, 6)) + + for j in range(col): + d = ds_flight[r[j]] + for i in range(1, len(ds_flight["launch_time"]) - 1): + ax[j].plot( + d.isel(sonde_id=i), + ds_flight["alt"] / 1000, + c="grey", + alpha=0.25, + linewidth=0.5, + ) + + ax[j].plot( + np.nanmean(d, axis=0), + ds_flight["alt"] / 1000, + linewidth=3, + c="k", + ) + ax[j].set_xlabel(r_titles[j], fontsize=12) + ax[j].spines["right"].set_visible(False) + ax[j].spines["top"].set_visible(False) + if j == 0: + ax[j].set_ylabel("Altitude / km", fontsize=12) + + plt.suptitle( + f"Sondes {ds_flight.sonde_id.values[0]} to {ds_flight.sonde_id.values[-1]}", + fontsize=12, + ) + + save_filename = f"{save_filepath}vertical-profiles-measured-quantities.png" + + plt.savefig(save_filename, dpi=300, bbox_inches="tight") + + +def drift_plots(ds_flight=None, save_filepath="/path/to/save/"): + + print("Plotting drift in lat and lon...") + + f, ax = plt.subplots(1, 2, sharey=True, figsize=(10, 5)) + + for i in range(len(ds_flight["launch_time"])): + + max_id = np.max(np.where(~np.isnan(ds_flight["lon"].isel(sonde_id=i)))) + + ax[0].plot( + ds_flight["lat"].isel(sonde_id=i) + - ds_flight["lat"].isel(sonde_id=i).isel(alt=max_id), + ds_flight["alt"] / 1000, + linewidth=1.5, + c="grey", + alpha=0.75, + ) + + ax[0].set_xlabel("Drift in Latitude / $\degree$", fontsize=12) + ax[0].set_ylabel("Altitude / km", fontsize=12) + ax[0].spines["right"].set_visible(False) + ax[0].spines["top"].set_visible(False) + + ax[1].plot( + ds_flight["lon"].isel(sonde_id=i) + - ds_flight["lon"].isel(sonde_id=i).isel(alt=max_id), + ds_flight["alt"] / 1000, + linewidth=1.5, + c="grey", + alpha=0.75, + ) + + ax[1].set_xlabel("Drift in Longitude / $\degree$", fontsize=12) + ax[1].spines["right"].set_visible(False) + ax[1].spines["top"].set_visible(False) + + plt.suptitle( + f"Sondes {ds_flight.sonde_id.values[0]} to {ds_flight.sonde_id.values[-1]}", + fontsize=12, + ) + + save_filename = f"{save_filepath}drift-in-lat-lon.png" + + plt.savefig(save_filename, dpi=300, bbox_inches="tight") From b3912f682d8273896641d4d830213f33b3ac017a Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Tue, 27 Jun 2023 14:52:35 +0200 Subject: [PATCH 05/12] initial plotting script --- src/halodrops/api/plotting.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/halodrops/api/plotting.py diff --git a/src/halodrops/api/plotting.py b/src/halodrops/api/plotting.py new file mode 100644 index 0000000..b5199a0 --- /dev/null +++ b/src/halodrops/api/plotting.py @@ -0,0 +1,22 @@ +from halodrops.plotting import quicklooks as ql + + +# Access satellite data +satellite_image = ql.get_satellite_data(ds_flight=ds_sondes_first_circle_Jan24) + + +# Plot launch locations over satellite images +ql.launch_locations_map( + ds_flight=ds_sondes_first_circle_Jan24, + satellite_data=satellite_image, + save_filepath="/path/to/save/", +) + +# Plot longitude/time +ql.plot_lat_time(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=".") + +# Plot vertical profiles +ql.plot_profiles(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=".") + +# Plot dropsonde drift +ql.drift_plots(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=".") From f02a224f4e5f1bd762e1efaf309a193f4e1827da Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Tue, 27 Jun 2023 15:16:00 +0200 Subject: [PATCH 06/12] notebook to make quicklooks --- docs/source/howto/create_quicklooks.ipynb | 363 ++++++++++++++++++++++ 1 file changed, 363 insertions(+) create mode 100644 docs/source/howto/create_quicklooks.ipynb diff --git a/docs/source/howto/create_quicklooks.ipynb b/docs/source/howto/create_quicklooks.ipynb new file mode 100644 index 0000000..d92b80b --- /dev/null +++ b/docs/source/howto/create_quicklooks.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1ff5dc6d-caec-4303-8c22-684792c6cfe5", + "metadata": {}, + "source": [ + "# Some dropsonde quicklook examples" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "947b5fe5-e348-4d8c-b6fd-de449fc2aa44", + "metadata": {}, + "outputs": [], + "source": [ + "from halodrops.plotting import quicklooks as ql" + ] + }, + { + "cell_type": "markdown", + "id": "6b2d5ef7-5111-4978-99dc-36b6a28fed2c", + "metadata": {}, + "source": [ + "### Test plotting for EUREC4A data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a3d0cd28-5bce-46d9-abe8-5c45cc32c14e", + "metadata": {}, + "outputs": [], + "source": [ + "import eurec4a\n", + "from datetime import datetime, date\n", + "from collections import defaultdict\n", + "from functools import reduce\n", + "\n", + "\n", + "\n", + "# Access EUREC4A catalog\n", + "cat = eurec4a.get_intake_catalog(use_ipfs=False)\n", + "\n", + "# Get flight segments\n", + "meta = eurec4a.get_flight_segments()\n", + "\n", + "segments = [{**s,\n", + " \"platform_id\": platform_id,\n", + " \"flight_id\": flight_id\n", + " }\n", + " for platform_id, flights in meta.items()\n", + " for flight_id, flight in flights.items()\n", + " for s in flight[\"segments\"]\n", + " ]\n", + "\n", + "segments_by_segment_id = {s[\"segment_id\"]: s for s in segments}\n", + "segments_ordered_by_start_time = list(sorted(segments, key=lambda s: s[\"start\"]))\n", + "\n", + "circles_Jan24 = [s[\"segment_id\"]\n", + " for s in segments_ordered_by_start_time\n", + " if \"circle\" in s[\"kinds\"]\n", + " and s[\"start\"].date() == date(2020,1,24)\n", + " and s[\"platform_id\"] == \"HALO\"\n", + " ]\n", + "\n", + "first_circle_Jan24 = circles_Jan24[0]\n", + "\n", + "dropsonde_ids = segments_by_segment_id[first_circle_Jan24][\"dropsondes\"][\"GOOD\"]" + ] + }, + { + "cell_type": "markdown", + "id": "bde5f87f-503d-48f2-9cfc-8a4a8c9010a9", + "metadata": {}, + "source": [ + "Load dropsonde dataset and select first circle of January 24, 2020:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5f08a63c-b9e8-4d9e-b48c-ae27983a3920", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n" + ] + } + ], + "source": [ + "ds = cat.dropsondes.JOANNE.level3.to_dask()\n", + "\n", + "# Select dropsondes from Jan 24 2020\n", + "mask_sondes_first_circle_Jan24 = reduce(lambda a, b: a | b, [ds.sonde_id==d for d in dropsonde_ids])\n", + "ds_sondes_first_circle_Jan24 = ds.isel(sonde_id=mask_sondes_first_circle_Jan24)" + ] + }, + { + "cell_type": "markdown", + "id": "f01f4463-b18a-4562-ac57-0278a5d27a19", + "metadata": {}, + "source": [ + "Access satellite images:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6de0f717-bd26-4eec-8eba-6f43ee98a57a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/kerchunk/combine.py:269: UserWarning: Concatenated coordinate 't' contains less than expectednumber of values across the datasets: [6.33133503e+08]\n", + " warnings.warn(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/gogoesgone/processing.py:28: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " self.dataset = xr.open_dataset(filepath, engine=\"zarr\")\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/gogoesgone/processing.py:178: RuntimeWarning: invalid value encountered in sqrt\n", + " r_s = (-b - np.sqrt(b**2 - (4 * a * c))) / (2 * a)\n" + ] + } + ], + "source": [ + "satellite_image = ql.get_satellite_data(ds_flight=ds_sondes_first_circle_Jan24,\n", + " satellite_name=\"goes16\", channel = 13, product=\"ABI-L2-CMIPF\",\n", + " extent = (-62,-48,10,20))" + ] + }, + { + "cell_type": "markdown", + "id": "b5834ca1-2c9f-47c7-bf7b-0c8ce62eb897", + "metadata": {}, + "source": [ + "## Plot dropsonde launch locations on a map (over a GOES-16 image)\n", + "\n", + "By default the satellite image will be taken at the average launch time from all dropsondes in the plot. By default the colormap is chosen to show the flight altitude, but it can be any variable with dimensions (`sonde_id`)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "652d22a6-0ff9-45f8-8b69-8608f18d7ae5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ql.launch_locations_map(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\", \n", + " satellite_data=satellite_image)" + ] + }, + { + "cell_type": "markdown", + "id": "61c0e563-6411-41c1-a21e-d4d23c064537", + "metadata": {}, + "source": [ + "## Plot latitude-time quantities\n", + "\n", + "By default the colormap is chosen to show the flight altitude, but it can be any variable with dimensions (`sonde_id`)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5dc93114-76fc-4ce6-88b9-dab6944428f6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ql.plot_lat_time(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" + ] + }, + { + "cell_type": "markdown", + "id": "e7005a0b-8603-4a8e-8306-af5933ce2a5a", + "metadata": {}, + "source": [ + "## Plot vertical profiles\n", + "The variables and number of plots can be adjusted by the user. By default the quicklook shows temperature, potential temperature, relative humidity, and wind speed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0d1315af-7d6e-499e-a1ce-2cda46562724", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/m/m300931/halodrops/src/halodrops/plotting/quicklooks.py:280: RuntimeWarning: Mean of empty slice\n", + " np.nanmean(d, axis=0),\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ql.plot_profiles(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" + ] + }, + { + "cell_type": "markdown", + "id": "c54961a5-873d-4091-b798-d72e42d06a45", + "metadata": {}, + "source": [ + "## Plot dropsonde drift" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "805d161e-72bd-4596-948d-75842b6df1e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting drift in lat and lon...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", + "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", + " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ql.drift_plots(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" + ] + }, + { + "cell_type": "markdown", + "id": "31d1e2b6-0bb0-4b03-b94f-cd0619b7abe7", + "metadata": {}, + "source": [ + "## Saving plots in one pdf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b542d28-3a83-4801-b767-316959ede93d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "HALO-DROPS", + "language": "python", + "name": "my-kernel" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 2959d90f16bbf25589924c8d9f770f07f82fc660 Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Tue, 27 Jun 2023 15:21:35 +0200 Subject: [PATCH 07/12] generic nonfunctional plotting script --- src/halodrops/api/plotting.py | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/src/halodrops/api/plotting.py b/src/halodrops/api/plotting.py index b5199a0..20bf7aa 100644 --- a/src/halodrops/api/plotting.py +++ b/src/halodrops/api/plotting.py @@ -2,21 +2,18 @@ # Access satellite data -satellite_image = ql.get_satellite_data(ds_flight=ds_sondes_first_circle_Jan24) - +satellite_image = ql.get_satellite_data(**kwargs) # Plot launch locations over satellite images -ql.launch_locations_map( - ds_flight=ds_sondes_first_circle_Jan24, - satellite_data=satellite_image, - save_filepath="/path/to/save/", -) +ql.launch_locations_map(**kwargs) # Plot longitude/time -ql.plot_lat_time(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=".") +ql.plot_lat_time(**kwargs) # Plot vertical profiles -ql.plot_profiles(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=".") +ql.plot_profiles(**kwargs) # Plot dropsonde drift -ql.drift_plots(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=".") +ql.drift_plots(**kwargs) + +# Output all quicklooks into a PDF From 439406d0dbcbf3c6a71a9f7fb15c971ac55dfd0c Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Tue, 4 Jul 2023 11:00:05 +0200 Subject: [PATCH 08/12] no quicklook notebook for now --- docs/source/howto/create_quicklooks.ipynb | 363 ---------------------- 1 file changed, 363 deletions(-) delete mode 100644 docs/source/howto/create_quicklooks.ipynb diff --git a/docs/source/howto/create_quicklooks.ipynb b/docs/source/howto/create_quicklooks.ipynb deleted file mode 100644 index d92b80b..0000000 --- a/docs/source/howto/create_quicklooks.ipynb +++ /dev/null @@ -1,363 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "1ff5dc6d-caec-4303-8c22-684792c6cfe5", - "metadata": {}, - "source": [ - "# Some dropsonde quicklook examples" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "947b5fe5-e348-4d8c-b6fd-de449fc2aa44", - "metadata": {}, - "outputs": [], - "source": [ - "from halodrops.plotting import quicklooks as ql" - ] - }, - { - "cell_type": "markdown", - "id": "6b2d5ef7-5111-4978-99dc-36b6a28fed2c", - "metadata": {}, - "source": [ - "### Test plotting for EUREC4A data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a3d0cd28-5bce-46d9-abe8-5c45cc32c14e", - "metadata": {}, - "outputs": [], - "source": [ - "import eurec4a\n", - "from datetime import datetime, date\n", - "from collections import defaultdict\n", - "from functools import reduce\n", - "\n", - "\n", - "\n", - "# Access EUREC4A catalog\n", - "cat = eurec4a.get_intake_catalog(use_ipfs=False)\n", - "\n", - "# Get flight segments\n", - "meta = eurec4a.get_flight_segments()\n", - "\n", - "segments = [{**s,\n", - " \"platform_id\": platform_id,\n", - " \"flight_id\": flight_id\n", - " }\n", - " for platform_id, flights in meta.items()\n", - " for flight_id, flight in flights.items()\n", - " for s in flight[\"segments\"]\n", - " ]\n", - "\n", - "segments_by_segment_id = {s[\"segment_id\"]: s for s in segments}\n", - "segments_ordered_by_start_time = list(sorted(segments, key=lambda s: s[\"start\"]))\n", - "\n", - "circles_Jan24 = [s[\"segment_id\"]\n", - " for s in segments_ordered_by_start_time\n", - " if \"circle\" in s[\"kinds\"]\n", - " and s[\"start\"].date() == date(2020,1,24)\n", - " and s[\"platform_id\"] == \"HALO\"\n", - " ]\n", - "\n", - "first_circle_Jan24 = circles_Jan24[0]\n", - "\n", - "dropsonde_ids = segments_by_segment_id[first_circle_Jan24][\"dropsondes\"][\"GOOD\"]" - ] - }, - { - "cell_type": "markdown", - "id": "bde5f87f-503d-48f2-9cfc-8a4a8c9010a9", - "metadata": {}, - "source": [ - "Load dropsonde dataset and select first circle of January 24, 2020:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5f08a63c-b9e8-4d9e-b48c-ae27983a3920", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n" - ] - } - ], - "source": [ - "ds = cat.dropsondes.JOANNE.level3.to_dask()\n", - "\n", - "# Select dropsondes from Jan 24 2020\n", - "mask_sondes_first_circle_Jan24 = reduce(lambda a, b: a | b, [ds.sonde_id==d for d in dropsonde_ids])\n", - "ds_sondes_first_circle_Jan24 = ds.isel(sonde_id=mask_sondes_first_circle_Jan24)" - ] - }, - { - "cell_type": "markdown", - "id": "f01f4463-b18a-4562-ac57-0278a5d27a19", - "metadata": {}, - "source": [ - "Access satellite images:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "6de0f717-bd26-4eec-8eba-6f43ee98a57a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/kerchunk/combine.py:269: UserWarning: Concatenated coordinate 't' contains less than expectednumber of values across the datasets: [6.33133503e+08]\n", - " warnings.warn(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/gogoesgone/processing.py:28: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " self.dataset = xr.open_dataset(filepath, engine=\"zarr\")\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/gogoesgone/processing.py:178: RuntimeWarning: invalid value encountered in sqrt\n", - " r_s = (-b - np.sqrt(b**2 - (4 * a * c))) / (2 * a)\n" - ] - } - ], - "source": [ - "satellite_image = ql.get_satellite_data(ds_flight=ds_sondes_first_circle_Jan24,\n", - " satellite_name=\"goes16\", channel = 13, product=\"ABI-L2-CMIPF\",\n", - " extent = (-62,-48,10,20))" - ] - }, - { - "cell_type": "markdown", - "id": "b5834ca1-2c9f-47c7-bf7b-0c8ce62eb897", - "metadata": {}, - "source": [ - "## Plot dropsonde launch locations on a map (over a GOES-16 image)\n", - "\n", - "By default the satellite image will be taken at the average launch time from all dropsondes in the plot. By default the colormap is chosen to show the flight altitude, but it can be any variable with dimensions (`sonde_id`)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "652d22a6-0ff9-45f8-8b69-8608f18d7ae5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ql.launch_locations_map(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\", \n", - " satellite_data=satellite_image)" - ] - }, - { - "cell_type": "markdown", - "id": "61c0e563-6411-41c1-a21e-d4d23c064537", - "metadata": {}, - "source": [ - "## Plot latitude-time quantities\n", - "\n", - "By default the colormap is chosen to show the flight altitude, but it can be any variable with dimensions (`sonde_id`)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5dc93114-76fc-4ce6-88b9-dab6944428f6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ql.plot_lat_time(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" - ] - }, - { - "cell_type": "markdown", - "id": "e7005a0b-8603-4a8e-8306-af5933ce2a5a", - "metadata": {}, - "source": [ - "## Plot vertical profiles\n", - "The variables and number of plots can be adjusted by the user. By default the quicklook shows temperature, potential temperature, relative humidity, and wind speed." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0d1315af-7d6e-499e-a1ce-2cda46562724", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/m/m300931/halodrops/src/halodrops/plotting/quicklooks.py:280: RuntimeWarning: Mean of empty slice\n", - " np.nanmean(d, axis=0),\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ql.plot_profiles(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" - ] - }, - { - "cell_type": "markdown", - "id": "c54961a5-873d-4091-b798-d72e42d06a45", - "metadata": {}, - "source": [ - "## Plot dropsonde drift" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "805d161e-72bd-4596-948d-75842b6df1e2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting drift in lat and lon...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n", - "/home/m/m300931/mambaforge/envs/halodrops_env/lib/python3.10/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n", - " flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ql.drift_plots(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" - ] - }, - { - "cell_type": "markdown", - "id": "31d1e2b6-0bb0-4b03-b94f-cd0619b7abe7", - "metadata": {}, - "source": [ - "## Saving plots in one pdf" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4b542d28-3a83-4801-b767-316959ede93d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "HALO-DROPS", - "language": "python", - "name": "my-kernel" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 894bc8574e705e693412a52a9079d54feb4c47e1 Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Tue, 11 Jul 2023 19:15:19 +0200 Subject: [PATCH 09/12] remove kwargs, set default extent --- src/halodrops/api/plotting.py | 10 ++++---- src/halodrops/plotting/quicklooks.py | 38 ++++++++++++++++++++++------ 2 files changed, 35 insertions(+), 13 deletions(-) diff --git a/src/halodrops/api/plotting.py b/src/halodrops/api/plotting.py index 20bf7aa..9c32718 100644 --- a/src/halodrops/api/plotting.py +++ b/src/halodrops/api/plotting.py @@ -2,18 +2,18 @@ # Access satellite data -satellite_image = ql.get_satellite_data(**kwargs) +satellite_image = ql.get_satellite_data() # Plot launch locations over satellite images -ql.launch_locations_map(**kwargs) +ql.launch_locations_map() # Plot longitude/time -ql.plot_lat_time(**kwargs) +ql.plot_lat_time() # Plot vertical profiles -ql.plot_profiles(**kwargs) +ql.plot_profiles() # Plot dropsonde drift -ql.drift_plots(**kwargs) +ql.drift_plots() # Output all quicklooks into a PDF diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/plotting/quicklooks.py index 7ccb4b9..b03e8d9 100644 --- a/src/halodrops/plotting/quicklooks.py +++ b/src/halodrops/plotting/quicklooks.py @@ -66,19 +66,30 @@ def get_satellite_data( By default use the mean launch time from dropsonde dataset. """ - # Get correct time for satellite data + # Get correct time for satellite data. Default is mean of all launches if satellite_time == "mean_launch_time": use_time = get_mean_launch_time(ds_flight=ds_flight) else: use_time = convert_time_to_str(time=satellite_time) + # Define default extent based on launch locations, or user-defined extent + if extent is not None: + image_lims = extent + else: + image_lims = ( + ds_flight.lon.min() - 1, + ds_flight.lon.max() + 1, + ds_flight.lat.min() - 1, + ds_flight.lat.max() + 1, + ) + # Get filepath to satellite data at nearest time. flist = za.nearest_time_url(use_time, time_format, channel, product, satellite_name) m = za.get_mapper_from_mzz(flist) # Select subset of satellite domain img = pr.Image(m) - subset = img.subset_region_from_latlon_extents(extent, unit="degree") + subset = img.subset_region_from_latlon_extents(image_lims, unit="degree") return subset @@ -90,7 +101,7 @@ def launch_locations_map( color_coding_var="flight_altitude", color_coding_cmap="magma", satellite_time=None, - extent=(-61, -52, 10, 16), + extent=None, satellite_cmap="Greys", satellite_vmin=280, satellite_vmax=300, @@ -102,9 +113,20 @@ def launch_locations_map( fig = plt.figure(figsize=(10, 8)) + # Define default extent based on launch locations, or user-defined extent + if extent is not None: + image_lims = extent + else: + image_lims = ( + ds_flight.lon.min() - 1, + ds_flight.lon.max() + 1, + ds_flight.lat.min() - 1, + ds_flight.lat.max() + 1, + ) + ax = plt.axes(projection=ccrs.PlateCarree()) ax.coastlines(resolution="50m", linewidth=1.5) - ax.set_extent(extent, crs=ccrs.PlateCarree()) + ax.set_extent(image_lims, crs=ccrs.PlateCarree()) # Plot satellite image if satellite_data: @@ -115,7 +137,7 @@ def launch_locations_map( cmap=satellite_cmap, add_colorbar=True, cbar_kwargs={ - "pad": 0.1, + "pad": 0.05, "extend": "both", "aspect": 15, "shrink": 0.7, @@ -150,8 +172,8 @@ def launch_locations_map( ) # Assigning axes ticks - xticks = np.arange(-180, 180, 4) - yticks = np.arange(-90, 90, 4) + xticks = np.arange(-180, 180, 1) + yticks = np.arange(-90, 90, 1) # Setting up the gridlines gl = ax.gridlines( @@ -171,7 +193,7 @@ def launch_locations_map( # Colorbar g = fig.colorbar( - im_launches, orientation="horizontal", extend="both", aspect=30, pad=0.1 + im_launches, orientation="horizontal", extend="both", aspect=30, pad=0.05 ) g.set_label( f"{ds_flight[color_coding_var].name} / {ds_flight[color_coding_var].units}", From dbe1714e4cc7d8c78a23707e49bb81c6ff17b599 Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Tue, 11 Jul 2023 19:18:02 +0200 Subject: [PATCH 10/12] set satellite extent to None --- src/halodrops/plotting/quicklooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/plotting/quicklooks.py index b03e8d9..852ae36 100644 --- a/src/halodrops/plotting/quicklooks.py +++ b/src/halodrops/plotting/quicklooks.py @@ -58,7 +58,7 @@ def get_satellite_data( satellite_name="goes16", channel=13, product="ABI-L2-CMIPF", - extent=(-62, -48, 10, 20), + extent=None, ): """ From 13fee8c7090a6f63ac1a54987eefc4f54803e26f Mon Sep 17 00:00:00 2001 From: Nina Robbins Date: Thu, 11 Jul 2024 11:03:48 +0200 Subject: [PATCH 11/12] example notebook for quicklooks --- docs/source/howto/create_quicklooks.ipynb | 267 ++++++++++++++++++++++ 1 file changed, 267 insertions(+) create mode 100644 docs/source/howto/create_quicklooks.ipynb diff --git a/docs/source/howto/create_quicklooks.ipynb b/docs/source/howto/create_quicklooks.ipynb new file mode 100644 index 0000000..98ac46a --- /dev/null +++ b/docs/source/howto/create_quicklooks.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1ff5dc6d-caec-4303-8c22-684792c6cfe5", + "metadata": {}, + "source": [ + "# Some dropsonde quicklook examples" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "947b5fe5-e348-4d8c-b6fd-de449fc2aa44", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'halodrops'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mhalodrops\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mplotting\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m quicklooks \u001b[38;5;28;01mas\u001b[39;00m ql\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'halodrops'" + ] + } + ], + "source": [ + "from halodrops.plotting import quicklooks as ql" + ] + }, + { + "cell_type": "markdown", + "id": "6b2d5ef7-5111-4978-99dc-36b6a28fed2c", + "metadata": {}, + "source": [ + "### Test plotting for EUREC4A data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3d0cd28-5bce-46d9-abe8-5c45cc32c14e", + "metadata": {}, + "outputs": [], + "source": [ + "import eurec4a\n", + "from datetime import datetime, date\n", + "from collections import defaultdict\n", + "from functools import reduce\n", + "\n", + "# Access EUREC4A catalog\n", + "cat = eurec4a.get_intake_catalog(use_ipfs=False)\n", + "\n", + "# Get flight segments\n", + "meta = eurec4a.get_flight_segments()\n", + "\n", + "segments = [{**s,\n", + " \"platform_id\": platform_id,\n", + " \"flight_id\": flight_id\n", + " }\n", + " for platform_id, flights in meta.items()\n", + " for flight_id, flight in flights.items()\n", + " for s in flight[\"segments\"]\n", + " ]\n", + "\n", + "segments_by_segment_id = {s[\"segment_id\"]: s for s in segments}\n", + "segments_ordered_by_start_time = list(sorted(segments, key=lambda s: s[\"start\"]))\n", + "\n", + "circles_Jan24 = [s[\"segment_id\"]\n", + " for s in segments_ordered_by_start_time\n", + " if \"circle\" in s[\"kinds\"]\n", + " and s[\"start\"].date() == date(2020,1,24)\n", + " and s[\"platform_id\"] == \"HALO\"\n", + " ]\n", + "\n", + "first_circle_Jan24 = circles_Jan24[0]\n", + "\n", + "dropsonde_ids = segments_by_segment_id[first_circle_Jan24][\"dropsondes\"][\"GOOD\"]" + ] + }, + { + "cell_type": "markdown", + "id": "bde5f87f-503d-48f2-9cfc-8a4a8c9010a9", + "metadata": {}, + "source": [ + "Load dropsonde dataset and select first circle of January 24, 2020:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f08a63c-b9e8-4d9e-b48c-ae27983a3920", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ds = cat.dropsondes.JOANNE.level3.to_dask()\n", + "\n", + "# Select dropsondes from Jan 24 2020\n", + "mask_sondes_first_circle_Jan24 = reduce(lambda a, b: a | b, [ds.sonde_id==d for d in dropsonde_ids])\n", + "mask_sondes_third_circle_Jan24 = reduce(lambda a, b: a | b, [ds.sonde_id==d for d in dropsonde_ids])\n", + "\n", + "ds_sondes_first_circle_Jan24 = ds.isel(sonde_id=mask_sondes_first_circle_Jan24)\n", + "ds_sondes_third_circle_Jan24 = ds.isel(sonde_id=mask_sondes_third_circle_Jan24)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14d71026-054c-410f-8723-b44adcf31f0b", + "metadata": {}, + "outputs": [], + "source": [ + "ds_sondes_first_circle_Jan24" + ] + }, + { + "cell_type": "markdown", + "id": "f01f4463-b18a-4562-ac57-0278a5d27a19", + "metadata": {}, + "source": [ + "Access satellite images:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6de0f717-bd26-4eec-8eba-6f43ee98a57a", + "metadata": {}, + "outputs": [], + "source": [ + "satellite_image = ql.get_satellite_data(ds_flight=ds_sondes_first_circle_Jan24,\n", + " satellite_name=\"goes16\", channel = 13, product=\"ABI-L2-CMIPF\")#,\n", + " #extent = (-62,-48,10,30))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5118c746-9a84-4323-b3bc-c1b3c2c61793", + "metadata": {}, + "outputs": [], + "source": [ + "satellite_image" + ] + }, + { + "cell_type": "markdown", + "id": "b5834ca1-2c9f-47c7-bf7b-0c8ce62eb897", + "metadata": {}, + "source": [ + "## Plot dropsonde launch locations on a map (over a GOES-16 image)\n", + "\n", + "By default the satellite image will be taken at the average launch time from all dropsondes in the plot. By default the colormap is chosen to show the flight altitude, but it can be any variable with dimensions (`sonde_id`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "652d22a6-0ff9-45f8-8b69-8608f18d7ae5", + "metadata": {}, + "outputs": [], + "source": [ + "ql.launch_locations_map(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\", \n", + " satellite_data=satellite_image)\n", + " #extent = (-62,-48,10,30))" + ] + }, + { + "cell_type": "markdown", + "id": "61c0e563-6411-41c1-a21e-d4d23c064537", + "metadata": {}, + "source": [ + "## Plot latitude-time quantities\n", + "\n", + "By default the colormap is chosen to show the flight altitude, but it can be any variable with dimensions (`sonde_id`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5dc93114-76fc-4ce6-88b9-dab6944428f6", + "metadata": {}, + "outputs": [], + "source": [ + "ql.plot_lat_time(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" + ] + }, + { + "cell_type": "markdown", + "id": "e7005a0b-8603-4a8e-8306-af5933ce2a5a", + "metadata": {}, + "source": [ + "## Plot vertical profiles\n", + "The variables and number of plots can be adjusted by the user. By default the quicklook shows temperature, potential temperature, relative humidity, and wind speed." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d1315af-7d6e-499e-a1ce-2cda46562724", + "metadata": {}, + "outputs": [], + "source": [ + "ql.plot_profiles(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" + ] + }, + { + "cell_type": "markdown", + "id": "c54961a5-873d-4091-b798-d72e42d06a45", + "metadata": {}, + "source": [ + "## Plot dropsonde drift" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "805d161e-72bd-4596-948d-75842b6df1e2", + "metadata": {}, + "outputs": [], + "source": [ + "ql.drift_plots(ds_flight=ds_sondes_first_circle_Jan24, save_filepath=\"/home/m/m300931/\")" + ] + }, + { + "cell_type": "markdown", + "id": "31d1e2b6-0bb0-4b03-b94f-cd0619b7abe7", + "metadata": {}, + "source": [ + "## Saving plots in one pdf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b542d28-3a83-4801-b767-316959ede93d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "HALO-DROPS", + "language": "python", + "name": "my-kernel" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 1bb4a967bc34be49554cf037df26823e54af67dd Mon Sep 17 00:00:00 2001 From: Nina Robbins Blanch Date: Sat, 17 Aug 2024 12:52:59 -0100 Subject: [PATCH 12/12] quicklooks at same folder level as processor etc --- src/halodrops/{plotting => }/quicklooks.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/halodrops/{plotting => }/quicklooks.py (100%) diff --git a/src/halodrops/plotting/quicklooks.py b/src/halodrops/quicklooks.py similarity index 100% rename from src/halodrops/plotting/quicklooks.py rename to src/halodrops/quicklooks.py