From 3b3e46e97764a72d7c1a1a522d488f88ee662495 Mon Sep 17 00:00:00 2001 From: "stephen.worsley" Date: Wed, 25 Jan 2023 14:25:51 +0000 Subject: [PATCH 1/3] address additional comments --- .../Sec_05_Regridding.md | 78 ++-- notebooks/Sec_05_Regridding.ipynb | 373 +++++++++++++----- 2 files changed, 315 insertions(+), 136 deletions(-) diff --git a/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md b/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md index 2779504..9761981 100644 --- a/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md +++ b/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md @@ -104,6 +104,7 @@ import matplotlib.pyplot as plt from testdata_fetching import um_temp grid_temp = um_temp() +# We slice the cube to make sure it is 2D for plotting. iqplt.pcolormesh(grid_temp[0, 0]) plt.gca().coastlines() plt.show() @@ -113,11 +114,12 @@ plt.gca().coastlines() plt.show() ``` -We can then plot the difference between the UM data and the data regridded from LFRic. Since our data is now on a latlon grid we can do this with matplotlib as normal. +We can then plot the difference between the UM data and the data regridded from LFRic. Since all our data is now on a latlon grid we can subtract to find the difference between the regridded LFRic data and equivalent UM data and plot this with matplotlib as normal. ```python temp_diff = result_2 - grid_temp +# We choose a colormap that makes it clear where the differences are. iqplt.pcolormesh(temp_diff[0, 0], vmin=-4,vmax=4, cmap="seismic") plt.gca().coastlines() plt.show() @@ -206,10 +208,10 @@ lat_bands = DimCoord( lon_full = DimCoord(0, bounds=[[-180, 180]], standard_name="longitude", units="degrees") ``` -**Step 3:** Create a single celled cube (i.e. `Cube([[0]])`) and attach the latitude and longitude coordinates to it. +**Step 3:** Create a six celled cube (i.e. `Cube([[0, 0, 0, 0, 0, 0]])`) and attach the latitude and longitude coordinates to it. ```python -lat_band_cube = Cube(np.zeros((1,) + lat_bands.shape)) +lat_band_cube = Cube([[0, 0, 0, 0, 0, 0]]) lat_band_cube.add_dim_coord(lat_bands, 1) lat_band_cube.add_dim_coord(lon_full, 0) lat_band_cube @@ -227,7 +229,7 @@ Initialise a `MeshToGridESMFRegridder` with `mesh_cube` and your single celled c lat_band_mean_calculator_10 = MeshToGridESMFRegridder(mesh_cube, lat_band_cube, resolution=10) ``` -**Step 5:** Apply this regridder to `mesh_cube` and print the data from this result (i.e. `print(result_cube.data)`). +**Step 5:** Apply this regridder to `mesh_cube` and print the data from this result (i.e. `print(result_cube.data)`) and plot with `iqplt.pcolormesh`. ```python lat_band_mean_10 = lat_band_mean_calculator_10(mesh_cube) @@ -239,7 +241,7 @@ plt.show() **Step 6:** Repeat step 4 and 5 for `resolution=100`. -Note the difference in value. Also note that it takes more time to initialise a regridder with higher resolution. +Note the difference in value. Also note that it takes more time to initialise a regridder with higher resolution. Higher resolutions ought to be more accurate but there is a tradeoff between performance and accuracy. ```python lat_band_mean_calculator_100 = MeshToGridESMFRegridder(mesh_cube, lat_band_cube, resolution=100) @@ -276,62 +278,66 @@ print(lon_band_mean_10.data) If we have data on aditional dimensions, we can use the same approach as exercise 2 to produce a Hovmoller diagram. That is, if we have data that varies along time we can take the area weighted mean over latitude bands and plot the data aginst longitude and time (or similarly, we can plot against latitude and time). -**Step 1:** Load a temperature cube using the `testdata_fetching` function `lfric_temp`. Extract a single pressure slice using the `cube.extract` method with a constraint `iris.Constraint(pressure=850)` as the argument (we choose this level because it has noticable details). +**Step 1:** Load a cube with humidity data using the `testdata_fetching` function `lfric_rh_alltimes_3d`. +```python +from testdata_fetching import lfric_rh_alltimes_3d -from testdata_fetching import fric_temp -mesh_temp = lfric_temp() - -temp_slice = mesh_temp.extract(iris.Constraint(pressure=850)) -temp_slice - +humidity_cube = lfric_rh_alltimes_3d() +humidity_cube +``` -**Step 2:** Create a target cube whose longitude coordinate is derived from the UM cube loaded from `um_orography` and whose latitude coordinate has bounds `[[-180, 180]]`. This can be done by slicing a cube derived from `um_orography` (using the slice `[:1]` so that this dimension isnt collapsed), removing the latitude coordinate and adding a latitude coordinate with bounds `[[-180, 180]]` (you can reuse the coordinate from exercise 2). +**Step 2:** Create a target cube whose latitude coordinate is derived from the UM cube loaded from `um_orography` and whose longitude coordinate has bounds `[[-180, 180]]`. This can be done by slicing a cube derived from `um_orography` (using the slice `[:, :1]` so that this dimension isnt collapsed), removing the longitude coordinate and adding a longitude coordinate with bounds `[[-180, 180]]` (you can reuse the coordinate from exercise 2). ```python -target_cube_lons = grid_cube[:1] -target_cube_lons.remove_coord("latitude") -target_cube_lons.add_dim_coord(lat_full, 0) -target_cube_lons +target_cube_lats = grid_cube[:,:1] +target_cube_lats.remove_coord("longitude") +target_cube_lats.add_dim_coord(lon_full, 1) +target_cube_lats ``` ```python -# We also can do the same thing for bands of constant latitude. +# We also can do the same thing for bands of constant longitude. -# target_cube_lats = grid_cube[:,:1] -# target_cube_lats.remove_coord("longitude") -# target_cube_lats.add_dim_coord(lon_full, 1) -# target_cube_lats +# target_cube_lons = grid_cube[:1] +# target_cube_lons.remove_coord("latitude") +# target_cube_lons.add_dim_coord(lat_full, 0) +# target_cube_lons ``` -**Step 3:** Create a `MeshToGridESMFRegridder` regridder from the slice of the temperature cube onto the target cube. Set the resolution keyword to 2 (this should be sufficient since these are bands of constant longitude). Use this regridder to create a resulting cube. +**Step 3:** Create a `MeshToGridESMFRegridder` regridder from the slice of the humidity cube onto the target cube. Set the resolution keyword to 500 (this should be good balance of accuracy and performance). Use this regridder to create a resulting cube. ```python -um_lon_band_mean_calculator = MeshToGridESMFRegridder(temp_slice, target_cube_lons, resolution=2) -um_lon_bound_means = um_lon_band_mean_calculator(temp_slice) -um_lon_bound_means +um_lat_band_mean_calculator = MeshToGridESMFRegridder(humidity_cube, target_cube_lats, resolution=500) +um_lat_band_means = um_lat_band_mean_calculator(humidity_cube) +um_lat_band_means ``` ```python -# um_lat_band_mean_calculator = MeshToGridESMFRegridder(temp_slice, target_cube, resolution=500) -# um_lat_bound_means = um_lat_band_mean_calculator(temp_slice) -# um_lat_bound_means +# Continuing for bands of constant longitude. +# Note: this code takes about 2 minutes to run. I think this is due to with the way ESMF handles cells +# with unusual shapes. See https://github.com/SciTools-incubator/iris-esmf-regrid/issues/234. + +# um_lon_band_mean_calculator = MeshToGridESMFRegridder(humidity_cube, target_cube_lons, resolution=2) +# um_lon_band_means = um_lon_band_mean_calculator(humidity_cube) +# um_lon_band_means ``` -**Step 4:** Plot the data in the resulting cube. This can be done with `iqplt.pcolormesh`. Note that the resulting cube will have an unnecessary dimension which will have to be sliced (using `[:, 0]`). Note that extra steps can be taken to format the dates for this plot. +**Step 4:** Plot the data in the resulting cube. This can be done with `iqplt.pcolormesh`. Note that the resulting cube will have an unnecessary dimension which will have to be sliced (using `[:, :, 0]`). Note that extra steps can be taken to format the dates for this plot. ```python import matplotlib.dates as mdates - -iqplt.pcolormesh(um_lon_bound_means[:, 0, :]) -plt.gca().yaxis.set_major_formatter(mdates.DateFormatter("%D")) +# We use a colormap which highlights fine details. +iqplt.pcolormesh(um_lat_band_means[:, :, 0]) +plt.gca().xaxis.set_major_formatter(mdates.DateFormatter("%D")) plt.show() ``` ```python -# import matplotlib.dates as mdates -# iqplt.pcolormesh(um_lat_bound_means[:, :, 0]) -# plt.gca().xaxis.set_major_formatter(mdates.DateFormatter("%D")) +# Continuing for bands of constant longitude. + +# iqplt.pcolormesh(um_lon_band_means[:, 0]) +# plt.gca().yaxis.set_major_formatter(mdates.DateFormatter("%D")) # plt.show() ``` diff --git a/notebooks/Sec_05_Regridding.ipynb b/notebooks/Sec_05_Regridding.ipynb index 31c7dee..6b67f3d 100644 --- a/notebooks/Sec_05_Regridding.ipynb +++ b/notebooks/Sec_05_Regridding.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "9d9dcd31-7642-4c8a-8c20-60d0e608f99e", "metadata": {}, "outputs": [], @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "id": "e710655b-a75c-4bff-8d6b-2575cde0432c", "metadata": {}, "outputs": [ @@ -100,7 +100,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "\n", + "
\n", " \n", "\n", "\n", @@ -192,7 +192,7 @@ "" ] }, - "execution_count": 12, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -205,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "id": "09fecda0-07d7-4d59-9059-a2ce27448522", "metadata": {}, "outputs": [ @@ -260,7 +260,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)--
\n", + "
\n", " \n", "\n", "\n", @@ -352,7 +352,7 @@ "" ] }, - "execution_count": 13, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -374,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "id": "fb72ce6d-0724-45da-a4d1-b004b6ce6bb5", "metadata": {}, "outputs": [], @@ -395,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "id": "c6d9036e-6c44-4926-a85f-bacd18fe37e1", "metadata": {}, "outputs": [ @@ -450,7 +450,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)latitude
\n", + "
\n", " \n", "\n", "\n", @@ -538,7 +538,7 @@ "" ] }, - "execution_count": 15, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -559,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "id": "538abb30-d460-45a7-8398-c5fce4d4f8d6", "metadata": {}, "outputs": [ @@ -614,7 +614,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)latitude
\n", + "
\n", " \n", "\n", "\n", @@ -746,7 +746,7 @@ "" ] }, - "execution_count": 16, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -764,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "id": "d398cfa3-70ea-4a0c-b875-8560fb5313eb", "metadata": {}, "outputs": [ @@ -819,7 +819,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Air Temperature (K)time
\n", + "
\n", " \n", "\n", "\n", @@ -943,7 +943,7 @@ "" ] }, - "execution_count": 17, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -967,7 +967,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "id": "60d9028e-9d74-401d-a20f-77585ee57fdf", "metadata": {}, "outputs": [], @@ -990,7 +990,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 9, "id": "dafbd4e0-193d-401b-a8dd-626e0a8de88f", "metadata": {}, "outputs": [ @@ -1022,6 +1022,7 @@ "from testdata_fetching import um_temp\n", "grid_temp = um_temp()\n", "\n", + "# We slice the cube to make sure it is 2D for plotting.\n", "iqplt.pcolormesh(grid_temp[0, 0])\n", "plt.gca().coastlines()\n", "plt.show()\n", @@ -1036,12 +1037,12 @@ "id": "7d50da5c-ed51-4b70-b500-9b3081b7f2c2", "metadata": {}, "source": [ - "We can then plot the difference between the UM data and the data regridded from LFRic. Since our data is now on a latlon grid we can do this with matplotlib as normal." + "We can then plot the difference between the UM data and the data regridded from LFRic. Since all our data is now on a latlon grid we can subtract to find the difference between the regridded LFRic data and equivalent UM data and plot this with matplotlib as normal." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 10, "id": "834c9a53-2c1c-4e85-bee2-db5ab54e42ec", "metadata": {}, "outputs": [ @@ -1059,6 +1060,7 @@ "source": [ "temp_diff = result_2 - grid_temp\n", "\n", + "# We choose a colormap that makes it clear where the differences are.\n", "iqplt.pcolormesh(temp_diff[0, 0], vmin=-4,vmax=4, cmap=\"seismic\")\n", "plt.gca().coastlines()\n", "plt.show()" @@ -1074,7 +1076,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "id": "00a9ca63-726a-4eb4-b4ae-defd5e78e550", "metadata": {}, "outputs": [ @@ -1129,7 +1131,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Air Temperature (K)time
\n", + "
\n", " \n", "\n", "\n", @@ -1225,7 +1227,7 @@ "" ] }, - "execution_count": 22, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -1240,7 +1242,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "id": "d3a56c7d-1986-4a59-82f9-3608b08816c1", "metadata": {}, "outputs": [], @@ -1263,7 +1265,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 13, "id": "63a277ce-927c-4690-a402-b0fd0c96f6c9", "metadata": {}, "outputs": [], @@ -1281,7 +1283,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 14, "id": "0ce148f3-dfdc-4a5c-9c69-c1bcc6d3b830", "metadata": {}, "outputs": [], @@ -1299,7 +1301,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 15, "id": "c9df6e26-9d49-441e-b6a9-77f2989457e7", "metadata": {}, "outputs": [], @@ -1317,7 +1319,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "id": "d994de05-42c3-44d5-a485-8666e9b88e4e", "metadata": {}, "outputs": [ @@ -1366,7 +1368,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 17, "id": "ed3e37dd-27ef-4d4d-a753-18d1d605a36f", "metadata": {}, "outputs": [], @@ -1395,7 +1397,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 18, "id": "4671d53e-d4ae-42b4-9608-7bd416a8d1eb", "metadata": {}, "outputs": [], @@ -1418,7 +1420,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 19, "id": "e0eb804f-737a-4b6c-a469-6917e2b27087", "metadata": {}, "outputs": [], @@ -1436,7 +1438,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 20, "id": "6a358122-28c7-4276-90b6-9427f38cbf3c", "metadata": {}, "outputs": [ @@ -1491,7 +1493,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)--
\n", + "
\n", " \n", "\n", "\n", @@ -1524,7 +1526,7 @@ "" ] }, - "execution_count": 90, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1552,7 +1554,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 21, "id": "3c629318-c076-44ee-86b2-10188d5d5067", "metadata": {}, "outputs": [], @@ -1565,12 +1567,12 @@ "id": "c66c9fe0-d75b-4402-bcc0-ab675beb2c74", "metadata": {}, "source": [ - "**Step 5:** Apply this regridder to `mesh_cube` and print the data from this result (i.e. `print(result_cube.data)`)." + "**Step 5:** Apply this regridder to `mesh_cube` and print the data from this result (i.e. `print(result_cube.data)`) and plot with `iqplt.pcolormesh`." ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 22, "id": "8a7a5d23-0ce6-4673-a227-25f30e96e357", "metadata": {}, "outputs": [ @@ -1612,12 +1614,12 @@ "source": [ "**Step 6:** Repeat step 4 and 5 for `resolution=100`.\n", "\n", - "Note the difference in value. Also note that it takes more time to initialise a regridder with higher resolution." + "Note the difference in value. Also note that it takes more time to initialise a regridder with higher resolution. Higher resolutions ought to be more accurate but there is a tradeoff between performance and accuracy." ] }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 23, "id": "77220820-6d30-430f-bf91-e563e5311a85", "metadata": {}, "outputs": [ @@ -1666,7 +1668,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 24, "id": "fae1a8d7-7e23-4dc6-80e8-f7e864866b10", "metadata": {}, "outputs": [ @@ -1703,21 +1705,191 @@ "source": [ "## Exercise 3: Hovmoller plots\n", "\n", - "If we have data on aditional dimensions, we can use the same approach as exercise 2 to produce a Hovmoller diagram. That is, if we have data that varies along time we can take the area weighted mean over latitude bands and plot the data aginst longitude and time (or similarly, we can plot against latitude and time).\n", + "If we have data on aditional dimensions, we can use the same approach as exercise 2 to produce a Hovmoller diagram. That is, if we have data that varies along time we can take the area weighted mean over latitude bands and plot the data aginst latitude and time (or similarly, we can plot against longitude and time).\n", "\n", - "**Step 1:** Load a temperature cube using the `testdata_fetching` function `lfric_temp`. Extract a single pressure slice using the `cube.extract` method with a constraint `iris.Constraint(pressure=850)` as the argument (we choose this level because it has noticable details)." + "**Step 1:** Load a cube with humidity data using the `testdata_fetching` function `lfric_rh_alltimes_3d`." ] }, { - "cell_type": "markdown", - "id": "9aa7616d-15de-4aaf-a4a1-7268db19a963", + "cell_type": "code", + "execution_count": 25, + "id": "5331317a-ef26-4915-a561-f55629a2d168", "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "
Unknown (unknown)longitude
\n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "
Relative Humidity At Screen Level (1)time--
Shape24221184
Dimension coordinates
\ttimex-
Mesh coordinates
\tlatitude-x
\tlongitude-x
Auxiliary coordinates
\tforecast_periodx-
Mesh
\tnameTopology data of 2D unstructured mesh
\tlocationface
Scalar coordinates
\tforecast_reference_time2021-03-24 00:00:00
Cell methods
\tpointtime
Attributes
\tConventions'CF-1.7'
\tdescription'Created by xios'
\tinterval_operation'6 h'
\tinterval_write'6 h'
\tonline_operation'instant'
\ttitle'Created by xios'
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from testdata_fetching import fric_temp\n", - "mesh_temp = lfric_temp()\n", + "from testdata_fetching import lfric_rh_alltimes_3d\n", "\n", - "temp_slice = mesh_temp.extract(iris.Constraint(pressure=850))\n", - "temp_slice" + "humidity_cube = lfric_rh_alltimes_3d()\n", + "humidity_cube" ] }, { @@ -1725,13 +1897,13 @@ "id": "c6fb7bac-3d96-4ba8-abca-423d77969f14", "metadata": {}, "source": [ - "**Step 2:** Create a target cube whose longitude coordinate is derived from the UM cube loaded from `um_orography` and whose latitude coordinate has bounds `[[-180, 180]]`. This can be done by slicing a cube derived from `um_orography` (using the slice `[:1]` so that this dimension isnt collapsed), removing the latitude coordinate and adding a latitude coordinate with bounds `[[-180, 180]]` (you can reuse the coordinate from exercise 2)." + "**Step 2:** Create a target cube whose latitude coordinate is derived from the UM cube loaded from `um_orography` and whose longitude coordinate has bounds `[[-180, 180]]`. This can be done by slicing a cube derived from `um_orography` (using the slice `[:, :1]` so that this dimension isnt collapsed), removing the longitude coordinate and adding a longitude coordinate with bounds `[[-180, 180]]` (you can reuse the coordinate from exercise 2)." ] }, { "cell_type": "code", - "execution_count": 59, - "id": "e5461e53-4129-440d-8660-b8a372b52ab7", + "execution_count": 26, + "id": "a3feb23e-e43c-4dee-a0b1-984225e292c4", "metadata": {}, "outputs": [ { @@ -1785,7 +1957,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "\n", + "
\n", " \n", "\n", "\n", @@ -1793,8 +1965,8 @@ "\n", " \n", "\n", + "\n", "\n", - "\n", "\n", " \n", " \n", @@ -1874,34 +2046,34 @@ " " ], "text/plain": [ - "" + "" ] }, - "execution_count": 59, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "target_cube_lons = grid_cube[:1]\n", - "target_cube_lons.remove_coord(\"latitude\")\n", - "target_cube_lons.add_dim_coord(lat_full, 0)\n", - "target_cube_lons" + "target_cube_lats = grid_cube[:,:1]\n", + "target_cube_lats.remove_coord(\"longitude\")\n", + "target_cube_lats.add_dim_coord(lon_full, 1)\n", + "target_cube_lats" ] }, { "cell_type": "code", - "execution_count": 74, - "id": "a3feb23e-e43c-4dee-a0b1-984225e292c4", + "execution_count": 27, + "id": "e5461e53-4129-440d-8660-b8a372b52ab7", "metadata": {}, "outputs": [], "source": [ - "# We also can do the same thing for bands of constant latitude.\n", + "# We also can do the same thing for bands of constant longitude.\n", "\n", - "# target_cube_lats = grid_cube[:,:1]\n", - "# target_cube_lats.remove_coord(\"longitude\")\n", - "# target_cube_lats.add_dim_coord(lon_full, 1)\n", - "# target_cube_lats" + "# target_cube_lons = grid_cube[:1]\n", + "# target_cube_lons.remove_coord(\"latitude\")\n", + "# target_cube_lons.add_dim_coord(lat_full, 0)\n", + "# target_cube_lons" ] }, { @@ -1909,13 +2081,13 @@ "id": "7237c86a-1c61-43e9-8954-876f1dcfebdd", "metadata": {}, "source": [ - "**Step 3:** Create a `MeshToGridESMFRegridder` regridder from the slice of the temperature cube onto the target cube. Set the resolution keyword to 2 (this should be sufficient since these are bands of constant longitude). Use this regridder to create a resulting cube." + "**Step 3:** Create a `MeshToGridESMFRegridder` regridder from the slice of the humidity cube onto the target cube. Set the resolution keyword to 500 (this should be good balance of accuracy and performance). Use this regridder to create a resulting cube." ] }, { "cell_type": "code", - "execution_count": 71, - "id": "7c3b0154-7be3-48ac-a3bd-ae68b414b6d1", + "execution_count": 28, + "id": "f2bb8a41-3344-4cf3-bcc9-5e67981355b1", "metadata": {}, "outputs": [ { @@ -1969,9 +2141,9 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)latitude
Shape4801640
Dimension coordinates
\n", + "
\n", " \n", - "\n", + "\n", "\n", "\n", "\n", @@ -1979,8 +2151,8 @@ " \n", "\n", "\n", + "\n", "\n", - "\n", "\n", " \n", " \n", @@ -2029,10 +2201,6 @@ " \n", "\n", "\n", - " \n", - " \n", - "\n", - "\n", " \n", " \n", " \n", @@ -2076,30 +2244,34 @@ " " ], "text/plain": [ - "" + "" ] }, - "execution_count": 71, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "um_lon_band_mean_calculator = MeshToGridESMFRegridder(temp_slice, target_cube_lons, resolution=2)\n", - "um_lon_bound_means = um_lon_band_mean_calculator(temp_slice)\n", - "um_lon_bound_means" + "um_lat_band_mean_calculator = MeshToGridESMFRegridder(humidity_cube, target_cube_lats, resolution=500)\n", + "um_lat_band_means = um_lat_band_mean_calculator(humidity_cube)\n", + "um_lat_band_means" ] }, { "cell_type": "code", - "execution_count": 75, - "id": "f2bb8a41-3344-4cf3-bcc9-5e67981355b1", + "execution_count": 29, + "id": "7c3b0154-7be3-48ac-a3bd-ae68b414b6d1", "metadata": {}, "outputs": [], "source": [ - "# um_lat_band_mean_calculator = MeshToGridESMFRegridder(temp_slice, target_cube, resolution=500)\n", - "# um_lat_bound_means = um_lat_band_mean_calculator(temp_slice)\n", - "# um_lat_bound_means" + "# Continuing for bands of constant longitude.\n", + "# Note: this code takes about 2 minutes to run. I think this is due to with the way ESMF handles cells\n", + "# with unusual shapes. See https://github.com/SciTools-incubator/iris-esmf-regrid/issues/234.\n", + "\n", + "# um_lon_band_mean_calculator = MeshToGridESMFRegridder(humidity_cube, target_cube_lons, resolution=2)\n", + "# um_lon_band_means = um_lon_band_mean_calculator(humidity_cube)\n", + "# um_lon_band_means" ] }, { @@ -2107,13 +2279,13 @@ "id": "cf4e2acb-8e87-47be-9a4b-81b7cbf86fa6", "metadata": {}, "source": [ - "**Step 4:** Plot the data in the resulting cube. This can be done with `iqplt.pcolormesh`. Note that the resulting cube will have an unnecessary dimension which will have to be sliced (using `[:, 0]`). Note that extra steps can be taken to format the dates for this plot." + "**Step 4:** Plot the data in the resulting cube. This can be done with `iqplt.pcolormesh`. Note that the resulting cube will have an unnecessary dimension which will have to be sliced (using `[:, :, 0]`). Note that extra steps can be taken to format the dates for this plot." ] }, { "cell_type": "code", - "execution_count": 81, - "id": "4f191e7c-ed12-483b-885c-3e510aab7829", + "execution_count": 30, + "id": "4762302c-33f2-466a-9330-b15501a2d4e8", "metadata": {}, "outputs": [ { @@ -2126,7 +2298,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2137,28 +2309,29 @@ ], "source": [ "import matplotlib.dates as mdates\n", - "\n", - "iqplt.pcolormesh(um_lon_bound_means[:, 0, :])\n", - "plt.gca().yaxis.set_major_formatter(mdates.DateFormatter(\"%D\"))\n", + "# We use a colormap which highlights fine details.\n", + "iqplt.pcolormesh(um_lat_band_means[:, :, 0])\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter(\"%D\"))\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 76, - "id": "4762302c-33f2-466a-9330-b15501a2d4e8", + "execution_count": 31, + "id": "4f191e7c-ed12-483b-885c-3e510aab7829", "metadata": {}, "outputs": [], "source": [ - "# import matplotlib.dates as mdates\n", - "# iqplt.pcolormesh(um_lat_bound_means[:, :, 0])\n", - "# plt.gca().xaxis.set_major_formatter(mdates.DateFormatter(\"%D\"))\n", + "# Continuing for bands of constant longitude.\n", + "\n", + "# iqplt.pcolormesh(um_lon_band_means[:, 0])\n", + "# plt.gca().yaxis.set_major_formatter(mdates.DateFormatter(\"%D\"))\n", "# plt.show()" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 32, "id": "d8f4162e-d1b0-4205-9322-abf3f0840f57", "metadata": {}, "outputs": [], From 418d2585a51cb243699a1b2a300e6fd427d260c9 Mon Sep 17 00:00:00 2001 From: "stephen.worsley" Date: Wed, 25 Jan 2023 14:31:54 +0000 Subject: [PATCH 2/3] jupytext sync --- notebooks/.notebook_shadow_copies/Sec_05_Regridding.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md b/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md index 9761981..2df4694 100644 --- a/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md +++ b/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md @@ -276,7 +276,7 @@ print(lon_band_mean_10.data) ## Exercise 3: Hovmoller plots -If we have data on aditional dimensions, we can use the same approach as exercise 2 to produce a Hovmoller diagram. That is, if we have data that varies along time we can take the area weighted mean over latitude bands and plot the data aginst longitude and time (or similarly, we can plot against latitude and time). +If we have data on aditional dimensions, we can use the same approach as exercise 2 to produce a Hovmoller diagram. That is, if we have data that varies along time we can take the area weighted mean over latitude bands and plot the data aginst latitude and time (or similarly, we can plot against longitude and time). **Step 1:** Load a cube with humidity data using the `testdata_fetching` function `lfric_rh_alltimes_3d`. From aa93e7120ff5f51afdb3a5f768b2bff7997c2fff Mon Sep 17 00:00:00 2001 From: "stephen.worsley" Date: Thu, 26 Jan 2023 16:50:00 +0000 Subject: [PATCH 3/3] remove unnecessary imports --- .../Sec_05_Regridding.md | 9 ----- notebooks/Sec_05_Regridding.ipynb | 33 ++++++------------- 2 files changed, 10 insertions(+), 32 deletions(-) diff --git a/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md b/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md index 2df4694..dae86b5 100644 --- a/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md +++ b/notebooks/.notebook_shadow_copies/Sec_05_Regridding.md @@ -17,12 +17,7 @@ jupyter: ## Set up ```python -from pathlib import Path -import numpy as np - from esmf_regrid.experimental.unstructured_scheme import MeshToGridESMFRegridder, GridToMeshESMFRegridder -import iris -from iris import load, load_cube from iris.coords import DimCoord from iris.cube import Cube ``` @@ -348,7 +343,3 @@ plt.show() # Use this regridder to compare how well bilinear regridding and area weighted # regridding preserve area weighted mean after round tripping. ``` - -```python - -``` diff --git a/notebooks/Sec_05_Regridding.ipynb b/notebooks/Sec_05_Regridding.ipynb index 6b67f3d..23f71d3 100644 --- a/notebooks/Sec_05_Regridding.ipynb +++ b/notebooks/Sec_05_Regridding.ipynb @@ -17,12 +17,7 @@ "metadata": {}, "outputs": [], "source": [ - "from pathlib import Path\n", - "import numpy as np\n", - "\n", "from esmf_regrid.experimental.unstructured_scheme import MeshToGridESMFRegridder, GridToMeshESMFRegridder\n", - "import iris\n", - "from iris import load, load_cube\n", "from iris.coords import DimCoord\n", "from iris.cube import Cube" ] @@ -100,7 +95,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Air Temperature (K)Relative Humidity At Screen Level (1)timelatitudelongitude
Shape244801640
Dimension coordinates2021-03-24 00:00:00
\tpressure850.0 hPa
Cell methods
\n", + "
\n", " \n", "\n", "\n", @@ -260,7 +255,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)--
\n", + "
\n", " \n", "\n", "\n", @@ -450,7 +445,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)latitude
\n", + "
\n", " \n", "\n", "\n", @@ -614,7 +609,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)latitude
\n", + "
\n", " \n", "\n", "\n", @@ -819,7 +814,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Air Temperature (K)time
\n", + "
\n", " \n", "\n", "\n", @@ -1131,7 +1126,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Air Temperature (K)time
\n", + "
\n", " \n", "\n", "\n", @@ -1493,7 +1488,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)--
\n", + "
\n", " \n", "\n", "\n", @@ -1767,7 +1762,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Unknown (unknown)longitude
\n", + "
\n", " \n", "\n", "\n", @@ -1957,7 +1952,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Relative Humidity At Screen Level (1)time
\n", + "
\n", " \n", "\n", "\n", @@ -2141,7 +2136,7 @@ " margin-top: 7px;\n", " }\n", "\n", - "
Surface Altitude (m)latitude
\n", + "
\n", " \n", "\n", "\n", @@ -2342,14 +2337,6 @@ "# Use this regridder to compare how well bilinear regridding and area weighted\n", "# regridding preserve area weighted mean after round tripping." ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "280e4932-3978-441b-82c8-83c300f9ee4a", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": {
Relative Humidity At Screen Level (1)time