notebooks/create-SLIIDERS-ECON/exposure/5-get_positive_elev_tiles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define lists of tiles to be processed in the gridded exposure step\n",
    "- `WITHELEV`: Include information on exposure, elevation, and other boundaries.\n",
    "- `WITHOUTELEV`: Include information on exposure and other boundaries, but not elevation.\n",
    "- `CIAM`: Include information on elevation and other boundaries, but not exposure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geopandas as gpd\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import rhg_compute_tools.kubernetes as rhgk\n",
    "import xarray as xr\n",
    "from sliiders import settings as sset\n",
    "from sliiders import spatial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nworkers = 16\n",
    "\n",
    "client, cluster = rhgk.get_micro_cluster()\n",
    "\n",
    "cluster.scale(nworkers)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lat_size = 43200\n",
    "lon_size = 86400\n",
    "\n",
    "lats_per_deg, lons_per_deg = int(lat_size / 180), int(lon_size / 360)\n",
    "\n",
    "lon_chunk = int(lon_size / nworkers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bdem = xr.open_dataarray(sset.PATH_SRTM15_PLUS, chunks={\"lat\": lats_per_deg}).persist()\n",
    "\n",
    "bdem_max = (\n",
    "    bdem.coarsen(lat=lats_per_deg).max().coarsen(lon=lons_per_deg).max().compute()\n",
    ")\n",
    "\n",
    "bdem_min = (\n",
    "    bdem.coarsen(lat=lats_per_deg).min().coarsen(lon=lons_per_deg).min().compute()\n",
    ")\n",
    "\n",
    "bdem_max.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bdem_min.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-check that the grid's spacing is regular over 1-degree tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert len(np.unique(np.floor(bdem.lat.values[:lats_per_deg]))) == 1\n",
    "assert len(np.unique(np.floor(bdem.lon.values[:lons_per_deg]))) == 1\n",
    "\n",
    "assert (np.floor(bdem.lat.values)[::lats_per_deg] == np.arange(-90, 90)).sum() == 180\n",
    "assert (np.floor(bdem.lon.values)[::lons_per_deg] == np.arange(-180, 180)).sum() == 360"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shut down cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.close()\n",
    "cluster.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Organize tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_tiles = bdem_max.to_dataframe(name=\"max\").reset_index()\n",
    "min_tiles = bdem_min.to_dataframe(name=\"min\").reset_index()\n",
    "\n",
    "tiles = pd.merge(max_tiles, min_tiles, on=[\"lat\", \"lon\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determine whether each tile meets certain criteria, which will be used to define categories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prepare tiles and category sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiles[\"tile_name\"] = spatial.get_tile_names(tiles, \"lon\", \"lat\")\n",
    "\n",
    "tiles = gpd.GeoDataFrame(tiles, geometry=tiles.apply(spatial.get_degree_box, axis=1))\n",
    "\n",
    "tiles[\"llat\"] = np.floor(tiles[\"lat\"])\n",
    "tiles[\"llon\"] = np.floor(tiles[\"lon\"])\n",
    "\n",
    "assets = pd.read_parquet(sset.PATH_EXPOSURE_BLENDED, columns=[\"x_ix\", \"y_ix\"]).values.T\n",
    "exp_tiles = spatial.get_all_exp_tiles(*assets)\n",
    "\n",
    "pop = pd.read_parquet(sset.PATH_LANDSCAN_INT)\n",
    "pop = pop.loc[pop.population > 0, [\"x_ix\", \"y_ix\"]].values.T\n",
    "pop_tiles = spatial.get_all_exp_tiles(*pop)\n",
    "\n",
    "coastaldem_tiles = [t.stem for t in sset.DIR_COASTALDEM.glob(\"*.tif\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply category logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tile is included in CoastalDEM\n",
    "tiles[\"coastaldem\"] = tiles[\"tile_name\"].isin(coastaldem_tiles)\n",
    "\n",
    "# Tile has non-0 asset-value\n",
    "tiles[\"exp\"] = tiles[\"tile_name\"].isin(exp_tiles)\n",
    "\n",
    "# Tile has non-0 population\n",
    "tiles[\"pop\"] = tiles[\"tile_name\"].isin(pop_tiles)\n",
    "\n",
    "# Tile is below the 60th parallel south (governed under the Antarctic Treaty System)\n",
    "tiles[\"antarctica\"] = tiles[\"lat\"] < -60\n",
    "\n",
    "# Tile includes elevations below 50 meters\n",
    "tiles[\"below50\"] = tiles[\"min\"] <= 50\n",
    "\n",
    "# Tile includes elevations above -50 meters\n",
    "tiles[\"above_neg50\"] = tiles[\"max\"] >= -50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save list of low-lying tiles that are not contiguous with the ocean (\"inland\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ocean_shape = tiles[tiles[\"below50\"]].buffer(0.01).unary_union\n",
    "\n",
    "ocean_shape = list(ocean_shape.geoms)[np.argmax([g.area for g in ocean_shape.geoms])]\n",
    "\n",
    "tiles[\"contiguous_with_ocean\"] = tiles[\"geometry\"].within(ocean_shape)\n",
    "\n",
    "tiles[tiles[\"contiguous_with_ocean\"]].plot(figsize=(20, 20))\n",
    "\n",
    "inland = (\n",
    "    tiles[(tiles[\"coastaldem\"]) & (~tiles[\"contiguous_with_ocean\"])][[\"tile_name\"]]\n",
    "    .sort_values(\"tile_name\")\n",
    "    .reset_index(drop=True)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Categorize tiles based on whether they are relevant to each group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiles = tiles[~tiles[\"tile_name\"].isin(inland[\"tile_name\"].to_numpy())].reset_index(\n",
    "    drop=True\n",
    ")\n",
    "\n",
    "tiles[\"WITHELEV\"] = (tiles[\"below50\"] | tiles[\"coastaldem\"]) & tiles[\"exp\"]\n",
    "tiles[\"WITHOUTELEV\"] = tiles[\"exp\"] & (~tiles[\"WITHELEV\"])\n",
    "tiles[\"CIAM\"] = (\n",
    "    (tiles[\"above_neg50\"])\n",
    "    & (tiles[\"below50\"] | tiles[\"coastaldem\"])\n",
    "    & (~tiles[\"antarctica\"])\n",
    "    & (~tiles[\"exp\"])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot tile categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_color(tile):\n",
    "    if tile[\"WITHELEV\"]:\n",
    "        return \"purple\"\n",
    "    if tile[\"WITHOUTELEV\"]:\n",
    "        return \"green\"\n",
    "    if tile[\"CIAM\"]:\n",
    "        return \"orange\"\n",
    "    return \"blue\"\n",
    "\n",
    "\n",
    "tiles[\"color\"] = tiles.apply(get_color, axis=1)\n",
    "tiles.plot(color=tiles[\"color\"], figsize=(20, 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transform booleans into categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiles[\"PROCESSING_SET\"] = np.where(\n",
    "    tiles[\"WITHELEV\"],\n",
    "    \"WITHELEV\",\n",
    "    np.where(\n",
    "        tiles[\"WITHOUTELEV\"], \"WITHOUTELEV\", np.where(tiles[\"CIAM\"], \"CIAM\", None)\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out = tiles[[\"tile_name\", \"PROCESSING_SET\"]]\n",
    "\n",
    "out = out[pd.notnull(out[\"PROCESSING_SET\"])].reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out.to_parquet(sset.PATH_EXPOSURE_TILE_LIST, index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.9.12"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}