diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8449e86 --- /dev/null +++ b/.gitignore @@ -0,0 +1,92 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover + +# Translations +*.mo +*.pot + +# Django stuff: +*.log + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# DotEnv configuration +.env + +# Database +*.db +*.rdb + +# Pycharm +.idea + +# VS Code +.vscode/ + +# Spyder +.spyproject/ + +# Jupyter NB Checkpoints +.ipynb_checkpoints/ + +# exclude data from source control by default +/data/ + +# Mac OS-specific storage files +.DS_Store + +# vim +*.swp +*.swo + +# Mypy cache +.mypy_cache/ + +# dask +dask-worker-space \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..0e2b9a4 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "LocalizeSL"] + path = LocalizeSL + url = git@github.com:bobkopp/LocalizeSL.git diff --git a/HISTORY.rst b/HISTORY.rst new file mode 100644 index 0000000..c7a92b1 --- /dev/null +++ b/HISTORY.rst @@ -0,0 +1,11 @@ +History +======= + +.. v1.0.0: + +v1.0.0 +------ + +Released on April 8, 2022 + +Initial commit. Version associated with initial manuscript submission. \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..5a03fdd --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Climate Impact Lab + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..ad3c0c2 --- /dev/null +++ b/README.md @@ -0,0 +1,92 @@ +[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6010452.svg)](https://doi.org/10.5281/zenodo.6010452) +[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6012027.svg)](https://doi.org/10.5281/zenodo.6012027) + +# Sea Level Impacts Input Dataset by Elevation, Region, and Scenario (SLIIDERS) + +This repository hosts the code used to create the [SLIIDERS-ECON](https://doi.org/10.5281/zenodo.6010452) and [SLIIDERS-SLR](https://doi.org/10.5281/zenodo.6012027) datasets. The SLIIDERS datasets contain current and forecasted physical and socioeconomic metrics from 2000-2100 - organized by coastal segment, elevation slice, and scenario - for use as inputs to global coastal climate impacts research. + +**SLIIDERS-ECON** contains socioeconomic variables, varying horizontally and vertically over space. **SLIIDERS-SLR** contains Monte Carlo projections of Local Sea Level Rise under different emissions and ice sheet dynamics assumptions, based on the outputs of [LocalizeSL](https://github.com/bobkopp/LocalizeSL). Coastal segments in SLIIDERS-ECON can be matched to gridded LSLR projections in SLIIDERS-SLR via the `SLR_site` key. + +All work utilizing this code or the resulting SLIIDERS datasets should cite Depsky, Bolliger et al. 2022 (in prep.). See [License](#license) for details. + +## Installation +Most users will want to just use the datasets directly, accessible at the DOIs linked above. If you wish to recreate and/or modify the datasets, which we encourage, you will need to run the Jupyter notebooks in this repository. A collection of helper functions, organized into a Python package, is necessary to run the notebooks and can be found within the `sliiders` directory. A simple pip install will install this package + +```bash +pip install -e sliiders +``` + +In addition, you will need to have [Dask Gateway](https://gateway.dask.org) installed and configured to execute the parallel, Dask-backed workflows contained in this repo. Advanced users can use other Dask Cluster backends (including simply running [Dask Distributed](https://distributed.dask.org) locally), but doing so will require modifying the cluster setup portion of notebooks that employ dask. + +A Conda environment file better specifying a full environment needed to execute all of the workflows in this repo is in development and will be posted when complete. + +## Filepaths and other settings +All filepaths and settings for the notebooks can be found within `settings.py`. Before moving onto executing different parts of this repository, please adjust these settings to match your directory structure and desired values. Most values will not need to be updated unless you change a particular dataset. However, at minimum you should: + +1. Update the `DIR_DATA` filepath within this file to point to the root directory within which all of the data consumed and generated by this workflow will live. +2. Update `DASK_IMAGE` to point to a Docker Image that you will use for Dask workers (advanced users not using Dask Gateway may not need this parameter). + +## Package Structure +* `sliiders`: Contains `.py` files with essential settings and functions for the SLIIDERS workflow + - `settings.py`: Contains essential settings, including various parameters and data storage directories + - `gcs.py`: Contains functions related to the use of Google Cloud Storage (GCS). Users running workflows locally or on a different cloud provider are encouraged to contribute similar modules for other contexts. + - `io.py`: Contains various I/O-related functions + - `spatial.py`: Contains functions for executing spatial and geographic operations including those related to shapefiles, grid-cell level operations, and more. + - `dask.py`: Contains utility functions for working with dask clusters + - `country_level_ypk.py`: Contains functions for cleaning and working with country-level socioeconomic data, especially for the workflow in `notebooks/country_level_ypk` + +* `notebooks`: contains the workflows to create SLIIDERS-ECON and SLIIDERS-SLR. + +## Instructions (Generating SLIIDERS-ECON and SLIIDERS-SLR) + +To generate **SLIIDERS-ECON** and **SLIIDERS-SLR**, please follow the directions in `notebooks/README.md` and other readme files in the subdirectories within `notebooks` to learn about how to execute the workflows. +\ +The list and order of notebooks to run is reproduced in full here, along with any necessary manual steps. Click the `docs` link for each workflow to navigate to the relevant directory's page. + +1. `create-SLIIDERS-SLR` ([docs](notebooks/create-SLIIDERS-SLR)): Workflow to generate **SLIIDERS-SLR** + 1. `download-ifile-to-gcs.ipynb` + 2. `convert-mat-version.ipynb` + 3. `generate-projected-lsl.ipynb` + 4. `retrieve-num-gcms.ipynb` + 5. `process-localizesl-output.ipynb` +2. `create-SLIIDERS-ECON` ([docs](notebooks/create-SLIIDERS-ECON)): Workflow to generate **SLIIDERS-ECON** + 1. `download-sliiders-econ-input-data.ipynb` + 2. `country_level_ypk` ([docs](notebooks/create-SLIIDERS-ECON/country_level_ypk)): Workflow for organizing and projecting GDP (Y), population (P), capital stock (K), and related variables for historical (1950-2020) and future (2010-2100) timelines. + 1. `ypk1_prep_clean.ipynb` + 2. `ypk2_reorg_and_impute_ypk.ipynb` + 3. `ypk3_demo_ratios_historical_reg.ipynb` + 4. `ypk4_impute_hist_capital.ipynb` + 5. `ypk5_projected_yp.ipynb` + 6. `ypk6_projected_capital.ipynb` + 3. `exposure` ([docs](notebooks/create-SLIIDERS-ECON/exposure)): Workflow to generate present-day exposure grid. + 1. `1-create-coastline-segments.ipynb` + 2. `2-create-segment-regions.ipynb` + 3. `3-fill_missing_litpop_with_geg.ipynb` + 4. `4-vectorize-wetlands.ipynb` + 5. `5-get_positive_elev_tiles.ipynb` + 6. `6-generate_datum_conversion_grid.ipynb` + 7. `7-create_dem_mss.ipynb` + 8. `8-generate_protected_areas.ipynb` + 9. `9-generate_exposure_tiles.ipynb` + 10. `10-combine_exposure_tiles.ipynb` + 4. `create-SLIIDERS-ECON.ipynb` + +The resulting datasets can be found at these paths, defined in `settings.py`: +**SLIIDERS-ECON**: `PATH_SLIIDERS_ECON` +**SLIIDERS-SLR**: `PATH_SLIIDERS_SLR` + +## Support +Please file an issue for any problems you encounter. + +## Contributing +We encourage community contributions. At the moment, we have no contribution template. Please fork the project and file a Merge Request to propose your addition. Clearly define the contribution that the Merge Request is making and, when any issues have been resolved, we will merge the new code. + +## Authors +The original authors of this code include: +- Daniel Allen +- Ian Bolliger +- Junho Choi +- Nicholas Depsky + +## License +This code is licensed under the [MIT License](./LICENSE). However, we request that wherever this code or the SLIIDERS datasets are used, that the underlying manuscript (Depsky et al. 2022) is cited. A citation guide will be posted once the manuscript preprint is available. \ No newline at end of file diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..9daafb6 --- /dev/null +++ b/notebooks/README.md @@ -0,0 +1,6 @@ +# Instructions + +This directory contains sub-directories to produce final SLIIDERS outputs. The order of execution is as follows. For further instructions, we refer to the `README.md` files in the respective sub-directories. + +1. `create-SLIIDERS-SLR`: Workflow to generate **SLIIDERS-SLR**, a dataset of gridded local sea-level Monte Carlo samples for each RCP scenario, year (decadal), and site ID (defined by LocalizeSL). +2. `create-SLIIDERS-ECON`: Workflow to generate **SLIIDERS-ECON**, a dataset containing socioeconomic variables by coastal segment, elevation, Shared Socioeconomic Pathway scenario. Note that this workflow uses the SLIIDERS-SLR dataset to find nearest grid cells to match to coastal segments. diff --git a/notebooks/create-SLIIDERS-ECON/README.md b/notebooks/create-SLIIDERS-ECON/README.md new file mode 100644 index 0000000..a782e3d --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/README.md @@ -0,0 +1,10 @@ +# Workflow for generating the SLIIDERS-ECON dataset + +This directory contains notebooks to generate the **SLIIDERS-ECON** dataset. The final output for future projections is a Zarr store containing socioeconomic variables binned by coastal segment, elevation slice, and Shared Socioeconomic Pathway. + +The steps to produce the final output are as follows. + +1. Use `download-sliiders-econ-input-data.ipynb` to download necessary datasets, including various country-level datasets and datasets such as including World Bank Intercomparison Project 2017 and construction cost index by Lincke and Hinkel (2021, *Earth's Future*). +2. Go to the directory `country_level_ypk` and follow the instructions in the `README.md` in that directory. The workflow in `country_level_ypk` cleans (and when necessary, imputes) various country-level socioeconomic variables. +3. Go to the directory `exposure` and follow the instructions in the `README.md` in that directory. The workflow in `exposure` generates current-day global exposure data by coastal segment, elevation, and other variables. +4. Use `create-SLIIDERS-ECON.ipynb` to combine disparate data sources to generate the final output. diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/README.md b/notebooks/create-SLIIDERS-ECON/country_level_ypk/README.md new file mode 100644 index 0000000..d966523 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/README.md @@ -0,0 +1,67 @@ +# Workflow for organizing and projecting GDP (`Y`), population (`P`), capital stock (`K`), and related variables for historical (1950-2020) and future (2010-2100) timelines + +**This version: last updated on March 30, 2022** + +## 1. Overview + +This directory contains the data acquistion, clean-up, and projection notebook files to organize and project variables including GDP, GDP per capita (GDPpc), population, and capital stock for both historical (1950-2020) and future or projected (2010-2100) timelines. Many of the data sources used to generate historical and future panels have missing data, and therefore efforts were made to impute these missing data through either some form of extrapolation or other established methods. Also, efforts were made to keep the PPP and USD units consistent (e.g., constant 2019 PPP USD) across different sources having different vintages of PPP and USD units. + +Below is a quick summary of what each file seeks to accomplish (where the header `ypk` stands for "GDP, population, and capital stock"). +1. `ypk1_prep_clean.ipynb`: cleans up selected raw datasets requiring more attention than others to be consistent and workable with other datasets. +2. `ypk2_reorg_and_impute.ipynb`: reorganizes the raw and previously-cleaned historical datasets so that each variable considered has a single, consistent stream of values for each country. After this process, imputes missing GDPpc, GDP, and population values that might still be missing from the cleaned historical dataset. +3. `ypk3_demo_ratios_historical_reg.ipynb`: contains code to clean and extrapolate demographic (age-group) ratios and create the "demographic variables" necessary to conduct the "historical regression" (According to Higgins, 1998) of finding the relationship between investment-to-GDP ratio (I/Y ratio) and demographic variables, (relative) GDPpc, and GDPpc growth rate. Furthermore, the said historical regression is conducted to acquire estimates of investment-to-GDP ratios for missing country-years. +4. `ypk4_impute_hist_capital.ipynb`: contains code to use the historical and estimated investment-to-GDP ratios to create current-PPP investment values. These are used to replicate the initial-year capital stock estimation (country-by-country) as described in Inklaar, Woltjer, and Albarrán (2019). Also, the investment values are used in conjunction with GEG-15 and LitPop data sources to fill in missing values for the latter parts of the historical capital stock data. The end product is a filled (1950-2020) capital stock data for all relevant countries. +5. `ypk5_projected_yp.ipynb`: contains code to clean up GDP, GDPpc, and population for the future timeline, with some basic extrapolation conducted for countries with missing projections. +6. `ypk6_projected_capital.ipynb`: generates projections of capital stocks based on the Dellink et al. (2017) methodology. + +For running these files, note that they have to be **run consecutively** (i.e., from `ypk1~` to `ypk7~`). Each notebook file contains basic descriptions on what each step does; in all cases, the cells must be run consecutively from top to bottom. + +## 2. Basic description of key variables + +We describe below some key variables produced by the above process. Note that our naming conventions largely follow Penn World Table 10.0. +- `cgdpo_19`: Current PPP (purchasing power parity) GDP in millions of 2017 and 2019 USD +- `cgdpo_pc_19`: Current PPP GDP per capita in ones of 2017 and 2019 USD +- `rgdpna_19`: (National account-based) GDP in millions of constant 2019 PPP USD +- `rgdpna_pc_19`: (National account-based) GDP per capita in ones of constant 2019 PPP USD +- `cn_19`: Current PPP capital stock in millions of 2019 USD +- `rnna_19`: Capital stock in millions of constant PPP 2019 USD +- `pop`: Population in millions of people +- `k_movable_ratio`: ratio movable capital out of total physical capital (values in ) +- `iy_ratio`: Investment-to-GDP ratio +- `delta`: Physical capital depreciation rate + +Note that for GDP, GDP per capita, and capital stock variables, there are also versions with `_17` at the end instead of `_19`. For current PPP variables, this means using 2017 USD; for constant PPP variables, this means using constant 2017 PPP USD (i.e., constant PPP of 2017 and 2017 USD). + +## 3. Output storage + +We import the SLIIDERS `settings.py` as `sset`, which can be done as follows: +``` +from sliiders import as settings as sset +``` +For the aggregate long-panel format historical and future timeline variables, you may refer to the following: +1. Historical: `sset.DIR_YPK_FINAL / "gdp_gdppc_pop_capital_1950_2020.parquet"` +2. Future: `sset.DIR_YPK_FINAL / "gdp_gdppc_pop_capital_proj_2010_2100.parquet"` + +where the metadata (e.g., units and sources) are also attached to the respective files. + +## 4. Regression results for imputing missing historical investment-to-GDP ratios + +We elaborate on the regression involving investment-to-GDP ratios mentioned in Section A3.2 in the notebook `ypk4_demo_ratios_historical_reg.ipynb`. The said notebook also contains information on how to derive each variable involved. We present the results below, where the dependent variable is investment-to-GDP ratio (denoted as in the notebook). + +| Variables | (1) | (2) | (3) | (4) | +| ------ | :------: | :------: | :------: | :------: | +| | 0.405
(0.161) | 0.346
(0.076) | 0.502
(0.201) | 0.480
(0.129) | +| | 0.864
(0.742) | 0.515
(0.611) | 0.506
(0.879) | 0.493
(0.915) | +| | -0.021
(0.052) | -0.027
(0.052) | 0.076
(0.022) | 0.108
(0.016) | +| | 0.004
(0.007) | 0.003
(0.006) | -0.011
(0.005) | -0.015
(0.005) | +| | 0.184
(0.186) | | 0.348
(0.190) | | +| | -0.008
(0.035) | | -0.038
(0.030) | | +| | -0.000
(0.002) | | 0.001
(0.001) | | +| | 3.988
(3.149) | | 1.784
(3.945) | | +| | -0.797
(0.570) | | -0.465
(0.597) | | +| | 0.040
(0.028) | | 0.026
(0.026) | | +| | 11145 | 11145 | 11145 | 11145 | +| Country fixed effects | Yes | Yes | No | No | +| Adjusted | 0.325 | 0.315 | 0.068 | 0.054 | +| AIC | -12712 | -12557 | -9317 | -9157 | +| BIC | -11153 | -11042 | -9236 | -9120 | diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk1_prep_clean.ipynb b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk1_prep_clean.ipynb new file mode 100644 index 0000000..0894701 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk1_prep_clean.ipynb @@ -0,0 +1,1011 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e08e3612", + "metadata": {}, + "source": [ + "## Preparing and cleaning files necessary for (country-level) capital stock projection workflow\n", + "\n", + "## Importing necessary modules and functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf9622a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c7606bf", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import shutil\n", + "from operator import itemgetter\n", + "\n", + "import dask.dataframe as ddf\n", + "import dask.delayed as delayed\n", + "import fiona\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pycountry as pyctry\n", + "from dask_gateway import Gateway\n", + "from py7zr import unpack_7zarchive\n", + "from tqdm.auto import tqdm\n", + "\n", + "from sliiders import country_level_ypk as ypk_fn\n", + "from sliiders import settings as sset\n", + "from sliiders import spatial\n", + "\n", + "# dask gateway setup\n", + "gateway = Gateway()\n", + "image_name = sset.DASK_IMAGE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8695ee9-d515-4bd2-a8ac-1bb25656cbcc", + "metadata": {}, + "outputs": [], + "source": [ + "# creating necessary directory\n", + "sset.DIR_YPK_INT.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "id": "4d76358a", + "metadata": {}, + "source": [ + "## Maddison Project: scale change" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0acd5006", + "metadata": {}, + "outputs": [], + "source": [ + "# original file format was excel spreadsheet, so we will read this as is\n", + "madd = pd.read_excel(sset.PATH_MPD_RAW)\n", + "\n", + "# population is in 1000s of people; we will save it to be in millions of people\n", + "madd[\"pop\"] = madd[\"pop\"] / 1000 ## divide by a thousand to get things in millions\n", + "\n", + "# GDPpc is currently in ones of USD; we want gdp to be in millions of USD\n", + "# one USD per million people = 1 million USD per person\n", + "madd[\"gdp\"] = madd[\"gdppc\"] * madd[\"pop\"]\n", + "\n", + "# indexing and exporting\n", + "madd.rename(columns={\"countrycode\": \"ccode\"}, inplace=True)\n", + "madd[\"gdppc_unit\"] = \"ones of USD (constant 2011 PPP USD)\"\n", + "madd[\"gdp_unit\"] = \"millions of USD (constant 2011 PPP USD)\"\n", + "madd[\"pop_unit\"] = \"millions of people\"\n", + "madd.set_index([\"ccode\", \"year\"], inplace=True)\n", + "madd.to_parquet(sset.DIR_YPK_INT / \"maddison_project.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "647b195b", + "metadata": {}, + "source": [ + "## UN WPP: overall populations data\n", + "\n", + "### Assign country (ISO) codes: initial try with obvious cases" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a9ebc1d0", + "metadata": {}, + "outputs": [], + "source": [ + "# importing data\n", + "un_df = pd.read_csv(sset.DIR_UN_WPP_RAW / \"UN_WPP2019_TotalPopulation.csv\")\n", + "\n", + "# let's check whether there are any with \"dependencies\" considered together with sov.s\n", + "for i in set(un_df.Location):\n", + " if \"ependenc\" in i:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3dab957b", + "metadata": {}, + "outputs": [], + "source": [ + "# very minor clean-up for iso country codes; initial\n", + "countryname_to_iso = dict([])\n", + "\n", + "for i in list(set(un_df.Location)):\n", + " name = pyctry.countries.get(name=i)\n", + " oname = pyctry.countries.get(official_name=i)\n", + "\n", + " if name is not None or oname is not None:\n", + " to_use = name\n", + " if name is None:\n", + " to_use = oname\n", + " countryname_to_iso[i] = to_use.alpha_3\n", + " else:\n", + " countryname_to_iso[i] = None\n", + "\n", + "# some mandotory clean-ups required\n", + "# Will not print them as there are too many, but can be checked via print command\n", + "# print(no_isos)\n", + "no_isos = [k for k, v in countryname_to_iso.items() if v is None]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3a6bde1", + "metadata": {}, + "outputs": [], + "source": [ + "# after examining the no_isos list, I conduct the following (manual) clean-up\n", + "to_update = {\n", + " \"Micronesia (Fed. States of)\": \"FSM\",\n", + " \"State of Palestine\": \"PSE\",\n", + " \"China (and dependencies)\": \"CHN+D\",\n", + " \"China, Macao SAR\": \"MAC\",\n", + " \"China, Hong Kong SAR\": \"HKG\",\n", + " \"Bolivia (Plurinational State of)\": \"BOL\",\n", + " \"Saint Helena\": \"SHN\",\n", + " \"Holy See\": \"VAT\",\n", + " \"Venezuela (Bolivarian Republic of)\": \"VEN\",\n", + " \"Iran (Islamic Republic of)\": \"IRN\",\n", + " \"United Kingdom (and dependencies)\": \"GBR+D\",\n", + " \"New Zealand (and dependencies)\": \"NZL+D\",\n", + " \"Dem. People's Republic of Korea\": \"PRK\",\n", + " \"China, Taiwan Province of China\": \"TWN\",\n", + " \"Democratic Republic of the Congo\": \"COD\",\n", + " \"Republic of Korea\": \"KOR\",\n", + " \"United States Virgin Islands\": \"VIR\",\n", + " \"Denmark (and dependencies)\": \"DNK+D\",\n", + " \"France (and dependencies)\": \"FRA+D\",\n", + " \"United States of America (and dependencies)\": \"USA+D\",\n", + " \"Wallis and Futuna Islands\": \"WLF\",\n", + " \"Channel Islands\": \"GGY+JEY\",\n", + " \"Netherlands (and dependencies)\": \"NLD+D\",\n", + "}\n", + "\n", + "# updating the ISO codes\n", + "countryname_to_iso.update(to_update)" + ] + }, + { + "cell_type": "markdown", + "id": "8e8189d5", + "metadata": {}, + "source": [ + "### Detecting cases spanning multiple regions\n", + "\n", + "We do not want to account for cases like \"Europe\" where there are multiple countries / territories / sovereignties associated with it. Therefore, we will assign, to these multiple-region cases, the code `WIDE`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2944f67", + "metadata": {}, + "outputs": [], + "source": [ + "# re-checking for clean-ups; again, this is too long a list to print\n", + "no_isos_2 = [k for k, v in countryname_to_iso.items() if v is None]\n", + "\n", + "# the whole of no_isos_2 is \"WIDE\"\n", + "for i, ctry in enumerate(no_isos_2):\n", + " countryname_to_iso[ctry] = \"WIDE\"\n", + "\n", + "# applying the dictionary to get country codes (ISO)\n", + "un_df[\"ccode\"] = un_df.Location.map(countryname_to_iso)" + ] + }, + { + "cell_type": "markdown", + "id": "9644b04b", + "metadata": {}, + "source": [ + "### Exporting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b78d2c7", + "metadata": {}, + "outputs": [], + "source": [ + "un_df.rename(columns={\"Time\": \"year\"}, inplace=True)\n", + "un_df.set_index([\"ccode\", \"year\"], inplace=True)\n", + "un_df.to_parquet(sset.DIR_YPK_INT / \"un_population.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "5b4a6c04", + "metadata": {}, + "source": [ + "## UN WPP: population-by-age-group" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "22db8719", + "metadata": {}, + "outputs": [], + "source": [ + "# attaching country codes; first import un_pop information\n", + "by_age = pd.read_csv(sset.DIR_UN_WPP_RAW / \"UN_WPP2019_Population_by_Age.csv\")\n", + "\n", + "# attaching the country codes\n", + "un_df_dic = dict(zip(un_df.Location, un_df.index.get_level_values(\"ccode\")))\n", + "by_age[\"ccode\"] = by_age.Location.map(un_df_dic)\n", + "\n", + "# double checking if any are missing country codes\n", + "print(\"The missing-ccode rows are:\", by_age[pd.isnull(by_age.ccode)].shape[0])\n", + "\n", + "# saving the ccodes as indices\n", + "by_age.set_index([\"ccode\"], inplace=True)\n", + "\n", + "# exporting\n", + "by_age.to_parquet(sset.DIR_YPK_INT / \"un_population_by_age.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "2f3eb43d", + "metadata": {}, + "source": [ + "## GEG-15" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e18b799", + "metadata": {}, + "outputs": [], + "source": [ + "# cluster setup\n", + "N_CLUSTER = 20\n", + "cluster = gateway.new_cluster(worker_image=image_name, profile=\"micro\")\n", + "client = cluster.get_client()\n", + "cluster.scale(N_CLUSTER)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2b94412", + "metadata": {}, + "outputs": [], + "source": [ + "@delayed\n", + "def clean_chunk(start, num, shp_path):\n", + " with fiona.open(shp_path, \"r\") as shp:\n", + " chunk = shp[start : (start + num)]\n", + " properties = pd.DataFrame((map(itemgetter(\"properties\"), chunk)))\n", + " geometries = list(map(itemgetter(\"geometry\"), chunk))\n", + " coordinates = pd.DataFrame(\n", + " map(itemgetter(\"coordinates\"), geometries), columns=[\"lon\", \"lat\"]\n", + " )\n", + " df = coordinates.merge(properties, left_index=True, right_index=True)\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b81ef7a2", + "metadata": {}, + "outputs": [], + "source": [ + "DIR_GAR = sset.DIR_GEG15_RAW / \"gar-exp\"\n", + "with fiona.open(DIR_GAR / \"gar_exp.shp\") as shp:\n", + " num_geoms = len(shp)\n", + "\n", + "data_chunked = []\n", + "for ii in range(0, num_geoms, 1000):\n", + " data_chunked.append(clean_chunk(ii, 1000, str(DIR_GAR / \"gar_exp.shp\")))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa4c6a58", + "metadata": {}, + "outputs": [], + "source": [ + "df = ddf.from_delayed(data_chunked)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fe52819", + "metadata": {}, + "outputs": [], + "source": [ + "df = df.repartition(npartitions=16).persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04cbccaf", + "metadata": {}, + "outputs": [], + "source": [ + "sset.DIR_GEG15_INT.mkdir(parents=True, exist_ok=True)\n", + "df.to_parquet(sset.DIR_GEG15_INT / \"gar_exp.parquet\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b56024a", + "metadata": {}, + "outputs": [], + "source": [ + "cluster.scale(0)\n", + "client.close()\n", + "cluster.close()\n", + "cluster.shutdown()" + ] + }, + { + "cell_type": "markdown", + "id": "d8d10ce3-91a6-45d6-89b0-7b13985f200d", + "metadata": {}, + "source": [ + "## Unzip and process Landscan" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e1a3d46-ca5a-4ddc-9545-66420177cf53", + "metadata": {}, + "outputs": [], + "source": [ + "spatial.process_landscan(\n", + " landscan_zip=sset.DIR_LANDSCAN_RAW / f\"{sset.LANDSCAN_VERS}.zip\",\n", + " dir_landscan_raw=sset.DIR_LANDSCAN_RAW / sset.LANDSCAN_VERS,\n", + " dir_landscan_int=sset.DIR_LANDSCAN_INT,\n", + " landscan_year=sset.LANDSCAN_YEAR,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "32e2ac64", + "metadata": {}, + "source": [ + "## CIA World Factbook: gathering GDP PPP terms\n", + "\n", + "The information gathered through sources such as PWT, World Bank WDI, and OECD Regional data often lack GDP information about many of the smaller or disputed countries and territories. In order to account for these countries, we incorporate data from CIA World Factbook dataset which has not much year-to-year information but has more countries covered.\n", + "\n", + "### Unzipping and organizing the files\n", + "\n", + "Note that the cell directly below needs to be run **only once** since it is basically unzipping the `.7z` zip file and may take a long time to repeat over again." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c92fa2c", + "metadata": {}, + "outputs": [], + "source": [ + "# unzipping: this may take a long time\n", + "CIA_DIR, zip_file_name = sset.DIR_YPK_RAW, \"weekly_json.7z\"\n", + "shutil.register_unpack_format(\"7zip\", [\".7z\"], unpack_7zarchive)\n", + "shutil.unpack_archive(CIA_DIR / zip_file_name, CIA_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20797d4d", + "metadata": {}, + "outputs": [], + "source": [ + "# ordering them by time (Earlier entries first)\n", + "CIA_DIR_week = sset.DIR_YPK_RAW / \"weekly_json\"\n", + "file_lst = np.sort(list(CIA_DIR_week.glob(\"*\")))" + ] + }, + { + "cell_type": "markdown", + "id": "2df988e2", + "metadata": {}, + "source": [ + "### Fetch necessary information from the individual `.json` files" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4132539f", + "metadata": {}, + "outputs": [], + "source": [ + "def file_gdp_fetcher(filename):\n", + " \"\"\"From weekly-scraped CIA World Factbook data (in json format), gather relevant GDP\n", + " information and save as a dictionary.\n", + "\n", + " Parameters\n", + " ----------\n", + " filename : Path-like or str\n", + " individual weekly-scraped CIA World Factbook data file path\n", + "\n", + " overall_dict : dict\n", + " information (in dictionary format) containing the countries' GDP information\n", + " (in purchasing power parity) and for which year(s) those information is provided\n", + "\n", + " \"\"\"\n", + "\n", + " with open(filename) as fp:\n", + " data = json.load(fp)\n", + " ctries = list(data[\"countries\"].keys())\n", + " ctries.sort()\n", + "\n", + " note_phrase_1 = \"data are in \"\n", + " note_phrase_2 = \" dollars\"\n", + " note_phrase_3 = \" us dollars\"\n", + "\n", + " overall_dict = dict([])\n", + " for c in ctries:\n", + "\n", + " try:\n", + " info = data[\"countries\"][c][\"data\"][\"economy\"][\"gdp\"]\n", + " info = info[\"purchasing_power_parity\"]\n", + " note = info.get(\"note\")\n", + "\n", + " base_yr = None\n", + " if note is not None:\n", + " note = note.lower()\n", + " if (note_phrase_1 in note) and (note_phrase_3 in note):\n", + " note_ = note.split(note_phrase_1)[1]\n", + " note_ = note_.split(note_phrase_3)[0]\n", + " base_yr = int(note_[0:4])\n", + " elif (note_phrase_1 in note) and (note_phrase_2 in note):\n", + " note_ = note.split(note_phrase_1)[1]\n", + " note_ = note_.split(note_phrase_2)[0]\n", + " base_yr = int(note_[0:4])\n", + " info_values = info.get(\"annual_values\")\n", + " if (info_values is not None) and (type(info_values) in [tuple, list]):\n", + " keys = []\n", + " values = []\n", + " for i in info_values:\n", + " keys.append(int(i[\"date\"]))\n", + " values.append((i[\"value\"], int(i[\"date\"])))\n", + " if base_yr is not None:\n", + " values = [(x[0], base_yr) for x in values]\n", + " yr_dict = dict(zip(keys, values))\n", + " overall_dict[c] = yr_dict\n", + "\n", + " except KeyError:\n", + " continue\n", + "\n", + " return overall_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e8e681f", + "metadata": {}, + "outputs": [], + "source": [ + "# individual results of the file_gdp_fetcher function stored in a list\n", + "lst_results = []\n", + "for f in tqdm(file_lst):\n", + " lst_results.append(file_gdp_fetcher(f))" + ] + }, + { + "cell_type": "markdown", + "id": "c5d2d1e9", + "metadata": {}, + "source": [ + "### Updating the individual dictionaries with the most recent information" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9248d602", + "metadata": {}, + "outputs": [], + "source": [ + "def update_one_with_two(dict1, dict2):\n", + " \"\"\"For simple updating of dictionaries, from `dict2` onto `dict1` in order to make\n", + " sure that all relevant CIA World Factbook data are gathered\n", + "\n", + " Parameters\n", + " ----------\n", + " dict1 : dict\n", + " dictionary to implement the updates onto\n", + " dict2 : dict\n", + " dictionary to gather new information from\n", + "\n", + " Returns\n", + " -------\n", + " dict_ : dict\n", + " updated dictionary containing the information of both dictionaries\n", + "\n", + " \"\"\"\n", + "\n", + " dict_ = dict(dict1)\n", + " lst1 = list(dict1.keys())\n", + "\n", + " for key in dict2.keys():\n", + " if key not in lst1:\n", + " dict_[key] = dict2[key]\n", + " continue\n", + "\n", + " subdict = dict2[key]\n", + " subkeys = list(subdict.keys())\n", + " for subkey in subkeys:\n", + " dict_[key][subkey] = subdict[subkey]\n", + "\n", + " return dict_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c6aa475", + "metadata": {}, + "outputs": [], + "source": [ + "i = 0\n", + "for res in tqdm(lst_results[1:]):\n", + " if i == 0:\n", + " midres = update_one_with_two(lst_results[0], res)\n", + " else:\n", + " midres = update_one_with_two(midres, res)\n", + " i += 1" + ] + }, + { + "cell_type": "markdown", + "id": "fe86819a", + "metadata": {}, + "source": [ + "### Saving into a long-panel format dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23ddf2f1", + "metadata": {}, + "outputs": [], + "source": [ + "ctry_dfs = []\n", + "for i in midres.keys():\n", + " info = midres[i]\n", + " i_k = list(info.keys())\n", + " i_v = [info[i_k_] for i_k_ in i_k]\n", + " ctry_info = [[i, i_k[l]] + list(i_v[l]) for l in range(len(i_k))]\n", + " ctry_df = pd.DataFrame(ctry_info, columns=[\"country\", \"year\", \"gdp\", \"ppp_year\"])\n", + " ctry_dfs.append(ctry_df)\n", + "ctry_agg_df = pd.concat(ctry_dfs, axis=0)\n", + "ctry_agg_df[\"country\"] = [x.replace(\"_\", \" \") for x in ctry_agg_df[\"country\"]]\n", + "ctry_agg_df.set_index([\"country\", \"year\"], inplace=True)\n", + "ctry_agg_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "dabdcdca", + "metadata": {}, + "source": [ + "### Assigning countrycodes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56b9a0fb", + "metadata": {}, + "outputs": [], + "source": [ + "# let's use the UN populations data, since it should have the most countries\n", + "# to match names with values\n", + "un_loc = sset.DIR_YPK_INT\n", + "unpop = pd.read_parquet(un_loc / \"un_population.parquet\").reset_index()\n", + "\n", + "unpop[\"Location_lower\"] = [x.lower() for x in unpop.Location]\n", + "initial_cleanup = dict(zip(unpop.Location_lower, unpop.ccode))\n", + "\n", + "## attaching the cleaned countrycodes\n", + "initial_df = [list(initial_cleanup.keys()), list(initial_cleanup.values())]\n", + "initial_df = pd.DataFrame(\n", + " np.array(initial_df).T, columns=[\"country\", \"ccode\"]\n", + ").set_index([\"country\"])\n", + "ctry_agg_df = ctry_agg_df.merge(\n", + " initial_df, left_index=True, right_index=True, how=\"left\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c2eeaea", + "metadata": {}, + "outputs": [], + "source": [ + "## checking which didn't get country codes\n", + "cia_ccodes_only = ctry_agg_df.reset_index()[[\"country\", \"ccode\"]].drop_duplicates()\n", + "unknown_case = []\n", + "for i, case in enumerate(cia_ccodes_only[\"ccode\"]):\n", + " if pd.isnull(case):\n", + " unknown_case.append(cia_ccodes_only[\"country\"].values[i])\n", + "unknown_case = np.sort(np.unique(unknown_case))\n", + "print(unknown_case)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7ab6757", + "metadata": {}, + "outputs": [], + "source": [ + "# manual cleanup\n", + "unknown_case_ccodes = [\"BHS\", \"BOL\", \"BRN\", \"MMR\", \"CPV\", \"COD\", \"COG\", \"CIV\", \"CUW\"]\n", + "unknown_case_ccodes += [\"CZE\", \"TLS\", \"-\", \"FLK\", \"GMB\", \"-\", \"GGY\", \"GNB\", \"HKG\"]\n", + "unknown_case_ccodes += [\"IRN\", \"JEY\", \"PRK\", \"KOR\", \"KO-\", \"LAO\", \"MAC\", \"MKD\", \"FSM\"]\n", + "unknown_case_ccodes += [\"MDA\", \"-\", \"RUS\", \"SHN\", \"MAF\", \"SXM\", \"SWZ\", \"SYR\", \"TWN\"]\n", + "unknown_case_ccodes += [\"TZA\", \"TLS\", \"USA\", \"VEN\", \"VNM\", \"VIR\", \"WLF\", \"-\"]\n", + "\n", + "# double-checking the names' lengths\n", + "print(len(unknown_case) == len(unknown_case_ccodes))\n", + "\n", + "# getting a dataframe\n", + "update_df = pd.DataFrame(data={\"country\": unknown_case, \"ccode2\": unknown_case_ccodes})\n", + "update_df.set_index([\"country\"], inplace=True)\n", + "ctry_agg_df = ctry_agg_df.merge(\n", + " update_df, left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "ctry_agg_df.loc[pd.isnull(ctry_agg_df.ccode), \"ccode\"] = ctry_agg_df.loc[\n", + " pd.isnull(ctry_agg_df.ccode), \"ccode2\"\n", + "].values" + ] + }, + { + "cell_type": "markdown", + "id": "6631b61c", + "metadata": {}, + "source": [ + "### Fetching the PPP conversion rates (to constant 2017 PPP USD), and applying the conversion rates\n", + "\n", + "Also, turn it into millions of USD (currently in ones of USD)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a08c1ebf", + "metadata": {}, + "outputs": [], + "source": [ + "ppp_to_17 = ypk_fn.ppp_conversion_specific_year(2017, to=True, extrap_sim=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf2edb1f", + "metadata": {}, + "outputs": [], + "source": [ + "# neutral assumption when conversion rates are missing\n", + "ctry_agg_df = (\n", + " ctry_agg_df.reset_index()\n", + " .set_index([\"ccode\", \"year\"])\n", + " .drop([\"ccode2\"], axis=1)\n", + " .merge(ppp_to_17, left_index=True, right_index=True, how=\"left\")\n", + ")\n", + "ctry_agg_df.loc[pd.isnull(ctry_agg_df.conv), \"conv\"] = 1\n", + "\n", + "# first, divide by 1000000\n", + "ctry_agg_df[\"gdp\"] = ctry_agg_df[\"gdp\"] / 1000000\n", + "\n", + "# applying the conversion by multiplying\n", + "ctry_agg_df[\"gdp_ppp2017_currUSD\"] = ctry_agg_df[\"gdp\"] * ctry_agg_df[\"conv\"]" + ] + }, + { + "cell_type": "markdown", + "id": "6ba4de36", + "metadata": {}, + "source": [ + "### Attaching the US deflators and generating constant 2017 PPP USD values\n", + "\n", + "Note that while they are now in PPP of 2017, they are yet to be turned into constant 2017 PPP (since they are in current USD, for many). Therefore, we will need to fetch the US deflators (using `pl_gdpo` from PWT)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79e9dc22", + "metadata": {}, + "outputs": [], + "source": [ + "pwt = pd.read_excel(sset.PATH_PWT_RAW).rename(columns={\"countrycode\": \"ccode\"})\n", + "pwt.set_index([\"ccode\", \"year\"], inplace=True)\n", + "\n", + "us_defla = (\n", + " pwt.loc[\"USA\", [\"pl_gdpo\"]]\n", + " .reset_index()\n", + " .rename(columns={\"pl_gdpo\": \"pl_usa\", \"year\": \"ppp_year\"})\n", + ")\n", + "ctry_agg_df = (\n", + " ctry_agg_df.reset_index()\n", + " .merge(us_defla, on=[\"ppp_year\"], how=\"left\")\n", + " .set_index([\"ccode\", \"year\"])\n", + ")\n", + "\n", + "# generating constant 2017 ppp\n", + "ctry_agg_df[\"gdp_constant2017ppp\"] = (\n", + " ctry_agg_df[\"gdp_ppp2017_currUSD\"] / ctry_agg_df[\"pl_usa\"]\n", + ")\n", + "\n", + "ctry_agg_df_reorg = ctry_agg_df[[\"gdp_constant2017ppp\", \"country\"]].sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "81fed947", + "metadata": {}, + "source": [ + "### Checking for redundancies in country (ISO) codes\n", + "\n", + "Except when there aren't any country-codes attached, these redundancies are occurring because there have been changes to the countries' names over the years or there are multiple names for one country. We will use the following rule to remove some of the overlaps:\n", + "- SHN: Take only `saint helena ascension and tristan da cunha`\n", + "- CZE: For 2006-2012, use `czech republic` information; for 2013 and onwards, use `czechia` information.\n", + "- MKD: For 2006-2014, use `macedonia` information; for 2015 and onwards, use `north macedonia` information.\n", + "- SWZ: For 2006-2014, use `swaziland` information; for 2015 and onwards, use `eswatini` information.\n", + "- CPV: For 2006-2011, use `cape verde` information; for 2012 and onwards, use `cabo verde` information.\n", + "- TLS: Take only `timor leste`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37ee6478", + "metadata": {}, + "outputs": [], + "source": [ + "reorg_ccodes = ctry_agg_df_reorg.reset_index()[[\"ccode\", \"country\"]].drop_duplicates()\n", + "reorg_ccodes.set_index([\"ccode\"], inplace=True)\n", + "for i, ccode in enumerate(np.unique(reorg_ccodes.index.values)):\n", + " countrycases = reorg_ccodes.loc[ccode, \"country\"]\n", + " if (ccode != \"-\") and (type(countrycases) != str):\n", + " print(ccode, countrycases.values)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab54b382", + "metadata": {}, + "outputs": [], + "source": [ + "redundant_ones = [\"SHN\", \"CZE\", \"MKD\", \"SWZ\", \"CPV\", \"TLS\"]\n", + "ctry_agg_df_redun = ctry_agg_df_reorg.reset_index()\n", + "\n", + "ctry_shn = ctry_agg_df_redun.loc[\n", + " ctry_agg_df_redun.country == \"saint helena ascension and tristan da cunha\"\n", + "].set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_cze = ctry_agg_df_redun.loc[\n", + " ((ctry_agg_df_redun.country == \"czechia\") & (ctry_agg_df_redun.year >= 2013))\n", + " | (\n", + " (ctry_agg_df_redun.country == \"czech republic\")\n", + " & (ctry_agg_df_redun.year <= 2012)\n", + " )\n", + "].set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_mkd = ctry_agg_df_redun[\n", + " ((ctry_agg_df_redun.country == \"macedonia\") & (ctry_agg_df_redun.year <= 2014))\n", + " | (\n", + " (ctry_agg_df_redun.country == \"north macedonia\")\n", + " & (ctry_agg_df_redun.year >= 2015)\n", + " )\n", + "].set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_swz = ctry_agg_df_redun[\n", + " ((ctry_agg_df_redun.country == \"swaziland\") & (ctry_agg_df_redun.year <= 2014))\n", + " | ((ctry_agg_df_redun.country == \"eswatini\") & (ctry_agg_df_redun.year >= 2015))\n", + "].set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_cpv = ctry_agg_df_redun[\n", + " ((ctry_agg_df_redun.country == \"cape verde\") & (ctry_agg_df_redun.year <= 2011))\n", + " | ((ctry_agg_df_redun.country == \"cabo verde\") & (ctry_agg_df_redun.year >= 2012))\n", + "].set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_tls = ctry_agg_df_redun.loc[\n", + " ctry_agg_df_redun.country == \"timor leste\", :\n", + "].set_index([\"ccode\", \"year\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7ca3e2f", + "metadata": {}, + "outputs": [], + "source": [ + "ctry_agg_df_final = ctry_agg_df_reorg[\n", + " ~ctry_agg_df_reorg.index.get_level_values(\"ccode\").isin(\n", + " [\"-\", \"WIDE\"] + redundant_ones\n", + " )\n", + "].copy()\n", + "\n", + "ctry_agg_df_final = pd.concat(\n", + " [ctry_agg_df_final, ctry_shn, ctry_cze, ctry_mkd, ctry_swz, ctry_cpv, ctry_tls],\n", + " axis=0,\n", + ").sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "633df76b", + "metadata": {}, + "source": [ + "### Adding those that are not in the files\n", + "\n", + "**Tokelau `TKL`**\n", + "\n", + "According to Tokelau government (link [here](https://www.tokelau.org.nz/Bulletin/April+2017/GDP+first.html)), its PPP USD was 10 million (in 2017). So we will fill this in." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1c760d2", + "metadata": {}, + "outputs": [], + "source": [ + "tkl = pd.DataFrame(\n", + " [\n", + " [\"TKL\", 2017, 10, \"tokelau\"],\n", + " ],\n", + " columns=[\"ccode\", \"year\", \"gdp_constant2017ppp\", \"country\"],\n", + ").set_index([\"ccode\", \"year\"])\n", + "ctry_agg_df_final = pd.concat([ctry_agg_df_final, tkl], axis=0)" + ] + }, + { + "cell_type": "markdown", + "id": "e7b2ec2f", + "metadata": {}, + "source": [ + "**Saint Helena (`SHN`)**\n", + "\n", + "I update the latest values using the CIA World Factbook's January 7, 2021 vintage (link [here](https://www.cia.gov/the-world-factbook/)). For `SHN`, it is said that the 2009 value of GDP (in constant 2009 PPP USD) is 31.1 million, but we do not have the explicit PPP conversion for `SHN`. Since `SHN` is a British territory, `GBR` PPP rates are used." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab2c1cbd", + "metadata": {}, + "outputs": [], + "source": [ + "shn_rate = ppp_to_17.loc[(\"SHN\", 2009), \"conv\"]\n", + "us_def09 = pwt.loc[(\"USA\", 2009), \"pl_gdpo\"]\n", + "shn = pd.DataFrame(\n", + " [\n", + " [\"SHN\", 2009, shn_rate / us_def09 * 31.1, \"saint helena\"],\n", + " ],\n", + " columns=[\"ccode\", \"year\", \"gdp_constant2017ppp\", \"country\"],\n", + ").set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_agg_df_final = pd.concat([ctry_agg_df_final, shn], axis=0)" + ] + }, + { + "cell_type": "markdown", + "id": "207fa442", + "metadata": {}, + "source": [ + "**Vatican (`VAT`)**\n", + "\n", + "While not in the latest CIA World Factbook, the 2000 version has some information about Vatican city (archived [here](https://www.encyclopedia.com/places/spain-portugal-italy-greece-and-balkans/italian-political-geography/vatican-city)) which we will be able to use. It says that the 1999 estimate of the Vatican GDP (assuming it's constant 1999 PPP) was 21 million USD. Let us use the PPP conversion rates of Italy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "554deb3e", + "metadata": {}, + "outputs": [], + "source": [ + "vat_rate = ppp_to_17.loc[(\"VAT\", 1999), \"conv\"]\n", + "us_def99 = pwt.loc[(\"USA\", 1999), \"pl_gdpo\"]\n", + "vat = pd.DataFrame(\n", + " [\n", + " [\"VAT\", 1999, vat_rate / us_def99 * 21, \"vatican\"],\n", + " ],\n", + " columns=[\"ccode\", \"year\", \"gdp_constant2017ppp\", \"country\"],\n", + ").set_index([\"ccode\", \"year\"])\n", + "\n", + "ctry_agg_df_final = pd.concat([ctry_agg_df_final, vat], axis=0)" + ] + }, + { + "cell_type": "markdown", + "id": "483b6c8c", + "metadata": {}, + "source": [ + "### Exporting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2aad9b65", + "metadata": {}, + "outputs": [], + "source": [ + "ctry_agg_df_final.sort_index(inplace=True)\n", + "ctry_agg_df_final.rename(columns={\"gdp_constant2017ppp\": \"cia_rgdpna\"}, inplace=True)\n", + "ctry_agg_df_final.to_parquet(\n", + " sset.DIR_YPK_INT / \"cia_wf_gdp_constant_2017_ppp_usd_ver.parquet\"\n", + ")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk2_reorg_and_impute_ypk.ipynb b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk2_reorg_and_impute_ypk.ipynb new file mode 100644 index 0000000..c281a92 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk2_reorg_and_impute_ypk.ipynb @@ -0,0 +1,3790 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2bbfaf73-96c1-46d7-bafe-92c30ced3b76", + "metadata": {}, + "source": [ + "## Reorganizing raw data (GDP, GDPpc, and population) in long-panel format, converting to current and constant PPP terms, taking care of missing data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1c69bfd-3b4c-4bb4-8d00-6f8e1bdf7122", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85f3f8c1-947b-4170-acc0-366f75565a86", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from tqdm.auto import tqdm\n", + "\n", + "from sliiders import country_level_ypk as ypk_fn\n", + "from sliiders import settings as sset" + ] + }, + { + "cell_type": "markdown", + "id": "7444df03-7e87-43d1-bf13-bf7f7cd9885e", + "metadata": {}, + "source": [ + "## Importing all raw data, and creating a merged, long-panel version\n", + "\n", + "### PWT" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "996df854-1843-45fb-ad57-74173b99fcf5", + "metadata": {}, + "outputs": [], + "source": [ + "pwt100 = pd.read_excel(sset.PATH_PWT_RAW)\n", + "pwt100.rename(columns={\"countrycode\": \"ccode\"}, inplace=True)\n", + "pwt_gdp_pop = [\"ccode\", \"year\", \"pop\", \"rgdpo\", \"rgdpna\", \"cgdpo\"]\n", + "gdp_pop_df = pwt100[pwt_gdp_pop].copy().set_index([\"ccode\", \"year\"])" + ] + }, + { + "cell_type": "markdown", + "id": "f7c1b3b0-fe61-4825-85db-596c639eff72", + "metadata": {}, + "source": [ + "### WB WDI" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e45a649d-dc43-41fc-a96d-9dc1bd1adda7", + "metadata": {}, + "outputs": [], + "source": [ + "# WB WDI\n", + "wdi_rename_dict = {\n", + " \"SP.POP.TOTL\": \"wb_pop\",\n", + " \"NY.GDP.MKTP.PP.KD\": \"wb_rgdpna\",\n", + " \"NY.GDP.PCAP.PP.KD\": \"wb_rgdpna_pc\",\n", + " \"NY.GDP.MKTP.KD\": \"wb_gdp_nom\",\n", + " \"NY.GDP.PCAP.KD\": \"wb_gdp_nom_pc\",\n", + "}\n", + "wb_wdi = pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_pop_iy_gdp.parquet\").rename(\n", + " columns=wdi_rename_dict\n", + ")\n", + "wb_wdi = wb_wdi.loc[\n", + " wb_wdi.index.get_level_values(\"ccode\").isin(sset.ALL_ISOS_EXTENDED), :\n", + "].reset_index()\n", + "\n", + "# Unifying the country code conventions for Kosovo and Channel Islands\n", + "wb_wdi.loc[wb_wdi.ccode == \"XKX\", \"ccode\"] = \"KO-\"\n", + "wb_wdi.loc[wb_wdi.ccode == \"CHI\", \"ccode\"] = \"GGY+JEY\"\n", + "wb_wdi.set_index([\"ccode\", \"year\"], inplace=True)\n", + "\n", + "# re-scaling; currently in ones, but to have them in PWT scales\n", + "wb_wdi[[\"wb_rgdpna\", \"wb_gdp_nom\", \"wb_pop\"]] /= 1000000\n", + "\n", + "# merging\n", + "gdp_pop_df = gdp_pop_df.join(wb_wdi, how=\"outer\")" + ] + }, + { + "cell_type": "markdown", + "id": "b8696d23-122e-4a1a-bfa5-24485a623f20", + "metadata": {}, + "source": [ + "### IMF" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cf1d2eb-3fb8-4057-b1ac-7e7e56cd751c", + "metadata": {}, + "outputs": [], + "source": [ + "# the code below prevents the \"ArrowInvalid\" error\n", + "imf = pd.read_excel(sset.PATH_IMF_WEO_RAW, na_values=[\"n/a\", \"--\"]).rename(\n", + " columns={\"ISO\": \"ccode\", \"Subject Descriptor\": \"subject\"}\n", + ")\n", + "imf = imf.loc[imf.ccode.isin(sset.ALL_ISOS_EXTENDED), :]\n", + "\n", + "# renaming the subjects\n", + "imf_rename = {\n", + " \"Gross domestic product per capita, constant prices\": \"imf_rgdpna_pc\",\n", + " \"Gross domestic product per capita, current prices\": \"imf_gdppc_nom\",\n", + " \"Gross domestic product, current prices\": \"imf_gdp_nom\",\n", + " \"Population\": \"imf_pop\",\n", + "}\n", + "for key, nam in imf_rename.items():\n", + " imf.loc[imf.subject == key, \"subject\"] = nam\n", + "imf = imf.loc[imf.subject.isin(list(imf_rename.values())), :].copy()\n", + "v_names = dict(zip(list(range(1980, 2021)), [\"v_\" + str(x) for x in range(1980, 2021)]))\n", + "imf.rename(columns=v_names, inplace=True)\n", + "\n", + "# organizing this in vertical format\n", + "first = 0\n", + "for nam in imf_rename.values():\n", + " imf_sub = imf.loc[imf.subject == nam, [\"ccode\"] + list(v_names.values())].set_index(\n", + " [\"ccode\"]\n", + " )\n", + " imf_sub = ypk_fn.organize_hor_to_ver(\n", + " imf_sub, \"ccode\", None, nam, \"v_\", range(1980, 2021)\n", + " )\n", + " imf_sub[nam] = imf_sub[nam].astype(\"float64\")\n", + " if first == 0:\n", + " first += 1\n", + " imf_reorg = imf_sub.copy()\n", + " else:\n", + " imf_reorg = imf_reorg.merge(\n", + " imf_sub, how=\"outer\", left_index=True, right_index=True\n", + " )\n", + "\n", + "gdp_pop_df = gdp_pop_df.merge(imf_reorg, how=\"outer\", left_index=True, right_index=True)" + ] + }, + { + "cell_type": "markdown", + "id": "a5b448af-0fbc-40ef-a3e6-191c278ca955", + "metadata": {}, + "source": [ + "### Maddison Project Database (MPD)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "507434c7-071f-40a3-b205-33668913aabd", + "metadata": {}, + "outputs": [], + "source": [ + "# MPD\n", + "mpd = pd.read_parquet(sset.DIR_YPK_INT / \"maddison_project.parquet\")\n", + "mpd = mpd.loc[\n", + " mpd.index.get_level_values(\"ccode\").isin(sset.ALL_ISOS_EXTENDED), [\"gdppc\", \"pop\"]\n", + "].rename(columns=dict(zip([\"gdppc\", \"pop\"], [\"mpd_rgdpna_pc\", \"mpd_pop\"])))\n", + "\n", + "# separating North Korea (PRK) and non-PRK\n", + "mpd_no_prk = mpd.loc[mpd.index.get_level_values(\"ccode\") != \"PRK\", :].sort_index()\n", + "mpd_prk = mpd.loc[[\"PRK\"], :].sort_index()\n", + "\n", + "# some minor interpolation for the case of North Korea\n", + "mpd_prk_interped = pd.DataFrame(data={\"ccode\": [\"PRK\"] * 71, \"year\": range(1950, 2021)})\n", + "mpd_prk_interped.set_index([\"ccode\", \"year\"], inplace=True)\n", + "for i in [\"mpd_rgdpna_pc\", \"mpd_pop\"]:\n", + " i_yrs = (\n", + " mpd_prk.loc[~pd.isnull(mpd_prk[i]), :].index.get_level_values(\"year\").unique()\n", + " )\n", + " vals = mpd_prk.loc[(\"PRK\", i_yrs), i].values\n", + " interp_yrs = list(range(1950, i_yrs.max() + 1))\n", + " vals_interp = np.exp(np.interp(interp_yrs, i_yrs, np.log(vals)))\n", + " mpd_prk_interped[i] = np.nan\n", + " mpd_prk_interped.loc[(\"PRK\", interp_yrs), i] = vals_interp\n", + "\n", + "# merge\n", + "mpd = pd.concat([mpd_no_prk, mpd_prk_interped], axis=0)\n", + "gdp_pop_df = gdp_pop_df.join(mpd, how=\"outer\")" + ] + }, + { + "cell_type": "markdown", + "id": "8a8f4546-cc1a-467a-9cb4-1b50d631785c", + "metadata": {}, + "source": [ + "### UN population data (UN WPP)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a7da224-0438-419c-b6c3-7a5e60a8db5e", + "metadata": {}, + "outputs": [], + "source": [ + "unpop = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"un_population.parquet\",\n", + " filters=[\n", + " (\"Variant\", \"==\", \"Medium\"),\n", + " ],\n", + ")\n", + "unpop = unpop.loc[\n", + " unpop.index.get_level_values(\"ccode\").isin(sset.ALL_ISOS_EXTENDED)\n", + " & (unpop.index.get_level_values(\"year\") <= 2020),\n", + " [\"PopTotal\"],\n", + "].rename(columns={\"PopTotal\": \"un_pop\"})\n", + "\n", + "# re-organizing from thousands to millions\n", + "unpop[\"un_pop\"] /= 1000\n", + "\n", + "# merging\n", + "gdp_pop_df = gdp_pop_df.join(unpop.un_pop, how=\"outer\").sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "d5520b05-0d39-42fc-8f53-6194f7bd317b", + "metadata": {}, + "source": [ + "### OECD regional data\n", + "\n", + "Among the relevant countries and regions we want to observe, only the five French overseas departments (Martinique, Mayotte, Guadeloupe, French Guiana, and La Réunion) are available in OECD regional data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5f03eb9-c89e-4299-8507-90d15851b5b4", + "metadata": {}, + "outputs": [], + "source": [ + "# mapping region names and ISO codes\n", + "fra_regions = [\"Martinique\", \"Mayotte\", \"Guadeloupe\", \"French Guiana\", \"La Réunion\"]\n", + "fra_isos = [\"MTQ\", \"MYT\", \"GLP\", \"GUF\", \"REU\"]\n", + "fra_map = pd.DataFrame(data={\"Region\": fra_regions, \"ccode\": fra_isos})\n", + "\n", + "# reading in the OECD data for population and gdp\n", + "regpop = pd.read_csv(sset.DIR_OECD_REGIONS_RAW / \"REGION_DEMOGR.csv\").rename(\n", + " columns={\"Territory Level and Typology\": \"terrtype\", \"TIME\": \"year\"}\n", + ")\n", + "regpop = (\n", + " regpop.loc[(regpop.terrtype != \"Country\") & ~pd.isnull(regpop.Value), :]\n", + " .merge(fra_map, on=[\"Region\"], how=\"left\")\n", + " .sort_values([\"ccode\", \"year\"])\n", + " .rename(columns={\"Value\": \"oecd_pop\"})\n", + ")\n", + "\n", + "regecon = pd.read_csv(sset.DIR_OECD_REGIONS_RAW / \"REGION_ECONOM.csv\").rename(\n", + " columns={\"Territory Level and Typology\": \"terrtype\", \"TIME\": \"year\"}\n", + ")\n", + "regecon = (\n", + " regecon.loc[(regecon.terrtype != \"Country\") & ~pd.isnull(regecon.Value), :]\n", + " .merge(fra_map, on=[\"Region\"], how=\"left\")\n", + " .sort_values([\"ccode\", \"year\"])\n", + " .rename(columns={\"Value\": \"oecd_rgdpna\"})\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f222495-f877-4c98-b5d8-13da2b9aab93", + "metadata": {}, + "outputs": [], + "source": [ + "# subsetting for the total population information\n", + "fra_pop_detect = regpop.loc[\n", + " ~pd.isnull(regpop.ccode) & (regpop.VAR == \"T\") & (regpop.Gender == \"Total\"), :\n", + "].set_index([\"ccode\", \"year\"])\n", + "fra_pop_detect[\"oecd_pop\"] /= 1000000\n", + "\n", + "# subsetting for the total GDP information\n", + "fra_Y_detect = regecon.loc[\n", + " ~pd.isnull(regecon.ccode) & (regecon.MEAS == \"USD_PPP\") & (regecon.year <= 2020), :\n", + "].set_index([\"ccode\", \"year\"])\n", + "\n", + "# merging with the original dataset\n", + "gdp_pop_df = gdp_pop_df.join(\n", + " [fra_pop_detect.oecd_pop, fra_Y_detect.oecd_rgdpna], how=\"outer\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "41c7aa03-2b63-4e5a-ab00-98ebafaf68b3", + "metadata": {}, + "source": [ + "### CIA World Factbook\n", + "\n", + "CIA information has been pre-cleaned to be in 2017 PPP USD, part of which has used extrapolation for PPP conversion rates." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2442891d-5540-40b4-bf69-2d5ddd8a3c79", + "metadata": {}, + "outputs": [], + "source": [ + "cia = pd.read_parquet(sset.DIR_YPK_INT / \"cia_wf_gdp_constant_2017_ppp_usd_ver.parquet\")\n", + "gdp_pop_df = gdp_pop_df.merge(\n", + " cia[[\"cia_rgdpna\"]], left_index=True, right_index=True, how=\"outer\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cfe7cdaf-068b-462c-9941-4dd265630f25", + "metadata": {}, + "source": [ + "### UN SNA AMA information" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b83a9e04-fe4c-42d5-a8e0-f1d5d348e107", + "metadata": {}, + "outputs": [], + "source": [ + "# matching country/region names and country/region codes\n", + "wb_country_matching = (\n", + " wb_wdi[[\"country\"]].reset_index()[[\"country\", \"ccode\"]].drop_duplicates()\n", + ")\n", + "\n", + "un_country_dict_additional = [\n", + " [\"Anguilla\", \"AIA\"],\n", + " [\"Bolivia (Plurinational State of)\", \"BOL\"],\n", + " [\"China, Hong Kong SAR\", \"HKG\"],\n", + " [\"China, Macao Special Administrative Region\", \"MAC\"],\n", + " [\"China, People's Republic of\", \"CHN\"],\n", + " [\"Congo\", \"COG\"],\n", + " [\"Cook Islands\", \"COK\"],\n", + " [\"Curaçao\", \"CUW\"],\n", + " [\"Czechia\", \"CZE\"],\n", + " [\"Côte d'Ivoire\", \"CIV\"],\n", + " [\"Democratic People's Republic of Korea\", \"PRK\"],\n", + " [\"Democratic Republic of the Congo\", \"COD\"],\n", + " [\"Egypt\", \"EGY\"],\n", + " [\"Gambia\", \"GMB\"],\n", + " [\"Iran, Islamic Republic of\", \"IRN\"],\n", + " [\"Kingdom of Eswatini\", \"SWZ\"],\n", + " [\"Kyrgyzstan\", \"KGZ\"],\n", + " [\"Lao People's Democratic Republic\", \"LAO\"],\n", + " [\"Micronesia (Federated States of)\", \"FSM\"],\n", + " [\"Montserrat\", \"MSR\"],\n", + " [\"Republic of Korea\", \"KOR\"],\n", + " [\"Republic of Moldova\", \"MDA\"],\n", + " [\"Republic of North Macedonia\", \"MKD\"],\n", + " [\"Saint Kitts and Nevis\", \"KNA\"],\n", + " [\"Saint Lucia\", \"LCA\"],\n", + " [\"Saint Vincent and the Grenadines\", \"VCT\"],\n", + " [\"Slovakia\", \"SVK\"],\n", + " [\"State of Palestine\", \"PSE\"],\n", + " [\"Venezuela (Bolivarian Republic of)\", \"VEN\"],\n", + " [\"Viet Nam\", \"VNM\"],\n", + " [\"Yemen\", \"YEM\"],\n", + " [\"United Kingdom of Great Britain and Northern Ireland\", \"GBR\"],\n", + "]\n", + "\n", + "country_matching_additional = pd.concat(\n", + " [\n", + " wb_country_matching,\n", + " pd.DataFrame(un_country_dict_additional, columns=[\"country\", \"ccode\"]),\n", + " ],\n", + " axis=0,\n", + ").reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f695bc5-e894-4241-9dc0-361c0916be78", + "metadata": {}, + "outputs": [], + "source": [ + "UN_NOM_y = pd.read_csv(sset.DIR_UN_AMA_RAW / \"un_snaama_nom_gdppc.csv\").rename(\n", + " columns={\n", + " \"Country/Area\": \"country\",\n", + " \"Year\": \"year\",\n", + " \"GDP, Per Capita GDP - US Dollars\": \"un_nom_gdppc\",\n", + " }\n", + ")\n", + "UN_NOM_y.drop([\"Unit\"], axis=1, inplace=True)\n", + "UN_NOM_y = UN_NOM_y.merge(wb_country_matching, on=[\"country\"], how=\"left\")\n", + "UN_NOM_y = UN_NOM_y.loc[~pd.isnull(UN_NOM_y.ccode), :]\n", + "UN_NOM_y = UN_NOM_y.set_index([\"ccode\", \"year\"]).drop([\"country\"], axis=1).un_nom_gdppc\n", + "gdp_pop_df = gdp_pop_df.join(UN_NOM_y, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "d005a3ed-31cf-48a1-92a8-43cecdb03a16", + "metadata": { + "tags": [] + }, + "source": [ + "### Information from various disaggregated sources, for smaller regions, territories and countries\n", + "\n", + "This includes national account reports and approximations from organizational reports or academic papers.\n", + "\n", + "#### Åland Islands (`ALA`; GDP per capita and population)\n", + "\n", + "- GDP per capita: information available from Statistics and Research Åland (link [here](https://www.asub.ax/en/statistics/national-accounts/gross-domestic-product), see the link \"GDP per capita 1995-2018 in current prices, PPS euro\"). Since this is in PPP Euro (or Finnish Purchasing Power Standard exchange rate), we will use the nominal Euro-to-USD converision to clean this assuming that these are current PPP.\n", + "- Population: information available from Statistics and Research Åland (link [here](https://www.asub.ax/en/statistics/population/size-and-structure-population), see the link \"Åland, the Faroe Islands and Greenland\". This is in ones of people, so we divide by 1 million to keep the population in millions of people." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7359dad2-96f4-4d8a-93f1-38b798b3f7df", + "metadata": {}, + "outputs": [], + "source": [ + "# aland islands information, GDP\n", + "ala_gdp = (\n", + " pd.read_excel(sset.DIR_ALAND_STATISTICS_RAW / \"aland_gdp.xlsx\")\n", + " .rename(columns={\"Unnamed: 0\": \"country\"})\n", + " .set_index([\"country\"])\n", + ")\n", + "ala_years = ala_gdp.columns.values\n", + "ala_95_18_cgdpo_pc = ala_gdp.loc[\"Åland\", :]\n", + "\n", + "# exchange rate; EMU only has down to 1999, so for convenience's sake\n", + "# for 1995-1998, we will use 1999 rates\n", + "wdi_xrate = (\n", + " pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\")\n", + " .loc[(\"EMU\", list(range(1999, ala_years.max() + 1))), \"xrate\"]\n", + " .values\n", + ")\n", + "ala_xrate = np.hstack([[wdi_xrate[0]] * (1999 - ala_years.min()), wdi_xrate])\n", + "ala_95_18_cgdpo_pc = ala_95_18_cgdpo_pc * ala_xrate\n", + "\n", + "# creating the Aland islands column for cgdpo_pc\n", + "ala = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"FIN\", 1950:], \"cgdpo\"].copy() * np.nan)\n", + " .rename(\"ala_cgdpo_pc\")\n", + " .reset_index()\n", + ")\n", + "ala[\"ccode\"] = \"ALA\"\n", + "ala = ala.set_index([\"ccode\", \"year\"]).ala_cgdpo_pc\n", + "ala.loc[\"ALA\", list(ala_years)] = ala_95_18_cgdpo_pc.values\n", + "\n", + "# aland islands information, population\n", + "ala_pop_link = (\n", + " \"https://www.asub.ax/sites/www.asub.ax/files/attachments/page/alv01_aland_faroe\"\n", + " \"_islands_and_greenland_-_an_overview_with_comparable_data.xlsx\"\n", + ")\n", + "ala_pop = pd.read_excel(sset.DIR_ALAND_STATISTICS_RAW / \"aland_pop.xlsx\").rename(\n", + " columns={\"Unnamed: 0\": \"category\"}\n", + ")\n", + "ala_pop_00_20 = ala_pop.iloc[1].values[1:-1]\n", + "ala_pop = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"FIN\", 1950:], \"pop\"].copy() * np.nan)\n", + " .rename(\"ala_pop\")\n", + " .reset_index()\n", + ")\n", + "ala_pop[\"ccode\"] = \"ALA\"\n", + "ala_pop = ala_pop.set_index([\"ccode\", \"year\"]).ala_pop\n", + "ala_pop.loc[\"ALA\", list(range(2000, 2021))] = ala_pop_00_20 / 1000000\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(ala, how=\"outer\")\n", + "gdp_pop_df = gdp_pop_df.join(ala_pop, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "f7470549-9075-4b17-a110-789c60f88336", + "metadata": { + "tags": [] + }, + "source": [ + "#### Norfolk Island (`NFK`)\n", + "\n", + "- GDP: GDPpc as a percentage of the Australian level for the years 1951-52 are shown in [Treadgold (Asia Pacific Viewpoint, 1999)](https://doi.org/10.1111/1467-8373.00095) and similar percentage for 1995-96 are shown in [Treadgold (Pacific Economic Bulletin, 1998)](https://openresearch-repository.anu.edu.au/handle/1885/157535).\n", + "- Population: The Australian Census has information for Norfolk in the years 2001, 2011, and 2016: www.infrastructure.gov.au/territories-regions-cities/territories/norfolk-island" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a142f948-0112-411a-8a0f-fb155117734e", + "metadata": {}, + "outputs": [], + "source": [ + "# population\n", + "nfk = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"AUS\", 1950:], \"un_pop\"].copy() * np.nan)\n", + " .rename(\"aus_census_pop\")\n", + " .reset_index()\n", + ")\n", + "nfk[\"ccode\"] = \"NFK\"\n", + "nfk = nfk.set_index([\"ccode\", \"year\"]).aus_census_pop\n", + "nfk.loc[\"NFK\", [2001, 2011, 2016]] = np.array([2601, 1796, 1748]) / 1000000\n", + "gdp_pop_df = gdp_pop_df.join(nfk, how=\"outer\")\n", + "\n", + "# GDP\n", + "nfk_gdp = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"AUS\", 1950:], \"rgdpna\"].copy() * np.nan)\n", + " .rename(\"treadgold_rgdpna_pc\")\n", + " .reset_index()\n", + ")\n", + "nfk_gdp[\"ccode\"] = \"NFK\"\n", + "nfk_cgdpo = nfk_gdp.copy().rename(columns={\"treadgold_rgdpna_pc\": \"treadgold_cgdpo_pc\"})\n", + "\n", + "# getting the Australian GDPpc\n", + "nfk_yrs = [1951, 1952, 1995, 1996]\n", + "nfk_ratios = np.array([0.39, 0.39, 1.12, 1.12])\n", + "nfk_rgdpna_pc = (\n", + " gdp_pop_df.loc[pd.IndexSlice[\"AUS\", nfk_yrs], \"rgdpna\"].values\n", + " / gdp_pop_df.loc[pd.IndexSlice[\"AUS\", nfk_yrs], \"pop\"].values\n", + " * nfk_ratios\n", + ")\n", + "nfk_gdp = nfk_gdp.set_index([\"ccode\", \"year\"]).treadgold_rgdpna_pc\n", + "nfk_gdp.loc[\"NFK\", nfk_yrs] = nfk_rgdpna_pc\n", + "gdp_pop_df = gdp_pop_df.join(nfk_gdp, how=\"outer\")\n", + "\n", + "nfk_cgdpo_pc = (\n", + " gdp_pop_df.loc[pd.IndexSlice[\"AUS\", nfk_yrs], \"cgdpo\"].values\n", + " / gdp_pop_df.loc[pd.IndexSlice[\"AUS\", nfk_yrs], \"pop\"].values\n", + " * nfk_ratios\n", + ")\n", + "nfk_cgdpo = nfk_cgdpo.set_index([\"ccode\", \"year\"]).treadgold_cgdpo_pc\n", + "nfk_cgdpo.loc[\"NFK\", nfk_yrs] = nfk_cgdpo_pc\n", + "gdp_pop_df = gdp_pop_df.join(nfk_cgdpo, how=\"outer\")" + ] + }, + { + "cell_type": "markdown", + "id": "d988bec2-a804-4cf8-a84c-8c53df4c39cd", + "metadata": { + "tags": [] + }, + "source": [ + "#### Cocos (Keeling) Islands (`CCK`)\n", + "\n", + "- GDP: Information available from the House of Representative Committees of Parliament of Australia (link [here](https://www.aph.gov.au/parliamentary_business/committees/House_of_Representatives_Committees?url=ncet/economicenvironment/report/index.htm)). Please see **Chapter 3 The economic environment of the Indian Ocean Territories** page 23; the units are in Australian dollars (nominal), and the value corresponds to 2010's GDP.\n", + "- Population: from the Australian Bureau of Statistics (ABS); information for [2016](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2016/quickstat/90102), [2011](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2011/quickstat/90102?opendocument), [2006](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2006/quickstat/910053009?opendocument), and [2001](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2001/quickstat/910053009?opendocument) available from the ABS Quickstat pages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3eb5aa9-cf97-4dbe-9fec-eb4760f74f32", + "metadata": {}, + "outputs": [], + "source": [ + "# GDP\n", + "cck_gdp = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"AUS\", 1950:], \"rgdpna\"].copy() * np.nan)\n", + " .rename(\"aus_census_nom_gdp\")\n", + " .reset_index()\n", + ")\n", + "cck_gdp[\"ccode\"] = \"CCK\"\n", + "cck_gdp = cck_gdp.set_index([\"ccode\", \"year\"]).aus_census_nom_gdp\n", + "cck_gdp.loc[\"CCK\", [2010]] = (15000000 / 1000000) * pd.read_parquet(\n", + " sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\"\n", + ").loc[(\"AUS\", [2010]), \"xrate\"].values\n", + "\n", + "gdp_pop_df = gdp_pop_df.join(cck_gdp, how=\"outer\")\n", + "\n", + "# population\n", + "gdp_pop_df.loc[(\"CCK\", [2001, 2006, 2011, 2016]), \"aus_census_pop\"] = (\n", + " np.array([621, 572, 550, 544]) / 1000000\n", + ")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "55f78a73-023c-48ce-81df-7510ecf88d98", + "metadata": {}, + "source": [ + "#### Christmas Island (`CXR`)\n", + "- GDP: Information available from the House of Representative Committees of Parliament of Australia (link [here](https://www.aph.gov.au/parliamentary_business/committees/House_of_Representatives_Committees?url=ncet/economicenvironment/report/index.htm)). Please see **Chapter 3 The economic environment of the Indian Ocean Territories** page 23; the units are in Australian dollars (nominal), and the value corresponds to 2010's GDP.\n", + "- Population: from the Australian Bureau of Statistics (ABS); information for [2016](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2016/quickstat/90101?opendocument), [2011](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2011/quickstat/910052009?opendocument), [2006](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2006/quickstat/910052009?opendocument&navpos=220), and [2001](https://quickstats.censusdata.abs.gov.au/census_services/getproduct/census/2001/quickstat/910052009?opendocument&navpos=220) available from the ABS Quickstat pages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c93edf40-a139-4ccb-9a6d-35d65f77af45", + "metadata": {}, + "outputs": [], + "source": [ + "# population\n", + "cxr_gdp_pop = gdp_pop_df.loc[[\"CCK\"]].reset_index()\n", + "cxr_gdp_pop[\"ccode\"] = \"CXR\"\n", + "cxr_gdp_pop.set_index([\"ccode\", \"year\"], inplace=True)\n", + "cxr_gdp_pop.loc[(\"CXR\", [2001, 2006, 2011, 2016]), \"aus_census_pop\"] = (\n", + " np.array([1446, 1349, 2072, 1843]) / 1000000\n", + ")\n", + "\n", + "# GDP\n", + "xrate_val = (\n", + " pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\")\n", + " .loc[(\"AUS\", 2010), \"xrate\"]\n", + " .values[0]\n", + ")\n", + "cxr_gdp_pop.loc[(\"CXR\", 2010), \"aus_census_nom_gdp\"] = xrate_val * 71000000 / 1000000\n", + "\n", + "# merging\n", + "gdp_pop_df = pd.concat([gdp_pop_df, cxr_gdp_pop], axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "20aa0c69-7d20-4bd8-aa68-2e31d7ee8234", + "metadata": {}, + "source": [ + "#### Pitcairn Island (`PCN`)\n", + "\n", + "- GDP: estimate of approximately 217,000 New Zealand dollars (from [this link](https://web.archive.org/web/20150705134639/http://www.government.pn/policies/Pitcairn%20Island%20SDP%202012-2016.pdf#page=4) for a WayBackMachine Archive of the Government of Pitcairn's \"Pitcairn Islands Strategic Development Plan\")\n", + "- Population: from the Pitcairn Island [government website](http://www.immigration.gov.pn/community/the_people/index.html), 233 people in 1937 and 49 people in 2017. Also, according to CIA World Factbook ([link here](https://www.cia.gov/the-world-factbook/countries/pitcairn-islands/#people-and-society)), its population was 50 in 2021 (will interpolate and round up to whole numbers)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a4948806-11d6-4237-a9f7-e5698707d467", + "metadata": {}, + "outputs": [], + "source": [ + "# Pitcairn islands population\n", + "pcn_50_20 = np.round(\n", + " np.exp(\n", + " np.interp(list(range(1950, 2021)), [1937, 2017, 2021], np.log([233, 49, 50]))\n", + " ),\n", + " 0,\n", + ")\n", + "pcn_gdp = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"NZL\", 1950:], \"pop\"].copy() * np.nan)\n", + " .rename(\"pcn_pop\")\n", + " .reset_index()\n", + ")\n", + "pcn_gdp[\"ccode\"] = \"PCN\"\n", + "pcn_pop = pcn_gdp.copy()\n", + "pcn_pop = pcn_pop.set_index([\"ccode\", \"year\"]).pcn_pop\n", + "pcn_pop.loc[\"PCN\", list(range(1950, 2021))] = pcn_50_20 / 1000000\n", + "\n", + "# Pitcairn GDP\n", + "pcn_gdp.rename(columns={\"pcn_pop\": \"pcn_nom_gdp\"}, inplace=True)\n", + "pcn_gdp = pcn_gdp.set_index([\"ccode\", \"year\"]).pcn_nom_gdp\n", + "wdi_xrate = (\n", + " pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\")\n", + " .loc[(\"NZL\", 2006), \"xrate\"]\n", + " .values[0]\n", + ")\n", + "pcn_gdp.loc[\"PCN\", 2006] = (217000 / 1000000) * wdi_xrate\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(pcn_pop, how=\"outer\")\n", + "gdp_pop_df = gdp_pop_df.join(pcn_gdp, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "03150de2-40b1-4c60-9e97-3129d93a00e7", + "metadata": {}, + "source": [ + "#### Svalbard and Jan Mayen (`SJM`)\n", + "\n", + "Jan Mayen is uninhabited, but Svalbard has population and economic activity.\n", + "- GDP: Unfortunately, we will have to use the GDP per capita of Norway itself as we do not have a reliable GDP estimate of Svalbard and `SJM` is a part of Norway.\n", + "- Population: From the Statistikkbanken (Statistics Norway, link [here](https://www.ssb.no/en/statbank/table/07429)), select all half years (2009-2021)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d8a7ba3-19ab-48d2-88bd-e3c3d408f837", + "metadata": {}, + "outputs": [], + "source": [ + "## svalbard and jan maarten (no population for jan mayen)\n", + "h1 = [2085, 2052, 2017, 2115, 2158, 2100, 2185, 2152, 2145, 2214, 2258, 2428]\n", + "h2 = [2140, 2071, 2140, 2195, 2195, 2118, 2189, 2162, 2210, 2310, 2379, 2417]\n", + "sjm_pop_09_20 = np.round((np.array(h1) + np.array(h2)) / 2, 0) / 1000000\n", + "sjm_pop = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"NOR\", 1950:], \"pop\"].copy() * np.nan)\n", + " .rename(\"nor_census_pop\")\n", + " .reset_index()\n", + ")\n", + "sjm_pop[\"ccode\"] = \"SJM\"\n", + "sjm_pop = sjm_pop.set_index([\"ccode\", \"year\"]).nor_census_pop\n", + "sjm_pop.loc[\"SJM\", list(range(2009, 2021))] = sjm_pop_09_20\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(sjm_pop, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "34144b4b-a40c-450b-b77a-5b4fcfd5817d", + "metadata": {}, + "source": [ + "#### Saint Helena, Ascension and Tristan da Cunha (`SHN`)\n", + "\n", + "We have data from the [St. Helena Government](https://www.sainthelena.gov.sh/wp-content/uploads/2020/07/SEDP-EOY-Progress-Report-Final-160720.pdf) about the estimated GDP per capita (in 2019 prices, non-PPP) of 2018 and 2019. We will combine this later (by comparing ratios with the UK GDP) to get the approximate GDP per capita values in PPP.\n", + "- Note that this is *not* the average GDPpc of Saint Helena, Ascension and Tristan da Cunha but rather just Saint Helena (so we are using Saint Helena to proxy for the three areas, which are represented by the country-code `SHN`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27600ef8-3547-4478-be9e-0fcca7c7538a", + "metadata": {}, + "outputs": [], + "source": [ + "wdi_xrate = (\n", + " pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\")\n", + " .loc[(\"GBR\", [2018, 2019]), \"xrate\"]\n", + " .values\n", + ")\n", + "shn = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"GBR\", 1950:], \"rgdpna\"].copy() * np.nan)\n", + " .rename(\"shn_gov_gdppc\")\n", + " .reset_index()\n", + ")\n", + "shn[\"ccode\"] = \"SHN\"\n", + "shn = shn.set_index([\"ccode\", \"year\"]).shn_gov_gdppc\n", + "shn.loc[\"SHN\", [2018, 2019]] = np.array([8490, 8230]) * wdi_xrate\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(shn, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "bad0c87a-bd6f-4b79-ae7e-a091125d96a4", + "metadata": {}, + "source": [ + "#### Saint Barthélemy (`BLM`)\n", + "\n", + "Saint Barthélemy's 2010 and 1999 (nominal) GDP per capita shown in the CEROM document: [link here](https://www.cerom-outremer.fr/guadeloupe/publications/etudes-cerom/estimation-du-pib-par-habitant-de-st-barthelemy.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "486ae6c9-0db2-4afb-83d0-60c6b2e3064d", + "metadata": {}, + "outputs": [], + "source": [ + "blm = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"GBR\", 1950:], \"rgdpna\"].copy() * np.nan)\n", + " .rename(\"cerom_gdppc\")\n", + " .reset_index()\n", + ")\n", + "blm[\"ccode\"] = \"BLM\"\n", + "blm = blm.set_index([\"ccode\", \"year\"]).cerom_gdppc\n", + "wdi_xrate = (\n", + " pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\")\n", + " .loc[(\"EMU\", [1999, 2010]), \"xrate\"]\n", + " .values\n", + ")\n", + "blm.loc[\"BLM\", [1999, 2010]] = np.array([26000, 35700]) * wdi_xrate\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(blm, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b013433d-6321-4c6e-9146-587445eb1baa", + "metadata": {}, + "source": [ + "#### United States Minor Outlying Islands (`UMI`)\n", + "\n", + "- Population: from the U.S. Census ([link here](https://www.census.gov/history/pdf/2000-minoroutlyingislands.pdf)), years 1980, 1990, 2000\n", + "- GDP: will use GDPpc from `MNP` (Northern Mariana Islands)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79322cb4-5716-40bc-a2bd-41a8887ede64", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# US Minor Outlying Islands\n", + "umi_gdp = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"USA\", 1950:], \"pop\"].copy() * np.nan)\n", + " .rename(\"us_census_pop\")\n", + " .reset_index()\n", + ")\n", + "umi_gdp[\"ccode\"] = \"UMI\"\n", + "umi_gdp = umi_gdp.set_index([\"ccode\", \"year\"]).us_census_pop\n", + "umi_gdp.loc[\"UMI\", [1980, 1990, 2000]] = np.array([1082, 193, 316]) / 1000000\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(umi_gdp, how=\"outer\")\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "d6f8058b-f7f7-4ff8-8ae0-51166566dbce", + "metadata": {}, + "source": [ + "### Uninhabited areas (no population and no economic activity)\n", + "\n", + "These are: the French Southern and Antarctic Lands (`ATF`), Bouvet Island (`BVT`), Clipperton Island (`Cl-`), Heard and McDonald Islands (`HMD`), British Indian Ocean Territory (`IOT`), South Georgia and the South Sandwich Islands (`SGS`).\n", + "- `ATF`: According to the CIA World Factbook website (link [here](https://www.cia.gov/the-world-factbook/countries/french-southern-and-antarctic-lands/)), `ATF` does not have permanent population and therefore we will record this as having no population and no economic activity.\n", + "- `BVT`: uninhabited to protect nature reserve\n", + "- `CL-`: is an atoll with no permanent inhabitants since 1945.\n", + "- `HMD`: is an Australian external territory near Antarctica.\n", + "- `IOT`: is mostly composed of U.S.-U.K. military facilities with no permanent population.\n", + "- `SGS`: is uninhabited" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c6d7863-b1bb-4a54-bd3d-23f63f21c1c3", + "metadata": {}, + "outputs": [], + "source": [ + "# assigning 0 population and 0 GDP\n", + "atf_pop = (\n", + " (gdp_pop_df.loc[pd.IndexSlice[\"FRA\", 1950:], \"pop\"].copy() * np.nan)\n", + " .rename(\"noecon_pop\")\n", + " .reset_index()\n", + ")\n", + "atf_pop[\"ccode\"], atf_pop[\"atf_pop\"] = \"ATF\", 0\n", + "atf_pop.set_index([\"ccode\", \"year\"], inplace=True)\n", + "atf_gdp = atf_pop.copy().rename(columns={\"noecon_pop\": \"noecon_rgdpna\"})\n", + "atf_pop, atf_gdp = atf_pop.noecon_pop, atf_gdp.noecon_rgdpna\n", + "\n", + "# merging all\n", + "gdp_pop_df = gdp_pop_df.join(atf_pop, how=\"outer\")\n", + "gdp_pop_df = gdp_pop_df.join(atf_gdp, how=\"outer\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c01b354f-8ca5-4038-8cad-bd6773beb13a", + "metadata": {}, + "outputs": [], + "source": [ + "# Attaching the other uninhabited areas' information\n", + "for i in np.setdiff1d(sset.UNINHABITED_ISOS, [\"ATF\"]):\n", + " i_df = gdp_pop_df.loc[([\"ATF\"], slice(None)), :].reset_index()\n", + " i_df[\"ccode\"] = i\n", + " i_df.set_index([\"ccode\", \"year\"], inplace=True)\n", + " gdp_pop_df = pd.concat([gdp_pop_df, i_df], axis=0)\n", + "gdp_pop_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6e03a7c0-1784-4e5c-ac8a-2ff044a4080c", + "metadata": {}, + "source": [ + "### Exporting the intermediate result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e77e0021-692c-4153-ab55-a3bc436ec854", + "metadata": {}, + "outputs": [], + "source": [ + "# NE.GDI.FTOT.ZS: Gross fixed cap. formation rate in WB WDI; will be dealt with later\n", + "col_to_drop = np.intersect1d(gdp_pop_df.columns, [\"country\", \"NE.GDI.FTOT.ZS\"])\n", + "if len(col_to_drop) > 0:\n", + " gdp_pop_df.drop(col_to_drop, axis=1, inplace=True)\n", + "\n", + "gdp_pop_df.to_parquet(sset.DIR_YPK_RAW / \"gdp_gdppc_pop_raw_multiple_sources.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "974df6fe-3f7b-469a-8c99-67e5ce35b9d5", + "metadata": {}, + "source": [ + "## Historical population (1950-2019), creating a single sequence\n", + "\n", + "Before we go on further, note that when we refer to country-level population for those with overseas territories, it excludes the population of such territories (e.g., `USA` population noted below does not include `PRI` [Puerto Rico]). One big exception is that `FRA` (France) from PWT actually includes the following territories or \"overseas region\" into its population value calculation: `GLP`, `MYT`, `MTQ`, `GUF`, and `REU`. So we will actually use the `FRA+OV` designation for PWT variables and clean up along the way so that `FRA` only represents mainland France.\n", + "\n", + "### Re-reading in the raw-organized data\n", + "\n", + "If worried about memory issues (due to reasons outside of this notebook), restart the kernel, run the first and second cells, and run the following cells." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18ace68c-6493-4b15-8570-ce7b74b5cf0f", + "metadata": {}, + "outputs": [], + "source": [ + "gp_df = pd.read_parquet(sset.DIR_YPK_RAW / \"gdp_gdppc_pop_raw_multiple_sources.parquet\")\n", + "fraov = gp_df.loc[(\"FRA\", slice(None)), [\"pop\", \"cgdpo\", \"rgdpna\", \"rgdpo\"]]\n", + "fraov.reset_index(inplace=True)\n", + "fraov[\"ccode\"] = \"FRA+OV\"\n", + "gp_df = pd.concat([gp_df, fraov.set_index([\"ccode\", \"year\"])], axis=0)\n", + "\n", + "# just setting apart the population data\n", + "popraw_df = gp_df.loc[:, [x for x in gp_df.columns if \"pop\" in x]]" + ] + }, + { + "cell_type": "markdown", + "id": "43ad56e9-0fea-413e-a48d-34ef9331cf41", + "metadata": {}, + "source": [ + "### Cleaning for the uninhabited areas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1250231e-200e-485c-8050-6d3d3bcce349", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# `inh` for inhabited\n", + "pop_uninh = popraw_df.loc[sset.UNINHABITED_ISOS, :].sort_index()\n", + "pop_uninh[\"pop\"] = 0\n", + "pop_uninh[\"pop_source\"] = \"uninhabited\"\n", + "pop_uninh[\"pop_unit\"] = \"millions (of people)\"\n", + "pop_uninh = pop_uninh[[\"pop_unit\", \"pop_source\", \"pop\"]]\n", + "pop_inh = popraw_df.loc[\n", + " ~popraw_df.index.get_level_values(\"ccode\").isin(sset.UNINHABITED_ISOS), :\n", + "].sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "5f834e8e-eda8-46d4-bb7e-6d4b86ee9498", + "metadata": { + "tags": [] + }, + "source": [ + "### Cleaning for Serbia and Kosovo\n", + "\n", + "It has been noted that Kosovo's population was included in the Serbian population from UN (for all times) and that from PWT (before 1999). We do have the Kosovan population from World Bank (1960-2020) so we will subtract this from the Serbian population, and for 1950-1959, we will use the mean ratio between Kosovo and Serbia." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9db3eb7b-03f8-4473-884c-ce7f3ce094f4", + "metadata": {}, + "outputs": [], + "source": [ + "# 1960-2020\n", + "kosovo_pop = pop_inh.loc[\"KO-\", \"wb_pop\"]\n", + "kosovo_yrs = kosovo_pop.index.values\n", + "pop_inh.loc[(\"SRB\", kosovo_yrs), \"pop\"] = (\n", + " pop_inh.loc[(\"SRB\", kosovo_yrs), \"un_pop\"].values - kosovo_pop.values\n", + ")\n", + "srb_ko_pop = pop_inh.loc[[\"SRB\"], [\"pop\"]].sort_index()\n", + "ko_pop = srb_ko_pop.reset_index()\n", + "ko_pop[\"ccode\"], ko_pop[\"pop\"] = \"KO-\", np.nan\n", + "srb_ko_pop = pd.concat(\n", + " [srb_ko_pop, ko_pop.set_index([\"ccode\", \"year\"])], axis=0\n", + ").sort_index()\n", + "srb_ko_pop.loc[(\"KO-\", kosovo_yrs), \"pop\"] = kosovo_pop.values\n", + "\n", + "# taking care of the 1950-1959 (mean ratio of KO- to KO- + SRB)\n", + "ratio = (kosovo_pop.values / pop_inh.loc[(\"SRB\", kosovo_yrs), \"un_pop\"].values).mean()\n", + "pre_kosovo_yrs = np.sort(\n", + " np.setdiff1d(srb_ko_pop.index.get_level_values(\"year\").unique(), kosovo_yrs)\n", + ")\n", + "kosovo_pre_pop = pop_inh.loc[(\"SRB\", pre_kosovo_yrs), \"un_pop\"].values * ratio\n", + "srb_ko_pop.loc[(\"SRB\", pre_kosovo_yrs), \"pop\"] = (\n", + " pop_inh.loc[(\"SRB\", pre_kosovo_yrs), \"un_pop\"].values - kosovo_pre_pop\n", + ")\n", + "srb_ko_pop.loc[(\"KO-\", pre_kosovo_yrs), \"pop\"] = kosovo_pre_pop\n", + "srb_ko_pop[\"pop_unit\"] = \"millions (of people)\"\n", + "srb_ko_pop[\"pop_source\"] = \"UN_SRB_minus_WB_XKX\"\n", + "srb_ko_pop.loc[(\"KO-\", kosovo_yrs), \"pop_source\"] = \"WB\"\n", + "srb_ko_pop.loc[(\"SRB\", pre_kosovo_yrs), \"pop_source\"] = \"UN_SRB_ratio_WB_XKX\"\n", + "srb_ko_pop.loc[(\"KO-\", pre_kosovo_yrs), \"pop_source\"] = \"UN_SRB_ratio_WB_XKX\"\n", + "\n", + "## merging with the uninhabited to create the \"clean\" dataset\n", + "pop_cleaned = pd.concat([pop_uninh, srb_ko_pop], axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "26e376cf-b78a-4794-9474-81a984c00d1b", + "metadata": {}, + "source": [ + "### Cleaning for the U.S. and U.S. Territories\n", + "\n", + "It seems that there is some arbitrariness when it comes to including territories or excluding them, when calculating for the population (even within the same dataset, it is unclear whether the population for some year includes or excludes the territories). We will take the PWT10.0 population as the U.S. population without territories included, and attach population numbers of the territories appropriately (from relevant, filled data sources). For the missing years we extrapolate using the known ratio between the respective territory and the U.S. mainland." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "adc5a2d4-5e3e-4aa0-9fd8-72ed5184218e", + "metadata": {}, + "outputs": [], + "source": [ + "# USA; use PWT10.0 as the base\n", + "# since it's missing 2020, use the growth rate from wb_pop\n", + "us_gr = pop_inh.loc[(\"USA\", 2020), \"un_pop\"] / pop_inh.loc[(\"USA\", 2019), \"un_pop\"]\n", + "us_2020 = pop_inh.loc[(\"USA\", 2019), \"pop\"] * us_gr\n", + "us_df = pop_inh.loc[([\"USA\"], range(1950, 2021)), [\"pop\"]].sort_index()\n", + "us_df.loc[(\"USA\", 2020), \"pop\"] = us_2020\n", + "us_df[\"pop_source\"] = \"PWT\"\n", + "us_df.loc[(\"USA\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "740eb452-3447-4924-97ba-62c45707c082", + "metadata": {}, + "outputs": [], + "source": [ + "# UMI\n", + "umi_yrs = (\n", + " pop_inh.loc[~pd.isnull(pop_inh.us_census_pop), :]\n", + " .index.get_level_values(\"year\")\n", + " .values\n", + ")\n", + "umi_df = pop_inh.loc[(\"USA\", range(1950, 2021)), [\"pop\"]].reset_index()\n", + "umi_df[\"ccode\"], umi_df[\"pop\"] = \"UMI\", np.nan\n", + "umi_df.set_index([\"ccode\", \"year\"], inplace=True)\n", + "umi_vals = pop_inh.loc[(\"UMI\", umi_yrs), \"us_census_pop\"].values\n", + "umi_df.loc[(\"UMI\", umi_yrs), \"pop\"] = umi_vals\n", + "umi_ratio = (\n", + " umi_df.loc[(\"UMI\", umi_yrs), \"pop\"].values\n", + " / pop_inh.loc[(\"USA\", umi_yrs), \"pop\"].values\n", + ").mean()\n", + "umi_interp_yrs = list(range(umi_yrs.min(), umi_yrs.max() + 1))\n", + "umi_df.loc[(\"UMI\", umi_interp_yrs), \"pop\"] = np.exp(\n", + " np.interp(umi_interp_yrs, umi_yrs, np.log(umi_vals))\n", + ")\n", + "umi_df[\"pop_source\"] = \"interp\"\n", + "umi_df.loc[(\"UMI\", umi_yrs), \"pop_source\"] = \"US_CENSUS\"\n", + "\n", + "# ratio with the US\n", + "umi_remaining = np.setdiff1d(list(range(1950, 2021)), umi_interp_yrs)\n", + "umi_df.loc[(\"UMI\", umi_remaining), \"pop\"] = (\n", + " us_df.loc[(\"USA\", umi_remaining), \"pop\"].values * umi_ratio\n", + ")\n", + "umi_df.loc[(\"UMI\", umi_remaining), \"pop_source\"] = \"US_CENSUS_UMI_ratio_PWT_USA\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41aabd4c-6749-4568-9297-ba0ef2e03407", + "metadata": {}, + "outputs": [], + "source": [ + "# PRI, VIR, GUM, ASM, MNP: use UN population\n", + "other_us_terr_df = (\n", + " pop_inh.loc[([\"PRI\", \"VIR\", \"GUM\", \"ASM\", \"MNP\"], range(1950, 2021)), [\"un_pop\"]]\n", + " .sort_index()\n", + " .rename(columns={\"un_pop\": \"pop\"})\n", + ")\n", + "other_us_terr_df[\"pop_source\"] = \"UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38b82030-f5cf-4cb0-98ea-d61f00883c25", + "metadata": {}, + "outputs": [], + "source": [ + "# merging the cleaned information\n", + "pop_cleaned = pd.concat([pop_cleaned, us_df, umi_df, other_us_terr_df]).sort_index()\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "29e710f7-6d48-4a7f-9bb7-77c4c2d2e755", + "metadata": {}, + "source": [ + "### Cleaning for the French territories\n", + "\n", + "There are (excluding the no-population ones):\n", + "- Five overseas departments: `GUF`, `GLP`, `MTQ`, `MYT`, `REU`\n", + "- Overseas collectivities: `PYF`, `BLM`, `SPM`, `MAF`, `WLF`\n", + "- Other: `NCL`\n", + "\n", + "Including that for France, we will simply use UN population (since its French population doesn't include the departments)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5171db20-abdd-44ad-8ad6-12948f79b173", + "metadata": {}, + "outputs": [], + "source": [ + "# overseas departments\n", + "french = [\"GUF\", \"GLP\", \"MTQ\", \"MYT\", \"REU\", \"PYF\", \"BLM\", \"SPM\", \"MAF\", \"WLF\"]\n", + "french += [\"NCL\", \"FRA\"]\n", + "french_pop = pop_inh.loc[(french, range(1950, 2021)), [\"un_pop\"]].rename(\n", + " columns={\"un_pop\": \"pop\"}\n", + ")\n", + "french_pop[\"pop_source\"] = \"UN\"\n", + "french_pop[\"pop_unit\"] = \"millions (of people)\"\n", + "\n", + "pop_cleaned = pd.concat([french_pop, pop_cleaned], axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "2db7eebe-ae62-47e7-bdd3-3a2b43a590fa", + "metadata": {}, + "source": [ + "### Cleaning for the British territories\n", + "\n", + "These are (excluding the no-population ones):\n", + "- Overseas Territories: `AIA`, `BMU`, `VGB`, `CYM`, `FLK`, `GIB`, `MSR`, `PCN`, `SHN`, `TCA`\n", + "- Crown dependencies: `GGY`, `JEY`, `IMN`\n", + "\n", + "1. For all Overseas Territories *except `PCN`*, we take from UN (and for `PCN`, from interpolated data using CIA WF and `PCN` Government data).\n", + "\n", + "2. For `GGY` and `JEY`, their merged information is in `GGY+JEY` (for `un_pop`). Guernsey Annual Electronic Report (link [here](https://gov.gg/CHttpHandler.ashx?id=123156&p=0#:~:text=At%20the%20end%20of%20March%202019%2C%20Guernsey's%20population%20was%2062%2C792.&text=There%20was%20a%20natural%20decrease,of%20459%20people%20(0.7%25).)) shows `GGY` (Guernsey)'s population from 2009 to 2019. Take the average ratio of `GGY` population to `GGY+JEY` between these years, and use this ratio to extrapolate for the missing years (of `GGY` and `JEY`, separately).\n", + "\n", + "3. For `GBR`, take from PWT10.0. For `IMN`, take from UN." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ece16155-3257-408d-993c-8fc2de3e3238", + "metadata": {}, + "outputs": [], + "source": [ + "# cleaning Pitcairn\n", + "pcn_pop = pop_inh.loc[[\"PCN\"], [\"pcn_pop\"]].rename(columns={\"pcn_pop\": \"pop\"})\n", + "pcn_pop[\"pop_source\"] = \"interp\"\n", + "pcn_pop.loc[(\"PCN\", 2017), \"pop_source\"] = \"PCN_GOV\"\n", + "pcn_pop.loc[(\"PCN\", 2020), \"pop_source\"] = \"PCN_GOV_interp_CIA\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee7957e2-ed5b-4a4d-83fe-39fc817e7948", + "metadata": {}, + "outputs": [], + "source": [ + "# Guernsey and Jersey\n", + "ggy_09_19 = [62274, 62431, 62915, 63085, 62732, 62341, 62234, 62208, 62106]\n", + "ggy_09_19 += [62333, 62792]\n", + "ggy_09_19 = np.array(ggy_09_19) / 1000000\n", + "yr0919 = list(range(2009, 2020))\n", + "\n", + "ggy_jey_df = pop_inh.loc[[\"GGY+JEY\"], [\"un_pop\"]].rename(columns={\"un_pop\": \"pop\"})\n", + "ggy_df = ggy_jey_df.reset_index()\n", + "ggy_df[\"ccode\"] = \"GGY\"\n", + "ggy_df[\"pop\"] = np.nan\n", + "ggy_df.loc[ggy_df.year.isin(yr0919), \"pop\"] = ggy_09_19\n", + "ggy_df.set_index([\"ccode\", \"year\"], inplace=True)\n", + "\n", + "ggy_ratio = (ggy_09_19 / ggy_jey_df.loc[(\"GGY+JEY\", yr0919), \"pop\"].values).mean()\n", + "not_0919 = np.setdiff1d(list(range(1950, 2021)), yr0919)\n", + "ggy_df.loc[(\"GGY\", not_0919), \"pop\"] = (\n", + " ggy_jey_df.loc[(\"GGY+JEY\", not_0919), \"pop\"].values * ggy_ratio\n", + ")\n", + "jey_df = ggy_jey_df.reset_index()\n", + "jey_df[\"ccode\"], jey_df[\"pop\"] = \"JEY\", ggy_jey_df[\"pop\"].values - ggy_df[\"pop\"].values\n", + "jey_df.set_index([\"ccode\", \"year\"], inplace=True)\n", + "\n", + "# sources\n", + "ggy_df[\"pop_source\"] = \"GGY_REPORT\"\n", + "ggy_df.loc[(\"GGY\", not_0919), \"pop_source\"] = \"UN_ratio_GGY_REPORT\"\n", + "jey_df[\"pop_source\"] = \"UN_ratio_GGY_REPORT\"\n", + "jey_df.loc[(\"JEY\", yr0919), \"pop_source\"] = \"UN_minus_GGY_REPORT\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8e28735-9b45-4dc6-b78b-388df71eeb80", + "metadata": {}, + "outputs": [], + "source": [ + "# other GBR territories and GBR\n", + "gbr_df = pop_inh.loc[([\"GBR\"], range(1950, 2021)), [\"pop\"]]\n", + "gbr_df.loc[(\"GBR\", 2020), \"pop\"] = (\n", + " gbr_df.loc[(\"GBR\", 2019), \"pop\"]\n", + " * pop_inh.loc[(\"GBR\", 2020), \"un_pop\"]\n", + " / pop_inh.loc[(\"GBR\", 2019), \"un_pop\"]\n", + ")\n", + "gbr_df[\"pop_source\"] = \"PWT\"\n", + "gbr_df.loc[(\"GBR\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"\n", + "\n", + "other_gbr_terr_df = pop_inh.loc[\n", + " [\"AIA\", \"BMU\", \"VGB\", \"CYM\", \"FLK\", \"GIB\", \"MSR\", \"SHN\", \"TCA\", \"IMN\"], [\"un_pop\"]\n", + "].rename(columns={\"un_pop\": \"pop\"})\n", + "other_gbr_terr_df[\"pop_source\"] = \"UN\"\n", + "\n", + "# gathering all GBR-related territories\n", + "gbr_rel_df = pd.concat([pcn_pop, ggy_df, jey_df, gbr_df, other_gbr_terr_df], axis=0)\n", + "gbr_rel_df[\"pop_unit\"] = \"millions (of people)\"\n", + "\n", + "# merging\n", + "pop_cleaned = pd.concat([gbr_rel_df, pop_cleaned], axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "286a5bf0-e9b2-4901-af6f-47392fb8b6bf", + "metadata": {}, + "source": [ + "### Cleaning for the Australian territories\n", + "\n", + "These are (excluding the no-population ones):\n", + "- External Territories: `CXR`, `CCK`, `NFK`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9f148b3-96df-4d76-9525-947761d61339", + "metadata": {}, + "outputs": [], + "source": [ + "# getting the AUS 2020 value in\n", + "pop_inh.loc[(\"AUS\", 2020), \"pop\"] = (\n", + " pop_inh.loc[(\"AUS\", 2020), \"un_pop\"]\n", + " / pop_inh.loc[(\"AUS\", 2019), \"un_pop\"]\n", + " * pop_inh.loc[(\"AUS\", 2019), \"pop\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43cf297a-a494-40a2-b2f5-fea110b7596f", + "metadata": {}, + "outputs": [], + "source": [ + "# christmas island\n", + "cxr_df = pop_inh.loc[[\"CXR\"], [\"aus_census_pop\"]].rename(\n", + " columns={\"aus_census_pop\": \"pop\"}\n", + ")\n", + "aus_cen_yrs = [2001, 2006, 2011, 2016]\n", + "cxr_df[\"pop_source\"] = \"interp\"\n", + "cxr_df.loc[(\"CXR\", aus_cen_yrs), \"pop_source\"] = \"AUS_CENSUS\"\n", + "cxr_interp_yrs = range(np.min(aus_cen_yrs), np.max(aus_cen_yrs) + 1)\n", + "cxr_df.loc[(\"CXR\", list(cxr_interp_yrs)), \"pop\"] = np.exp(\n", + " np.interp(\n", + " cxr_interp_yrs,\n", + " aus_cen_yrs,\n", + " np.log(cxr_df.loc[(\"CXR\", aus_cen_yrs), \"pop\"].values),\n", + " )\n", + ")\n", + "\n", + "# country-territory ratios for extrapolation\n", + "cxr_ratio = (\n", + " cxr_df.loc[(\"CXR\", aus_cen_yrs), \"pop\"].values\n", + " / pop_inh.loc[(\"AUS\", aus_cen_yrs), \"pop\"].values\n", + ").mean()\n", + "non_cen_yrs = np.setdiff1d(list(range(1950, 2021)), cxr_interp_yrs)\n", + "cxr_df.loc[(\"CXR\", non_cen_yrs), \"pop\"] = (\n", + " cxr_ratio * pop_inh.loc[(\"AUS\", non_cen_yrs), \"pop\"].values\n", + ")\n", + "cxr_df.loc[(\"CXR\", non_cen_yrs), \"pop_source\"] = \"PWT_AUS_ratio_AUS_CENSUS_CXR\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ac99c46-1989-4f8a-926b-a5f27cc9e56f", + "metadata": {}, + "outputs": [], + "source": [ + "# Cocos keeling island\n", + "cck_df = pop_inh.loc[[\"CCK\"], [\"aus_census_pop\"]].rename(\n", + " columns={\"aus_census_pop\": \"pop\"}\n", + ")\n", + "cck_df[\"pop_source\"] = \"interp\"\n", + "cck_df.loc[(\"CCK\", aus_cen_yrs), \"pop_source\"] = \"AUS_CENSUS\"\n", + "cck_df.loc[(\"CCK\", list(cxr_interp_yrs)), \"pop\"] = np.exp(\n", + " np.interp(\n", + " cxr_interp_yrs,\n", + " aus_cen_yrs,\n", + " np.log(cck_df.loc[(\"CCK\", aus_cen_yrs), \"pop\"].values),\n", + " )\n", + ")\n", + "\n", + "# country-territory ratios for extrapolation\n", + "cck_ratio = (\n", + " cck_df.loc[(\"CCK\", aus_cen_yrs), \"pop\"].values\n", + " / pop_inh.loc[(\"AUS\", aus_cen_yrs), \"pop\"].values\n", + ").mean()\n", + "cck_df.loc[(\"CCK\", non_cen_yrs), \"pop\"] = (\n", + " cck_ratio * pop_inh.loc[(\"AUS\", non_cen_yrs), \"pop\"].values\n", + ")\n", + "cck_df.loc[(\"CCK\", non_cen_yrs), \"pop_source\"] = \"PWT_AUS_ratio_AUS_CENSUS_CCK\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f448410-1618-43ac-a14f-41bb208a80e3", + "metadata": {}, + "outputs": [], + "source": [ + "## norfolk island\n", + "nfk_df = pop_inh.loc[[\"NFK\"], [\"aus_census_pop\"]].rename(\n", + " columns={\"aus_census_pop\": \"pop\"}\n", + ")\n", + "nfk_df[\"pop_source\"] = \"interp\"\n", + "nfk_df.loc[(\"NFK\", [2001, 2011, 2016]), \"pop_source\"] = \"AUS_CENSUS\"\n", + "nfk_df.loc[(\"NFK\", list(cxr_interp_yrs)), \"pop\"] = np.exp(\n", + " np.interp(\n", + " cxr_interp_yrs,\n", + " [2001, 2011, 2016],\n", + " np.log(nfk_df.loc[(\"NFK\", [2001, 2011, 2016]), \"pop\"].values),\n", + " )\n", + ")\n", + "\n", + "# country-territory ratios for extrapolation\n", + "nfk_ratio = (\n", + " nfk_df.loc[(\"NFK\", [2001, 2011, 2016]), \"pop\"].values\n", + " / pop_inh.loc[(\"AUS\", [2001, 2011, 2016]), \"pop\"].values\n", + ").mean()\n", + "nfk_df.loc[(\"NFK\", non_cen_yrs), \"pop\"] = (\n", + " nfk_ratio * pop_inh.loc[(\"AUS\", non_cen_yrs), \"pop\"].values\n", + ")\n", + "nfk_df.loc[(\"NFK\", non_cen_yrs), \"pop_source\"] = \"PWT_AUS_ratio_AUS_CENSUS_NFK\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3c08cad-fa36-48c2-b2a4-423d37c43fc7", + "metadata": {}, + "outputs": [], + "source": [ + "aus_df = pop_inh.loc[([\"AUS\"], range(1950, 2021)), [\"pop\"]].copy()\n", + "aus_df[\"pop_source\"] = \"PWT\"\n", + "aus_df.loc[(\"AUS\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"\n", + "\n", + "pop_cleaned = pd.concat([aus_df, pop_cleaned, nfk_df, cck_df, cxr_df], axis=0)\n", + "pop_cleaned.sort_index(inplace=True)\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "19feeb4a-2896-4dc2-b1d0-9c565ebdc8a2", + "metadata": {}, + "source": [ + "### Cleaning for the New Zealand territories\n", + "\n", + "These are (excluding the no-population ones):\n", + "- External Territories: `TKL`, `NIU`, `COK`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34953fdb-94d7-4970-a063-a9b5b053f3bb", + "metadata": {}, + "outputs": [], + "source": [ + "# New Zealand\n", + "nzl_df = pop_inh.loc[(\"NZL\", range(1950, 2021)), [\"pop\"]].sort_index()\n", + "nzl_df.loc[(\"NZL\", 2020), \"pop\"] = (\n", + " nzl_df.loc[(\"NZL\", 2019), \"pop\"]\n", + " * pop_inh.loc[(\"NZL\", 2020), \"un_pop\"]\n", + " / pop_inh.loc[(\"NZL\", 2019), \"un_pop\"]\n", + ")\n", + "nzl_df[\"pop_source\"] = \"PWT\"\n", + "nzl_df.loc[(\"NZL\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "97fa25d5-59d0-4d62-b395-5f08cb5ce22b", + "metadata": {}, + "outputs": [], + "source": [ + "nzl_terr_df = pop_inh.loc[\n", + " ([\"NIU\", \"COK\", \"TKL\"], list(range(1950, 2021))), [\"un_pop\"]\n", + "].rename(columns={\"un_pop\": \"pop\"})\n", + "nzl_terr_df[\"pop_source\"] = \"UN\"\n", + "\n", + "pop_cleaned = pd.concat([pop_cleaned, nzl_df, nzl_terr_df], axis=0).sort_index()\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "43d46cce-2446-4cce-9854-1fa6a276825a", + "metadata": {}, + "source": [ + "### Cleaning for the Danish territories\n", + "\n", + "These are (excluding the no-population ones):\n", + "- `GRL`, `FRO`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c05b4130-681b-4806-8e35-f2f32b884d63", + "metadata": {}, + "outputs": [], + "source": [ + "# Denmark\n", + "dnk_df = pop_inh.loc[(\"DNK\", range(1950, 2021)), [\"pop\"]].sort_index()\n", + "dnk_df.loc[(\"DNK\", 2020), \"pop\"] = (\n", + " dnk_df.loc[(\"DNK\", 2019), \"pop\"]\n", + " * pop_inh.loc[(\"DNK\", 2020), \"un_pop\"]\n", + " / pop_inh.loc[(\"DNK\", 2019), \"un_pop\"]\n", + ")\n", + "dnk_df[\"pop_source\"] = \"PWT\"\n", + "dnk_df.loc[(\"DNK\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d425dbf9-f612-4ec9-8715-d11f6212ea43", + "metadata": {}, + "outputs": [], + "source": [ + "dnk_terr_df = pop_inh.loc[([\"GRL\", \"FRO\"], list(range(1950, 2021))), [\"un_pop\"]].rename(\n", + " columns={\"un_pop\": \"pop\"}\n", + ")\n", + "dnk_terr_df[\"pop_source\"] = \"UN\"\n", + "\n", + "pop_cleaned = pd.concat([pop_cleaned, dnk_df, dnk_terr_df], axis=0).sort_index()\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "be427ad7-4508-4dd2-b87d-1f52ebfaca90", + "metadata": {}, + "source": [ + "### Cleaning for the Finnish territories\n", + "\n", + "These are (excluding the no-population ones):\n", + "- `ALA`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f008b05a-647c-4224-9b1a-0f2272acbfdc", + "metadata": {}, + "outputs": [], + "source": [ + "# Finland\n", + "fin_df = pop_inh.loc[(\"FIN\", range(1950, 2021)), [\"pop\"]].sort_index()\n", + "fin_df.loc[(\"FIN\", 2020), \"pop\"] = (\n", + " fin_df.loc[(\"FIN\", 2019), \"pop\"]\n", + " * pop_inh.loc[(\"FIN\", 2020), \"un_pop\"]\n", + " / pop_inh.loc[(\"FIN\", 2019), \"un_pop\"]\n", + ")\n", + "fin_df[\"pop_source\"] = \"PWT\"\n", + "fin_df.loc[(\"FIN\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de1796cc-280a-445e-a7d6-36417c4e878b", + "metadata": {}, + "outputs": [], + "source": [ + "ala_df = pop_inh.loc[([\"ALA\"], range(1950, 2021)), [\"ala_pop\"]].rename(\n", + " columns={\"ala_pop\": \"pop\"}\n", + ")\n", + "ala_df[\"pop_source\"] = \"ALA_STAT\"\n", + "ala_yrs = (\n", + " ala_df.loc[~pd.isnull(ala_df[\"pop\"]), :].index.get_level_values(\"year\").unique()\n", + ")\n", + "ala_noyrs = np.setdiff1d(list(range(1950, 2021)), ala_yrs)\n", + "ala_ratio = (\n", + " ala_df.loc[(\"ALA\", ala_yrs), \"pop\"].values\n", + " / fin_df.loc[(\"FIN\", ala_yrs), \"pop\"].values\n", + ").mean()\n", + "ala_df.loc[(\"ALA\", ala_noyrs), \"pop\"] = (\n", + " ala_ratio * fin_df.loc[(\"FIN\", ala_noyrs), \"pop\"].values\n", + ")\n", + "ala_df.loc[(\"ALA\", ala_noyrs), \"pop_source\"] = \"PWT_FIN_ratio_ALA_STAT_ALA\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41c6cc1f-569b-4d6d-a701-ec8ec993529e", + "metadata": {}, + "outputs": [], + "source": [ + "pop_cleaned = pd.concat([pop_cleaned, fin_df, ala_df], axis=0).sort_index()\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "6f4fbf24-9461-46dc-b151-ca0045e39a17", + "metadata": {}, + "source": [ + "### Cleaning for the Norwegian territories\n", + "\n", + "These are (excluding the no-population ones):\n", + "- `SJM`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79358d66-c505-4d37-bcc5-7596a1d4db1f", + "metadata": {}, + "outputs": [], + "source": [ + "# Finland\n", + "nor_df = pop_inh.loc[(\"NOR\", range(1950, 2021)), [\"pop\"]].sort_index()\n", + "nor_df.loc[(\"NOR\", 2020), \"pop\"] = (\n", + " nor_df.loc[(\"NOR\", 2019), \"pop\"]\n", + " * pop_inh.loc[(\"NOR\", 2020), \"un_pop\"]\n", + " / pop_inh.loc[(\"NOR\", 2019), \"un_pop\"]\n", + ")\n", + "nor_df[\"pop_source\"] = \"PWT\"\n", + "nor_df.loc[(\"NOR\", 2020), \"pop_source\"] = \"PWT_ratio_UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b922925-09be-4a6b-8c5b-490825e8af78", + "metadata": {}, + "outputs": [], + "source": [ + "sjm_df = pop_inh.loc[([\"SJM\"], range(1950, 2021)), [\"nor_census_pop\"]].rename(\n", + " columns={\"nor_census_pop\": \"pop\"}\n", + ")\n", + "sjm_df[\"pop_source\"] = \"NOR_CENSUS\"\n", + "sjm_yrs = (\n", + " sjm_df.loc[~pd.isnull(sjm_df[\"pop\"]), :].index.get_level_values(\"year\").unique()\n", + ")\n", + "sjm_noyrs = np.setdiff1d(list(range(1950, 2021)), sjm_yrs)\n", + "sjm_ratio = (\n", + " sjm_df.loc[(\"SJM\", sjm_yrs), \"pop\"].values\n", + " / nor_df.loc[(\"NOR\", sjm_yrs), \"pop\"].values\n", + ").mean()\n", + "sjm_df.loc[(\"SJM\", sjm_noyrs), \"pop\"] = (\n", + " sjm_ratio * nor_df.loc[(\"NOR\", sjm_noyrs), \"pop\"].values\n", + ")\n", + "sjm_df.loc[(\"SJM\", sjm_noyrs), \"pop_source\"] = \"PWT_NOR_ratio_NOR_CENSUS_SJM\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc842239-3d64-4e93-97d9-afbeefca9928", + "metadata": {}, + "outputs": [], + "source": [ + "pop_cleaned = pd.concat([pop_cleaned, nor_df, sjm_df], axis=0).sort_index()\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "152dee79-0f69-4b44-aeda-352e2892dffd", + "metadata": {}, + "source": [ + "### For the rest, filling in missing population info from UN populations data to PWT data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c71cc0d3-7827-47af-aedc-06ff811f85a0", + "metadata": {}, + "outputs": [], + "source": [ + "# creating a xr.Dataset with the rest\n", + "pop_inh_remain = (\n", + " pop_inh.loc[(slice(None), range(1950, 2021)), :]\n", + " .index.get_level_values(\"ccode\")\n", + " .unique()\n", + ")\n", + "pop_inh_remain = np.setdiff1d(\n", + " pop_inh_remain, pop_cleaned.index.get_level_values(\"ccode\").unique()\n", + ")\n", + "pop_inh_remain = np.setdiff1d(pop_inh_remain, [\"CHI\", \"FRA+OV\", \"XKX\", \"GGY+JEY\"])\n", + "pop_inh_rem = pop_inh.loc[(pop_inh_remain, range(1950, 2021)), [\"pop\", \"un_pop\"]].copy()\n", + "pop_inh_rem_ds = xr.Dataset.from_dataframe(pop_inh_rem)\n", + "\n", + "# smooth_fill\n", + "pop_inh_rem_filled = ypk_fn.smooth_fill(\n", + " pop_inh_rem_ds[\"pop\"], pop_inh_rem_ds[\"un_pop\"], time_dim=\"year\", other_dim=\"ccode\"\n", + ").to_dataframe()\n", + "\n", + "pop_inh_rem_filled = pop_inh_rem_filled.merge(\n", + " pop_inh_rem[[\"pop\"]].rename(columns={\"pop\": \"pop_source\"}),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "pop_inh_rem_filled.loc[~pd.isnull(pop_inh_rem_filled.pop_source), \"pop_source\"] = \"PWT\"\n", + "pop_inh_rem_filled.loc[pd.isnull(pop_inh_rem_filled.pop_source), \"pop_source\"] = \"UN\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7eaa3eb-a03c-4de1-b980-9f4787809d00", + "metadata": {}, + "outputs": [], + "source": [ + "# concatenating with the rest\n", + "pop_cleaned = pd.concat([pop_cleaned, pop_inh_rem_filled], axis=0).sort_index()\n", + "pop_cleaned[\"pop_unit\"] = \"millions (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "3a08fd44-c5a8-4dd5-93d2-c67dd47a6e9c", + "metadata": {}, + "source": [ + "## Historical GDPpc (1950-2019), constant 2017 PPP USD, creating a single sequence\n", + "\n", + "We will first work with the constant 2017 PPP USD (i.e., ones with the `rgdpna` in their names), then create current PPP 2017 USD versions appropriately (in accordance with `cgdpo`). We will work with **per capita** version for extrapolation. But before working on the entire set of countries, I will first set aside France (due to the territory-inclusion problem mentioned above), work with the other countries (including the 5 French overseas territories), and return to the French case to subtract the sum of GDP values from the said territories to acquire the mainland French GDP (and GDPpc).\n", + "\n", + "### Setting aside the no-population cases" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a540d28c-89ce-4aae-a0ef-2d724bc04b75", + "metadata": {}, + "outputs": [], + "source": [ + "y_uninh = gp_df.loc[(sset.UNINHABITED_ISOS, range(1950, 2021)), [\"rgdpna\"]].rename(\n", + " columns={\"rgdpna\": \"rgdpna_pc\"}\n", + ")\n", + "y_uninh[\"rgdpna_pc\"] = 0\n", + "y_uninh[\"gdp_source\"] = \"uninhabited\"" + ] + }, + { + "cell_type": "markdown", + "id": "fc2393b4-f1a9-4dec-b882-5ae8dab6e837", + "metadata": {}, + "source": [ + "### Using World Bank information to fill in for PWT\n", + "\n", + "Both `rgdpna_pc` and `wb_rgdpna_pc` are in ones of constant 2017 PPP USD; we will use the `smooth_fill` function in `ypk_settings.py`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ffbee04b-e8a8-47d0-8822-8dcb74f5f75b", + "metadata": {}, + "outputs": [], + "source": [ + "gp_df[\"rgdpna_pc\"] = gp_df[\"rgdpna\"] / gp_df[\"pop\"]\n", + "y_xr_pwt_wb = xr.Dataset.from_dataframe(\n", + " gp_df.loc[\n", + " ~gp_df.index.get_level_values(\"ccode\").isin(sset.UNINHABITED_ISOS),\n", + " [\"rgdpna_pc\", \"wb_rgdpna_pc\"],\n", + " ]\n", + ")\n", + "\n", + "# filling in rgdpna_pc using wb_rgdpna_pc\n", + "y_pwt_wb = ypk_fn.smooth_fill(\n", + " y_xr_pwt_wb[\"rgdpna_pc\"],\n", + " y_xr_pwt_wb[\"wb_rgdpna_pc\"],\n", + " time_dim=\"year\",\n", + " other_dim=\"ccode\",\n", + ").to_dataframe()\n", + "y_pwt_clean = y_pwt_wb.loc[\n", + " y_pwt_wb.index.get_level_values(\"year\").isin(range(1950, 2021)), :\n", + "].copy()\n", + "\n", + "# filling in the source information\n", + "y_pwt_clean = y_pwt_clean.merge(\n", + " gp_df[[\"rgdpna_pc\", \"wb_rgdpna_pc\"]].rename(columns={\"rgdpna_pc\": \"gdp_source\"}),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean.loc[~pd.isnull(y_pwt_clean.gdp_source), \"gdp_source\"] = \"PWT\"\n", + "y_pwt_clean.loc[\n", + " pd.isnull(y_pwt_clean.gdp_source) & ~pd.isnull(y_pwt_clean.wb_rgdpna_pc),\n", + " \"gdp_source\",\n", + "] = \"WB\"\n", + "y_pwt_clean.drop([\"wb_rgdpna_pc\"], axis=1, inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "bd2dbdaa-8363-4286-8ba8-616fe9d87038", + "metadata": {}, + "source": [ + "### Using IMF information to fill in for PWT\n", + "\n", + "According to this [link](https://www.imf.org/external/pubs/ft/weo/faq.htm#q4d) talking about the PPP used by IMF, it is said that IMF WEO's PPP rates are calculated based on ICP's 2017 report. Since the variable description says that this is constant PPP, we will interpret `imf_rgdpna_pc` as being in ones of constant 2017 PPP USD." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ad37852-86d3-4fb6-8423-aba3815dba03", + "metadata": {}, + "outputs": [], + "source": [ + "y_pwt_clean = y_pwt_clean.merge(\n", + " gp_df[[\"imf_rgdpna_pc\"]], how=\"left\", left_index=True, right_index=True\n", + ")\n", + "y_xr_pwt_imf = xr.Dataset.from_dataframe(y_pwt_clean[[\"imf_rgdpna_pc\", \"rgdpna_pc\"]])\n", + "\n", + "# smooth_fill\n", + "y_pwt_imf = ypk_fn.smooth_fill(\n", + " y_xr_pwt_imf[\"rgdpna_pc\"],\n", + " y_xr_pwt_imf[\"imf_rgdpna_pc\"],\n", + " time_dim=\"year\",\n", + " other_dim=\"ccode\",\n", + ").to_dataframe()\n", + "\n", + "# merging\n", + "prev_dict = {\"rgdpna_pc\": \"rgdpna_pc_prev\"}\n", + "y_pwt_clean = y_pwt_clean.rename(columns=prev_dict).merge(\n", + " y_pwt_imf[[\"rgdpna_pc\"]],\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean.loc[\n", + " ~pd.isnull(y_pwt_clean.rgdpna_pc) & pd.isnull(y_pwt_clean.rgdpna_pc_prev),\n", + " \"gdp_source\",\n", + "] = \"IMF\"\n", + "y_pwt_clean.drop([\"rgdpna_pc_prev\", \"imf_rgdpna_pc\"], inplace=True, axis=1)" + ] + }, + { + "cell_type": "markdown", + "id": "a6307aa9-f8b2-4c80-b0a3-80ed15468f3b", + "metadata": {}, + "source": [ + "### Using MPD (Maddison) information to fill in for PWT\n", + "\n", + "MPD data in `mpd_rgdpna_pc` are in **constant 2011 PPP USD**, so we will have to use the PPP conversion rates to change them into constant 2017 PPP USD before using the function `smooth_fill`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d5ddf07-56b9-49f9-ad95-0bee7dd464f5", + "metadata": {}, + "outputs": [], + "source": [ + "# from constant 2011 PPP USD ot constant 2017 PPP USD\n", + "ppp_to_2017 = ypk_fn.ppp_conversion_specific_year(2017, extrap_sim=True)\n", + "ppp_11_to_17 = ppp_to_2017.loc[(slice(None), 2011), :].reset_index()\n", + "ppp_11_to_17.set_index([\"ccode\"], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "be0bc766-59c2-4401-8b04-230934726056", + "metadata": {}, + "source": [ + "We will use the \"neutral assumption\" (i.e., using the conversion rate of 1) and not use the WB conversion rates (and **only use PWT conversion rates**) due to there being a big discrepancy between the two measures." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfe04dd1-d613-4940-8b7d-bb0d3a247d0f", + "metadata": {}, + "outputs": [], + "source": [ + "# applying the conversion\n", + "y_pwt_clean = y_pwt_clean.merge(\n", + " gp_df[[\"mpd_rgdpna_pc\"]].merge(\n", + " ppp_11_to_17[[\"conv\"]], left_index=True, right_index=True, how=\"left\"\n", + " ),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean.loc[pd.isnull(y_pwt_clean.conv), \"conv\"] = 1\n", + "y_pwt_clean[\"mpd_rgdpna_pc\"] *= y_pwt_clean[\"conv\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70b803df-f787-4282-af14-00fa6aa4d936", + "metadata": {}, + "outputs": [], + "source": [ + "# smooth_fill\n", + "y_xr_pwt_mpd = xr.Dataset.from_dataframe(y_pwt_clean[[\"mpd_rgdpna_pc\", \"rgdpna_pc\"]])\n", + "y_pwt_mpd = ypk_fn.smooth_fill(\n", + " y_xr_pwt_mpd[\"rgdpna_pc\"],\n", + " y_xr_pwt_mpd[\"mpd_rgdpna_pc\"],\n", + " time_dim=\"year\",\n", + " other_dim=\"ccode\",\n", + ").to_dataframe()\n", + "\n", + "# merging\n", + "y_pwt_clean = y_pwt_clean.rename(columns=prev_dict).merge(\n", + " y_pwt_mpd[[\"rgdpna_pc\"]],\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean.loc[\n", + " ~pd.isnull(y_pwt_clean.rgdpna_pc) & pd.isnull(y_pwt_clean.rgdpna_pc_prev),\n", + " \"gdp_source\",\n", + "] = \"MPD\"\n", + "y_pwt_clean.drop([\"rgdpna_pc_prev\", \"mpd_rgdpna_pc\", \"conv\"], inplace=True, axis=1)" + ] + }, + { + "cell_type": "markdown", + "id": "6ae0dd96-d834-4bcb-be56-76718fd0276c", + "metadata": {}, + "source": [ + "### Using OECD regional data to fill in for PWT\n", + "\n", + "OECD information is in constant 2015 PPP USD, so we will change accordingly before using `smooth_fill`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa576943-47cd-4389-ac90-a87a66633331", + "metadata": {}, + "outputs": [], + "source": [ + "# from constant 2015 PPP USD to constant 2017 PPP USD\n", + "ppp_15_to_17 = ppp_to_2017.loc[(slice(None), 2015), :].reset_index()\n", + "ppp_15_to_17.set_index([\"ccode\"], inplace=True)\n", + "\n", + "# applying the conversion\n", + "y_pwt_clean = y_pwt_clean.merge(\n", + " gp_df[[\"oecd_rgdpna\"]].merge(\n", + " ppp_15_to_17[[\"conv\"]], left_index=True, right_index=True, how=\"left\"\n", + " ),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean = y_pwt_clean.merge(\n", + " pop_cleaned[[\"pop\"]], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "y_pwt_clean.loc[pd.isnull(y_pwt_clean.conv), \"conv\"] = 1\n", + "y_pwt_clean[\"oecd_rgdpna_pc\"] = (\n", + " y_pwt_clean[\"oecd_rgdpna\"] / y_pwt_clean[\"pop\"] * y_pwt_clean[\"conv\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a9d4578c-5768-41b9-9c31-ba3ad022904f", + "metadata": {}, + "outputs": [], + "source": [ + "# smooth_fill\n", + "y_xr_pwt_oecd = xr.Dataset.from_dataframe(y_pwt_clean[[\"oecd_rgdpna_pc\", \"rgdpna_pc\"]])\n", + "y_pwt_oecd = ypk_fn.smooth_fill(\n", + " y_xr_pwt_oecd[\"rgdpna_pc\"],\n", + " y_xr_pwt_oecd[\"oecd_rgdpna_pc\"],\n", + " time_dim=\"year\",\n", + " other_dim=\"ccode\",\n", + ").to_dataframe()\n", + "\n", + "# merging\n", + "y_pwt_clean = y_pwt_clean.rename(columns=prev_dict).merge(\n", + " y_pwt_oecd[[\"rgdpna_pc\"]],\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean.loc[\n", + " ~pd.isnull(y_pwt_clean.rgdpna_pc) & pd.isnull(y_pwt_clean.rgdpna_pc_prev),\n", + " \"gdp_source\",\n", + "] = \"OECD\"\n", + "y_pwt_clean.drop(\n", + " [\"rgdpna_pc_prev\", \"oecd_rgdpna_pc\", \"oecd_rgdpna\", \"conv\"], inplace=True, axis=1\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e9939f3a-586a-48ae-b314-c6fa54d47f91", + "metadata": {}, + "source": [ + "### Using CIA information to fill in for PWT\n", + "\n", + "CIA information (`cia_rgdpna`) is in constant 2017 PPP USD, so we will use this as is." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cbb4e74b-0e07-4c55-9e74-801215545b04", + "metadata": {}, + "outputs": [], + "source": [ + "# CIA rgdpna\n", + "y_pwt_clean = y_pwt_clean.merge(\n", + " gp_df[[\"cia_rgdpna\"]], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "y_pwt_clean[\"cia_rgdpna\"] /= y_pwt_clean[\"pop\"]\n", + "y_pwt_clean.rename(columns={\"cia_rgdpna\": \"cia_rgdpna_pc\"}, inplace=True)\n", + "\n", + "# interpolating\n", + "cia_y_ccode = (\n", + " y_pwt_clean.loc[~pd.isnull(y_pwt_clean.cia_rgdpna_pc), :]\n", + " .index.get_level_values(\"ccode\")\n", + " .unique()\n", + ")\n", + "cc_dfs = []\n", + "for cc in tqdm(cia_y_ccode):\n", + " cc_df = y_pwt_clean.loc[cc, [\"cia_rgdpna_pc\"]]\n", + " cc_yrs = (\n", + " cc_df.loc[~pd.isnull(cc_df.cia_rgdpna_pc), :]\n", + " .index.get_level_values(\"year\")\n", + " .unique()\n", + " )\n", + " cc_filled = range(cc_yrs.min(), cc_yrs.max() + 1)\n", + " cc_filled_vals = np.exp(\n", + " np.interp(cc_filled, cc_yrs, np.log(cc_df.loc[cc_yrs, \"cia_rgdpna_pc\"].values))\n", + " )\n", + " cc_dfs.append(\n", + " pd.DataFrame(\n", + " data={\n", + " \"ccode\": [cc] * len(cc_filled),\n", + " \"year\": cc_filled,\n", + " \"cia_rgdpna_pc_interp\": cc_filled_vals,\n", + " }\n", + " )\n", + " )\n", + "cc_dfs = pd.concat(cc_dfs, axis=0).set_index([\"ccode\", \"year\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b376750f-faaf-46eb-a28a-0b97862f1574", + "metadata": {}, + "outputs": [], + "source": [ + "# smooth_fill\n", + "y_pwt_clean = y_pwt_clean.merge(cc_dfs, left_index=True, right_index=True, how=\"outer\")\n", + "y_xr_pwt_cia = xr.Dataset.from_dataframe(\n", + " y_pwt_clean[[\"cia_rgdpna_pc_interp\", \"rgdpna_pc\"]]\n", + ")\n", + "y_pwt_cia = ypk_fn.smooth_fill(\n", + " y_xr_pwt_cia[\"rgdpna_pc\"],\n", + " y_xr_pwt_cia[\"cia_rgdpna_pc_interp\"],\n", + " time_dim=\"year\",\n", + " other_dim=\"ccode\",\n", + ").to_dataframe()\n", + "\n", + "# merging\n", + "y_pwt_clean = y_pwt_clean.rename(columns=prev_dict).merge(\n", + " y_pwt_cia[[\"rgdpna_pc\"]],\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_pwt_clean.loc[\n", + " ~pd.isnull(y_pwt_clean.cia_rgdpna_pc) & pd.isnull(y_pwt_clean.rgdpna_pc_prev),\n", + " \"gdp_source\",\n", + "] = \"CIA\"\n", + "y_pwt_clean.loc[\n", + " ~pd.isnull(y_pwt_clean.cia_rgdpna_pc_interp)\n", + " & pd.isnull(y_pwt_clean.rgdpna_pc_prev)\n", + " & (y_pwt_clean.gdp_source != \"CIA\"),\n", + " \"gdp_source\",\n", + "] = \"CIA_interp\"\n", + "\n", + "y_pwt_clean.drop(\n", + " [\"rgdpna_pc_prev\", \"cia_rgdpna_pc\", \"cia_rgdpna_pc_interp\"], inplace=True, axis=1\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "1ba71df6-0c9c-4940-a2ae-3ad96cbe7671", + "metadata": {}, + "source": [ + "### Aland Statistics (for `ALA`)\n", + "\n", + "We will extrapolate for the missing years as well, by creating ratios with Finland." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b08daef9-ddf3-446d-bb44-37f87e34daa7", + "metadata": {}, + "outputs": [], + "source": [ + "ala_cgdpo_pc = gp_df.loc[~pd.isnull(gp_df.ala_cgdpo_pc), [\"ala_cgdpo_pc\"]]\n", + "ala_yrs = ala_cgdpo_pc.index.get_level_values(\"year\").unique()\n", + "ala_ppp_val = ppp_to_2017.loc[(\"ALA\", ala_yrs), \"conv\"].values\n", + "y_pwt_clean.loc[(\"ALA\", ala_yrs), \"rgdpna_pc\"] = (\n", + " ala_ppp_val * ala_cgdpo_pc.ala_cgdpo_pc.values\n", + ")\n", + "y_pwt_clean.loc[(\"ALA\", ala_yrs), \"gdp_source\"] = \"ALAND_STAT\"\n", + "\n", + "# ratio wrt Finland\n", + "ala_fin_ratio = (\n", + " y_pwt_clean.loc[(\"ALA\", ala_yrs), \"rgdpna_pc\"].values\n", + " / y_pwt_clean.loc[(\"FIN\", ala_yrs), \"rgdpna_pc\"].values\n", + ").mean()\n", + "ala_noyrs = np.setdiff1d(list(range(1950, 2021)), ala_yrs)\n", + "y_pwt_clean.loc[(\"ALA\", ala_noyrs), \"rgdpna_pc\"] = (\n", + " ala_fin_ratio * y_pwt_clean.loc[(\"FIN\", ala_noyrs), \"rgdpna_pc\"].values\n", + ")\n", + "y_pwt_clean.loc[(\"ALA\", ala_noyrs), \"gdp_source\"] = \"FIN_extrap\"" + ] + }, + { + "cell_type": "markdown", + "id": "8a88edfa-edb6-4cb7-a3af-1c6fd35c24e0", + "metadata": {}, + "source": [ + "### Treadgold Reports on Norfolk Island (for `NFK`)\n", + "\n", + "We will extrapolate for the missing years as well, by creating ratios with Australia (`AUS`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27f97b8b-d7c5-4fa1-bd83-a655d8ab998f", + "metadata": {}, + "outputs": [], + "source": [ + "tgold_rgdpna_pc = gp_df.loc[\n", + " ~pd.isnull(gp_df.treadgold_rgdpna_pc), [\"treadgold_rgdpna_pc\"]\n", + "]\n", + "tgold_yrs = tgold_rgdpna_pc.index.get_level_values(\"year\").unique()\n", + "tgold_interp_yrs = list(range(tgold_yrs.min(), tgold_yrs.max() + 1))\n", + "tgold_interp_vals = np.exp(\n", + " np.interp(\n", + " tgold_interp_yrs, tgold_yrs, np.log(tgold_rgdpna_pc.treadgold_rgdpna_pc.values)\n", + " )\n", + ")\n", + "y_pwt_clean.loc[(\"NFK\", tgold_interp_yrs), \"rgdpna_pc\"] = tgold_interp_vals\n", + "y_pwt_clean.loc[(\"NFK\", tgold_interp_yrs), \"gdp_source\"] = \"Treadgold_ratio_PWT\"\n", + "\n", + "# calculating the ratios separately\n", + "nfk_aus_ratio_early = (\n", + " y_pwt_clean.loc[(\"NFK\", tgold_interp_yrs[0:2]), \"rgdpna_pc\"].values\n", + " / y_pwt_clean.loc[(\"AUS\", tgold_interp_yrs[0:2]), \"rgdpna_pc\"].values\n", + ").mean()\n", + "\n", + "nfk_aus_ratio_later = (\n", + " y_pwt_clean.loc[(\"NFK\", tgold_interp_yrs[-2:]), \"rgdpna_pc\"].values\n", + " / y_pwt_clean.loc[(\"AUS\", tgold_interp_yrs[-2:]), \"rgdpna_pc\"].values\n", + ").mean()\n", + "\n", + "y_pwt_clean.loc[(\"NFK\", 1950), \"rgdpna_pc\"] = (\n", + " nfk_aus_ratio_early * y_pwt_clean.loc[(\"AUS\", 1950), \"rgdpna_pc\"]\n", + ")\n", + "nfk_noyrs = np.setdiff1d(list(range(1951, 2021)), tgold_interp_yrs)\n", + "y_pwt_clean.loc[(\"NFK\", nfk_noyrs), \"rgdpna_pc\"] = (\n", + " nfk_aus_ratio_later * y_pwt_clean.loc[(\"AUS\", nfk_noyrs), \"rgdpna_pc\"].values\n", + ")\n", + "y_pwt_clean.loc[(\"NFK\", [1950] + list(nfk_noyrs)), \"gdp_source\"] = \"AUS_extrap\"" + ] + }, + { + "cell_type": "markdown", + "id": "24f26479-9598-423a-843f-628f5df94be7", + "metadata": {}, + "source": [ + "### Statistics Netherlands information on `BES`\n", + "\n", + "Nominal GDP for Bonaire, Saba, and Eustatius are shown separately (for the years 2012 and 2017, on this [Statistics Netherlands file](https://www.cbs.nl/en-gb/publication/2020/41/trends-in-the-caribbean-netherlands-2020)). We will add them together, interpolate, and create ratios with the Netherlands information to fill in the missing pieces as well." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad2eba56-9286-4c3e-8f92-a59ba9a70e7d", + "metadata": {}, + "outputs": [], + "source": [ + "# numbers correspond to GDP for Bonaire, Saba, and Eustatius (in mil. of nominal USD)\n", + "bes_yrs = list(range(2012, 2018))\n", + "bes_2012, bes_2017 = 372 + 42 + 101, 428 + 47 + 108\n", + "bes_pc_12_17 = (\n", + " np.array([bes_2012, bes_2017])\n", + " / pop_cleaned.loc[(\"BES\", [2012, 2017]), \"pop\"].values\n", + ")\n", + "\n", + "bes_ratio = bes_pc_12_17 / gp_df.loc[(\"NLD\", [2012, 2017]), \"wb_gdp_nom_pc\"].values\n", + "bes_avg_ratio = bes_ratio.mean()\n", + "bes_ppp_pc_12_17 = (\n", + " bes_ratio * y_pwt_clean.loc[(\"NLD\", [2012, 2017]), \"rgdpna_pc\"].values\n", + ")\n", + "bes_ppp_pc_12_17_interp = np.exp(\n", + " np.interp(bes_yrs, [2012, 2017], np.log(bes_ppp_pc_12_17))\n", + ")\n", + "bes_noyrs = np.setdiff1d(list(range(1950, 2021)), bes_yrs)\n", + "bes_ppp_pc_not12_17 = (\n", + " y_pwt_clean.loc[(\"NLD\", bes_noyrs), \"rgdpna_pc\"].values * bes_avg_ratio\n", + ")\n", + "y_pwt_clean.loc[(\"BES\", bes_yrs), \"rgdpna_pc\"] = bes_ppp_pc_12_17_interp\n", + "y_pwt_clean.loc[(\"BES\", bes_yrs), \"gdp_source\"] = \"NLD_STAT\"\n", + "y_pwt_clean.loc[(\"BES\", bes_noyrs), \"rgdpna_pc\"] = bes_ppp_pc_not12_17\n", + "y_pwt_clean.loc[(\"BES\", bes_noyrs), \"gdp_source\"] = \"NLD_extrap\"" + ] + }, + { + "cell_type": "markdown", + "id": "609b4e3a-c764-467d-bc33-06004eb8e55f", + "metadata": {}, + "source": [ + "### Information from CEROM, Saint Barthelemy (for `BLM`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8ceaa0c-0553-4f36-add2-39338623428d", + "metadata": {}, + "outputs": [], + "source": [ + "# getting the nominal values\n", + "cerom = gp_df.loc[\"BLM\", [\"cerom_gdppc\"]]\n", + "cerom_yrs = cerom.loc[~pd.isnull(cerom.cerom_gdppc), :].index.values\n", + "cerom_vals = cerom.loc[~pd.isnull(cerom.cerom_gdppc), \"cerom_gdppc\"].values\n", + "\n", + "# ratio with the nominal, french gdppc\n", + "blm_ratio = cerom_vals / gp_df.loc[(\"FRA\", cerom_yrs), \"wb_gdp_nom_pc\"].values\n", + "blm_y_vals = blm_ratio * y_pwt_clean.loc[(\"FRA\", cerom_yrs), \"rgdpna_pc\"].values\n", + "blm_interp_yrs = list(range(cerom_yrs.min(), cerom_yrs.max() + 1))\n", + "y_pwt_clean.loc[(\"BLM\", blm_interp_yrs), \"rgdpna_pc\"] = np.exp(\n", + " np.interp(blm_interp_yrs, cerom_yrs, np.log(blm_y_vals))\n", + ")\n", + "\n", + "# rest of the years\n", + "blm_noyrs = np.setdiff1d(list(range(1950, 2021)), blm_interp_yrs)\n", + "y_pwt_clean.loc[(\"BLM\", blm_noyrs), \"rgdpna_pc\"] = (\n", + " y_pwt_clean.loc[(\"FRA\", blm_noyrs), \"rgdpna_pc\"].values * blm_ratio.mean()\n", + ")\n", + "\n", + "y_pwt_clean.loc[(\"BLM\", blm_noyrs), \"gdp_source\"] = \"FRA_extrap\"\n", + "y_pwt_clean.loc[(\"BLM\", blm_interp_yrs), \"gdp_source\"] = \"CEROM\"" + ] + }, + { + "cell_type": "markdown", + "id": "40e83fd6-f861-445d-b68a-7d782d6e46b1", + "metadata": {}, + "source": [ + "### Australian Census from information (for `CCK` and `CXR`)\n", + "\n", + "Again, we only have nominal GDP of these areas in the year 2010 as nominal terms. Therefore, we will again rely on the scale with the relevant sovereignty (being `AUS`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e5dc8b3-87d9-46ff-b0dd-96a45474319a", + "metadata": {}, + "outputs": [], + "source": [ + "# ratios in 2010\n", + "aus_2010 = gp_df.loc[(\"AUS\", 2010), \"wb_gdp_nom_pc\"]\n", + "cxr_2010 = (\n", + " gp_df.loc[(\"CXR\", 2010), \"aus_census_nom_gdp\"]\n", + " / pop_cleaned.loc[(\"CXR\", 2010), \"pop\"]\n", + ")\n", + "cck_2010 = (\n", + " gp_df.loc[(\"CCK\", 2010), \"aus_census_nom_gdp\"]\n", + " / pop_cleaned.loc[(\"CCK\", 2010), \"pop\"]\n", + ")\n", + "cxr_aus_r, cck_aus_r = cxr_2010 / aus_2010, cck_2010 / aus_2010\n", + "\n", + "# apply the ratios\n", + "cxr_vals = y_pwt_clean.loc[(\"AUS\", range(1950, 2021)), \"rgdpna_pc\"].values * cxr_aus_r\n", + "cck_vals = y_pwt_clean.loc[(\"AUS\", range(1950, 2021)), \"rgdpna_pc\"].values * cck_aus_r\n", + "y_pwt_clean.loc[(\"CXR\", list(range(1950, 2021))), \"rgdpna_pc\"] = cxr_vals\n", + "y_pwt_clean.loc[(\"CCK\", list(range(1950, 2021))), \"rgdpna_pc\"] = cck_vals\n", + "\n", + "# sources\n", + "y_pwt_clean.loc[(\"CXR\", list(range(1950, 2021))), \"gdp_source\"] = \"AUS_extrap\"\n", + "y_pwt_clean.loc[(\"CCK\", list(range(1950, 2021))), \"gdp_source\"] = \"AUS_extrap\"\n", + "y_pwt_clean.loc[(\"CCK\", 2010), \"gdp_source\"] = \"AUS_parliament\"\n", + "y_pwt_clean.loc[(\"CXR\", 2010), \"gdp_source\"] = \"AUS_parliament\"" + ] + }, + { + "cell_type": "markdown", + "id": "b4345fd2-cb31-438d-a818-74fc5bf8ff58", + "metadata": {}, + "source": [ + "### Svalbard and Jan Mayen (`SJM`)\n", + "\n", + "As mentioned above, we do not have reliable metrics for GDPpc or GDP for `SJM`; so we will copy Norway's information." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5abaecc-9a4d-457e-b422-8616589b3b7f", + "metadata": {}, + "outputs": [], + "source": [ + "y_pwt_clean.loc[(\"SJM\", list(range(1950, 2021))), \"rgdpna_pc\"] = y_pwt_clean.loc[\n", + " (\"NOR\", list(range(1950, 2021))), \"rgdpna_pc\"\n", + "].values\n", + "y_pwt_clean.loc[\"SJM\", \"gdp_source\"] = \"NOR_copy\"" + ] + }, + { + "cell_type": "markdown", + "id": "006668cf-515a-447e-8d44-674e73f50042", + "metadata": {}, + "source": [ + "### United States Minor Outlying Islands (`UMI`)\n", + "\n", + "We will use the most similar U.S. territory, which are the Northern Mariana Islands (`MNP`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b225f80a-5f87-4087-a0b4-91dbcacdf812", + "metadata": {}, + "outputs": [], + "source": [ + "mnp = y_pwt_clean.loc[\"MNP\", :].copy()\n", + "mnpyrs = np.unique(mnp.loc[~pd.isnull(mnp.rgdpna_pc), :].index.get_level_values(\"year\"))\n", + "y_pwt_clean.loc[(\"UMI\", mnpyrs), \"rgdpna_pc\"] = y_pwt_clean.loc[\n", + " (\"MNP\", mnpyrs), \"rgdpna_pc\"\n", + "].values\n", + "y_pwt_clean.loc[(\"UMI\", mnpyrs), \"gdp_source\"] = \"MNP_copy\"" + ] + }, + { + "cell_type": "markdown", + "id": "611c5d6d-207a-45be-9c67-593ea7dbdbbb", + "metadata": {}, + "source": [ + "### Pitcairn Island (`PCN`): take the ratio with `GBR`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5b0e79a-2632-4c69-b1c3-85d0b14b81be", + "metadata": {}, + "outputs": [], + "source": [ + "pcn_ratio = (\n", + " gp_df.loc[(\"PCN\", 2006), \"pcn_nom_gdp\"]\n", + " / y_pwt_clean.loc[(\"PCN\", 2006), \"pop\"]\n", + " / gp_df.loc[(\"GBR\", 2006), \"wb_gdp_nom_pc\"]\n", + ")\n", + "pcn_rgdpna_pc = (\n", + " pcn_ratio * y_pwt_clean.loc[(\"GBR\", list(range(1950, 2021))), \"rgdpna_pc\"].values\n", + ")\n", + "y_pwt_clean.loc[(\"PCN\", list(range(1950, 2021))), \"rgdpna_pc\"] = pcn_rgdpna_pc\n", + "y_pwt_clean.loc[\"PCN\", \"gdp_source\"] = \"GBR_ratio\"" + ] + }, + { + "cell_type": "markdown", + "id": "d4c6190b-ca86-4b13-b66b-1cf700de4077", + "metadata": {}, + "source": [ + "### Cleaning up for other territories (current and former)\n", + "\n", + "In general, the reason for assigning country-sovereignty ratios instead of that between similar countries is based on the argument in [**Bertram (World Development, 2003)**](https://www.sciencedirect.com/science/article/abs/pii/S0305750X03002134) that territories (or island economies in the paper, to be more specific) seem to converge to trend with their metropolitan patrons more so than similar territory (island) economies. Based on this idea, we will fill in the missing years' GDPpc data with the nearest 5-year average (e.g., if years before 2000 are missing, use the country-sovereignty GDPpc ratio from 2000-2005 [averaged] to extrapolate for the missing years).\n", + "\n", + "Following territory-sovereignty relationships are considered (excluding the ones dealt with above, but including *previous* territory-sovereignty relationships mentioned in Bertram (2003)). Note that if they are already all filled (1950-2020), they will not be further extrapolated, and for the former territories, year in parentheses is that of gaining independence:\n", + "- Current `GBR`: `IMN`, `JEY`, `GGY`, `AIA`, `BMU`, `IOT`, `VGB`, `CYM`, `FLK`, `GIB`, `MSR`, `SHN`, `TCA`\n", + "- Former `GBR`: `VCT` (1979), `DMA` (1976), `GRD` (1974), `KNA` (1983), `ATG` (1981), `BHS` (1973), `MDV` (1966), `KIR` (1979), `TUV` (1978), `SLB` (1978), `TON` (1970), `FJI` (1970), `VUT` (1980; also managed by `FRA`)\n", + "- Current `FRA`: `GUF`, `GLP`, `MTQ`, `MYT`, `REU`, `SPM`, `MAF`, `BLM`, `PYF`, `WLF`, `NCL`\n", + "- Former `FRA`: `COM` (1975)\n", + "- Current `NLD`: `SXM`, `ABW`, `BES`, `CUW`\n", + "- Current `DNK`: `GRL`, `FRO`\n", + "- Current `NZL`: `NIU`, `WSM`, `COK`, `TKL`\n", + "- Current `USA`: `VIR`, `GUM`, `UMI`, `ASM`\n", + "- Former `USA` (including Free Association): `MHL`, `FSM`, `PLW`\n", + "- Former `AUS`: `NRU`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91aba98b-7426-4eec-8aed-0203af0d9d85", + "metadata": {}, + "outputs": [], + "source": [ + "def fill_using_simple_ratio(\n", + " terr_code, sov_code, df, col=\"rgdpna_pc\", source_col=\"gdp_source\"\n", + "):\n", + " \"\"\"Fill the missing values of the country denoted by `terr_code` using the average\n", + " ratio of nearest known values (at most 5 years) between the countries `terr_code`\n", + " and `sov_code`. This is based on the observation in Bertram (World Development,\n", + " 2003) that GDPpc of (island) territories tend to converge to sovereign GDPpc.\n", + "\n", + " Parameters\n", + " ----------\n", + " terr_code : str\n", + " country code for country/region that belongs to or was associated with the\n", + " country/region represented by `sov_code`\n", + " sov_code : str\n", + " country code for country/region that had or still has legal control over the\n", + " country/region represented by `terr_code`\n", + " df : pandas.DataFrame\n", + " that contains the country/region-level information; should have the columns\n", + " `col` and `source_col`, and be multi-indexed by `ccode` and `year` (denoting\n", + " country code and year)\n", + " col : str\n", + " column containing data that needs imputation/extrapolation (by using the ratio\n", + " of values from the two countries)\n", + " source_col : str\n", + " column containing source data, to be filled with basic information about which\n", + " country information (`sov_code`) was used to conduct the\n", + " imputation/extrapolation\n", + "\n", + " Returns\n", + " -------\n", + " df : pandas.DataFrame\n", + " containing the original information from the pre-modified `df` and the newly\n", + " imputed/extrapolated information\n", + "\n", + " \"\"\"\n", + " ALL_YRS = list(range(1950, 2021))\n", + " msng = (\n", + " df.loc[\n", + " pd.isnull(df[col]) & (df.index.get_level_values(\"ccode\") == terr_code), :\n", + " ]\n", + " .index.get_level_values(\"year\")\n", + " .unique()\n", + " )\n", + "\n", + " if len(msng) == 0:\n", + " return df\n", + "\n", + " filled = np.sort(np.setdiff1d(ALL_YRS, msng))\n", + "\n", + " if ALL_YRS[-1] in msng:\n", + " # years to create averages from\n", + " years = filled[-5:]\n", + "\n", + " # which years to extrapolate?\n", + " to_fill = msng[msng > filled[-1]]\n", + " avg_ratio = (\n", + " df.loc[(terr_code, years), col].values\n", + " / df.loc[(sov_code, years), col].values\n", + " ).mean()\n", + " df.loc[(terr_code, to_fill), col] = (\n", + " avg_ratio * df.loc[(sov_code, to_fill), col].values\n", + " )\n", + "\n", + " if ALL_YRS[0] in msng:\n", + " # years to create averages from\n", + " years = filled[0:5]\n", + "\n", + " # which years to extrapolate?\n", + " to_fill = msng[msng < filled[0]]\n", + " avg_ratio = (\n", + " df.loc[(terr_code, years), col].values\n", + " / df.loc[(sov_code, years), col].values\n", + " ).mean()\n", + " df.loc[(terr_code, to_fill), col] = (\n", + " avg_ratio * df.loc[(sov_code, to_fill), col].values\n", + " )\n", + "\n", + " df.loc[(terr_code, msng), source_col] = \"{}_extrap\".format(sov_code)\n", + "\n", + " return df" + ] + }, + { + "cell_type": "markdown", + "id": "6f4880f3-6a64-43d9-a243-a9204f048b2a", + "metadata": {}, + "source": [ + "#### `GBR` Territories (former and current)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14ee6dc9-5484-40d6-967b-b1edb4428566", + "metadata": {}, + "outputs": [], + "source": [ + "current_terr_gbr = [\n", + " \"IMN\",\n", + " \"JEY\",\n", + " \"GGY\",\n", + " \"AIA\",\n", + " \"BMU\",\n", + " \"VGB\",\n", + " \"CYM\",\n", + " \"FLK\",\n", + " \"GIB\",\n", + " \"MSR\",\n", + " \"SHN\",\n", + " \"TCA\",\n", + "]\n", + "former_terr_gbr = [\n", + " \"VCT\",\n", + " \"DMA\",\n", + " \"GRD\",\n", + " \"KNA\",\n", + " \"ATG\",\n", + " \"BHS\",\n", + " \"MDV\",\n", + " \"KIR\",\n", + " \"TUV\",\n", + " \"SLB\",\n", + " \"TON\",\n", + " \"FJI\",\n", + " \"VUT\",\n", + "]\n", + "for i in former_terr_gbr + current_terr_gbr:\n", + " y_pwt_clean = fill_using_simple_ratio(i, \"GBR\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "333e0acd-f5fd-4b4b-85a7-4e59012d2bae", + "metadata": {}, + "source": [ + "#### `FRA` Territories (former and current)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3e6cdbe-f826-43f6-97ac-5d807ece7f8e", + "metadata": {}, + "outputs": [], + "source": [ + "current_terr_fra = [\n", + " \"GUF\",\n", + " \"GLP\",\n", + " \"MTQ\",\n", + " \"MYT\",\n", + " \"REU\",\n", + " \"SPM\",\n", + " \"MAF\",\n", + " \"BLM\",\n", + " \"PYF\",\n", + " \"WLF\",\n", + " \"NCL\",\n", + "]\n", + "former_terr_fra = [\"COM\"]\n", + "for i in former_terr_fra + current_terr_fra:\n", + " y_pwt_clean = fill_using_simple_ratio(i, \"FRA\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "2980b4e3-8d34-4a6f-a60a-461076286148", + "metadata": {}, + "source": [ + "#### `NLD` Territories (current)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0ef855c-84f9-4204-86d4-a0aeee03e127", + "metadata": {}, + "outputs": [], + "source": [ + "current_terr_nld = [\"SXM\", \"ABW\", \"BES\", \"CUW\"]\n", + "for i in current_terr_nld:\n", + " y_pwt_clean = fill_using_simple_ratio(i, \"NLD\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "7176add7-9255-44c8-9368-48eddbabd5b1", + "metadata": {}, + "source": [ + "#### `DNK` Territories (current)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb397fca-3822-49a7-9f48-9a3cab267cf9", + "metadata": {}, + "outputs": [], + "source": [ + "former_terr_prt = [\"GRL\", \"FRO\"]\n", + "for i in former_terr_prt:\n", + " y_pwt_clean = fill_using_simple_ratio(i, \"DNK\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "ebaf28e0-9208-45d1-bb67-b4e222955a78", + "metadata": {}, + "source": [ + "#### `NZL` Territories (current)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecbcd811-456a-4ede-9016-ec6f03e5f8aa", + "metadata": {}, + "outputs": [], + "source": [ + "current_terr_nzl = [\"NIU\", \"WSM\", \"COK\", \"TKL\"]\n", + "for i in current_terr_nzl:\n", + " y_pwt_clean = fill_using_simple_ratio(i, \"NZL\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "e9886239-c34c-47cd-9abb-1117cc289d0f", + "metadata": {}, + "source": [ + "#### `USA` Territories (former and current)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4cde65fe-66fd-4a4e-85fc-20cb104f7e42", + "metadata": {}, + "outputs": [], + "source": [ + "current_terr_usa = [\"VIR\", \"GUM\", \"UMI\", \"ASM\"]\n", + "former_terr_usa = [\"MHL\", \"FSM\", \"PLW\"]\n", + "for i in former_terr_usa + current_terr_usa:\n", + " y_pwt_clean = fill_using_simple_ratio(i, \"USA\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "c6299b5d-f060-4e1d-acb5-1a4ad27eb0a2", + "metadata": {}, + "source": [ + "#### `AUS` Territories (former)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21238a76-dbc0-4f4a-ade7-644b6d2539c8", + "metadata": {}, + "outputs": [], + "source": [ + "y_pwt_clean = fill_using_simple_ratio(\"NRU\", \"AUS\", y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "190387db-c884-458a-9871-fe91185b388b", + "metadata": {}, + "source": [ + "### City-states, city-territories, or microstates\n", + "\n", + "Will use a similar tactic as above. We match it as follows:\n", + "- `AND`: `FRA`\n", + "- `MCO`: `FRA`\n", + "- `MAC`: `HKG`\n", + "- `VAT`: `ITA`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40fb5aca-b224-434b-b3f3-0e49e39acc03", + "metadata": {}, + "outputs": [], + "source": [ + "micro_to_extrap = [\"AND\", \"MCO\", \"MAC\", \"VAT\"]\n", + "micro_from_extrap = [\"FRA\", \"FRA\", \"HKG\", \"ITA\"]\n", + "for j, i in enumerate(micro_to_extrap):\n", + " y_pwt_clean = fill_using_simple_ratio(i, micro_from_extrap[j], y_pwt_clean)" + ] + }, + { + "cell_type": "markdown", + "id": "cfbf35cf-fe66-4110-8047-50f1bd4554e5", + "metadata": {}, + "source": [ + "### Extrapolating based on similar trends\n", + "\n", + "For the remaining countries, we will detect similar-trending countries and use their average trends to fill in the missing pieces. Note that I will not be using trends from those countries whose information have already been extrapolated using others' trends (e.g., using territory-sovereignty relationship)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29a3b92b-47a3-4d2e-9998-baef9409722f", + "metadata": {}, + "outputs": [], + "source": [ + "## detecting which to extrapolate and which not to\n", + "to_extrap = []\n", + "from_extrap = []\n", + "for i in y_pwt_clean.index.get_level_values(\"ccode\").unique():\n", + " i_sum = pd.isnull(y_pwt_clean.loc[i, \"rgdpna_pc\"].values).sum()\n", + " if i_sum > 0:\n", + " if i not in [\"GGY+JEY\", \"CHI\", \"FRA+OV\"]:\n", + " to_extrap.append(i)\n", + " continue\n", + "\n", + " i_source = np.unique(y_pwt_clean.loc[i, \"gdp_source\"].values)\n", + " i_no_extraped = True\n", + " for sour in i_source:\n", + " if (sour == \"GBR_ratio\") or (\"extrap\" in sour) or (\"copy\" in sour):\n", + " i_no_extraped = False\n", + " break\n", + "\n", + " if i_no_extraped:\n", + " from_extrap.append(i)\n", + "\n", + "exclude_extrap = np.setdiff1d(\n", + " y_pwt_clean.index.get_level_values(\"ccode\").unique(), to_extrap + from_extrap\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7826af8-dd49-4188-900d-1a5a30f12714", + "metadata": {}, + "outputs": [], + "source": [ + "## extrapolation process\n", + "gdppc_extrap = ypk_fn.extrap_using_closest(\n", + " to_extrap,\n", + " ypk_fn.organize_ver_to_hor(\n", + " y_pwt_clean.copy(),\n", + " \"rgdpna_pc\",\n", + " \"year\",\n", + " \"ccode\",\n", + " range(1950, 2021),\n", + " ),\n", + " begin_end=[1950, 2020],\n", + " exclude_these=list(exclude_extrap) + [\"GGY+JEY\", \"CHI\", \"FRA+OV\"],\n", + ")\n", + "gdppc_extrap = ypk_fn.organize_hor_to_ver(\n", + " gdppc_extrap,\n", + " \"ccode\",\n", + " None,\n", + " \"rgdpna_pc_extrap\",\n", + " yrs=range(1950, 2021),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f015af1c-8e0b-4e75-9366-0a4f15a1baf5", + "metadata": {}, + "outputs": [], + "source": [ + "## merging this back to the original dataframe\n", + "y_pwt_clean = y_pwt_clean.merge(\n", + " gdppc_extrap, how=\"left\", left_index=True, right_index=True\n", + ")\n", + "y_pwt_clean.loc[pd.isnull(y_pwt_clean.gdp_source), \"gdp_source\"] = y_pwt_clean.loc[\n", + " pd.isnull(y_pwt_clean.gdp_source), \"msng_fill\"\n", + "].values\n", + "y_pwt_clean.loc[pd.isnull(y_pwt_clean.rgdpna_pc), \"rgdpna_pc\"] = y_pwt_clean.loc[\n", + " pd.isnull(y_pwt_clean.rgdpna_pc), \"rgdpna_pc_extrap\"\n", + "].values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34186be3-64ec-4d26-bf0b-10e9ce2d0a26", + "metadata": {}, + "outputs": [], + "source": [ + "## finalizing the rgdpna_pc series\n", + "y_clean = (\n", + " y_pwt_clean.loc[\n", + " ~y_pwt_clean.index.get_level_values(\"ccode\").isin([\"FRA+OV\", \"GGY+JEY\", \"CHI\"]),\n", + " :,\n", + " ]\n", + " .sort_index()\n", + " .drop([\"rgdpna_pc_extrap\", \"msng_fill\"], axis=1)\n", + ")\n", + "y_clean = pd.concat([y_clean, y_uninh])[[\"rgdpna_pc\", \"gdp_source\"]].sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "8fd1def3-6e60-4875-9586-004e57e28621", + "metadata": {}, + "source": [ + "### Cleaning up for Mainland France\n", + "\n", + "Currently, the values that have been recorded in `rgdpna_pc` for `FRA` are in terms of overall French population (including the 5 overseas departments). Therefore, in order to keep things consistent, we will 1) multiply the overall French population and the overseas departments' populations to get `rgdpna` values, 2) subtract the five overseas departments' `rgdpna` values from overall French `rgdpna`, and 3) divide by the mainland French population to get the mainland-specific `rgdpna_pc` values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f472b53-b065-428f-b0c0-47afc44a5b10", + "metadata": {}, + "outputs": [], + "source": [ + "fra_terr = [\"GUF\", \"GLP\", \"MTQ\", \"MYT\", \"REU\"]\n", + "fra_terr_dfs = y_clean.loc[[\"FRA\"] + fra_terr, :].copy()\n", + "fra_terr_dfs = fra_terr_dfs.merge(\n", + " gp_df.loc[[\"FRA\"], [\"pop\"]], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "fra_terr_dfs.loc[(\"FRA\", 2020), \"pop\"] = (\n", + " fra_terr_dfs.loc[(\"FRA\", 2019), \"pop\"]\n", + " * pop_cleaned.loc[(\"FRA\", 2020), \"pop\"]\n", + " / pop_cleaned.loc[(\"FRA\", 2019), \"pop\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1346a4e-4eb0-4bd6-ab68-463799a5b412", + "metadata": {}, + "outputs": [], + "source": [ + "fra_terr_dfs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "63ef82ee-53ea-4264-a324-dccd6d7133ec", + "metadata": {}, + "outputs": [], + "source": [ + "fra_terr = [\"GUF\", \"GLP\", \"MTQ\", \"MYT\", \"REU\"]\n", + "fra_terr_dfs = y_clean.loc[[\"FRA\"] + fra_terr, :].copy()\n", + "fra_terr_dfs = fra_terr_dfs.merge(\n", + " gp_df.loc[[\"FRA\"], [\"pop\"]], left_index=True, right_index=True, how=\"left\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "749082fa-c1e7-4ff7-b962-d36c74d3a752", + "metadata": {}, + "outputs": [], + "source": [ + "# cleaning up the mainland france\n", + "fra_terr = [\"GUF\", \"GLP\", \"MTQ\", \"MYT\", \"REU\"]\n", + "fra_terr_dfs = y_clean.loc[[\"FRA\"] + fra_terr, :].copy()\n", + "fra_terr_dfs = fra_terr_dfs.merge(\n", + " gp_df.loc[[\"FRA\"], [\"pop\"]], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "fra_terr_dfs.loc[(\"FRA\", 2020), \"pop\"] = (\n", + " fra_terr_dfs.loc[(\"FRA\", 2019), \"pop\"]\n", + " * pop_cleaned.loc[(\"FRA\", 2020), \"pop\"]\n", + " / pop_cleaned.loc[(\"FRA\", 2019), \"pop\"]\n", + ")\n", + "yrs_tgt = list(range(1950, 2021))\n", + "for i in fra_terr:\n", + " fra_terr_dfs.loc[(i, yrs_tgt), \"pop\"] = pop_cleaned.loc[(i, yrs_tgt), \"pop\"].values\n", + "\n", + "fra_terr_dfs[\"rgdpna\"] = fra_terr_dfs[\"rgdpna_pc\"] * fra_terr_dfs[\"pop\"]\n", + "fra_terr_dfs.loc[(\"FRA\", yrs_tgt), \"rgdpna\"] = fra_terr_dfs.loc[\n", + " (\"FRA\", yrs_tgt), \"rgdpna\"\n", + "].values - (\n", + " fra_terr_dfs.loc[fra_terr, [\"rgdpna\"]]\n", + " .reset_index()\n", + " .groupby([\"year\"])\n", + " .sum()\n", + " .rgdpna.values\n", + ")\n", + "\n", + "fra_terr_dfs.loc[(\"FRA\", yrs_tgt), \"pop\"] = pop_cleaned.loc[\n", + " (\"FRA\", yrs_tgt), \"pop\"\n", + "].values\n", + "fra_terr_dfs.loc[(\"FRA\", yrs_tgt), \"rgdpna_pc\"] = (\n", + " fra_terr_dfs.loc[(\"FRA\", yrs_tgt), \"rgdpna\"].values\n", + " / fra_terr_dfs.loc[(\"FRA\", yrs_tgt), \"pop\"].values\n", + ")\n", + "\n", + "# re-attaching with the cleaned GDPpc dataset\n", + "y_clean.loc[(\"FRA\", yrs_tgt), \"rgdpna_pc\"] = fra_terr_dfs.loc[\n", + " (\"FRA\", yrs_tgt), \"rgdpna_pc\"\n", + "].values" + ] + }, + { + "cell_type": "markdown", + "id": "d35137a1-1291-49da-bafe-50b2e357fe8f", + "metadata": {}, + "source": [ + "### Creating GDP (`rgdpna`) values\n", + "\n", + "This will be simpler to execute, by appending the cleaned population dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "935e1f94-d84b-4d49-998a-406411bbbee0", + "metadata": {}, + "outputs": [], + "source": [ + "y_clean = y_clean.merge(pop_cleaned, left_index=True, right_index=True, how=\"left\")\n", + "y_clean[\"gdp_unit\"] = \"millions (PPP USD)\"\n", + "y_clean[\"gdppc_unit\"] = \"ones (PPP USD)\"\n", + "y_clean[\"rgdpna\"] = y_clean[\"rgdpna_pc\"] * y_clean[\"pop\"]" + ] + }, + { + "cell_type": "markdown", + "id": "6bf4e643-5b3d-4689-910e-347675415cca", + "metadata": {}, + "source": [ + "## Filling in the missing values for the `cgdpo` (current PPP 2017 USD) series\n", + "\n", + "### Transforming the `rgdpna_pc` series to `cgdpo_pc` equivalents" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "faeb6e83-bede-4409-ac23-442d90c5e3cd", + "metadata": {}, + "outputs": [], + "source": [ + "y_clean = y_clean.merge(\n", + " ppp_to_2017[[\"conv\"]],\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "## neutral assumption\n", + "y_clean.loc[pd.isnull(y_clean.conv), \"conv\"] = 1\n", + "\n", + "## copying the 2019 conversion to 2020 conversion\n", + "y_clean.loc[(slice(None), 2020), \"conv\"] = y_clean.loc[\n", + " (slice(None), 2019), \"conv\"\n", + "].values\n", + "y_clean[\"cgdpo_pc_equiv\"] = y_clean[\"rgdpna_pc\"] / y_clean[\"conv\"]" + ] + }, + { + "cell_type": "markdown", + "id": "ea9c6aa3-adf5-40d3-91a5-141de81210e9", + "metadata": {}, + "source": [ + "### Attaching the actual `cgdpo` values from PWT, and creating `cgdpo_pc`\n", + "\n", + "In doing so, we will again try to clean up for the issue with French mainland." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f45d4321-855d-474b-8073-dab668ebb4a3", + "metadata": {}, + "outputs": [], + "source": [ + "col_dict = {\"cgdpo\": \"cgdpo_pwt\", \"pop\": \"pop_pwt\"}\n", + "y_clean = y_clean.merge(\n", + " gp_df[[\"cgdpo\", \"pop\"]].rename(columns=col_dict),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "42d48930-c4dc-4ae2-a4e3-27307a45d6c6", + "metadata": {}, + "source": [ + "Briefly separating out the French territories, and dealing with their numbers first" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2f5312e-15c0-41e8-8e67-f5caed7c94d5", + "metadata": {}, + "outputs": [], + "source": [ + "## gathering the French overseas department values\n", + "y_clean_fra_terr = y_clean.loc[fra_terr, :].copy()\n", + "y_clean_fra_terr[\"cgdpo\"] = y_clean_fra_terr[\"cgdpo_pc_equiv\"]\n", + "fra_terr_cgdpo = y_clean_fra_terr.reset_index().groupby([\"year\"]).sum()[\"cgdpo\"].values\n", + "\n", + "## subtracting this from the `cgdpo_pwt` values in `y_claen` (for FRA)\n", + "y_clean.loc[(\"FRA\", yrs_tgt), \"cgdpo_pwt\"] = (\n", + " y_clean.loc[(\"FRA\", yrs_tgt), \"cgdpo_pwt\"].values - fra_terr_cgdpo\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "65c6cf84-4961-4a68-8be6-674f50c474d9", + "metadata": {}, + "source": [ + "Creating `cgdpo_pc` in PWT version (`cgdpo_pc_pwt`) but with the cleaned population" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ade1d37-0f09-45b3-b7ce-fca82f7942a9", + "metadata": {}, + "outputs": [], + "source": [ + "y_clean[\"cgdpo_pc_pwt\"] = y_clean[\"cgdpo_pwt\"] / y_clean[\"pop\"]" + ] + }, + { + "cell_type": "markdown", + "id": "052671a9-6278-4b40-ab52-dd8ed1b4c5fd", + "metadata": {}, + "source": [ + "### Smooth-filling the missing values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "290003a7-164e-4375-a7d1-c0d20b96184b", + "metadata": {}, + "outputs": [], + "source": [ + "## creating a xr.Dataset with the cgdpo_pc variables\n", + "cgdpo_clean_up = xr.Dataset.from_dataframe(y_clean[[\"cgdpo_pc_pwt\", \"cgdpo_pc_equiv\"]])\n", + "\n", + "## smooth_fill\n", + "cgdpo_clean_up = ypk_fn.smooth_fill(\n", + " cgdpo_clean_up[\"cgdpo_pc_pwt\"],\n", + " cgdpo_clean_up[\"cgdpo_pc_equiv\"],\n", + " time_dim=\"year\",\n", + " other_dim=\"ccode\",\n", + ").to_dataframe()\n", + "\n", + "y_clean = y_clean.merge(\n", + " cgdpo_clean_up.rename(columns={\"cgdpo_pc_pwt\": \"cgdpo_pc\"}),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "\n", + "## creating cgdpo values\n", + "y_clean[\"cgdpo\"] = y_clean[\"cgdpo_pc\"] * y_clean[\"pop\"]" + ] + }, + { + "cell_type": "markdown", + "id": "e9c66764-75f7-4cfe-a869-0e9c954add61", + "metadata": {}, + "source": [ + "## Creating the current PPP-2019 USD `cgdpo` and constant PPP-2019 USD `rgdpna`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27a3f1a9-bccc-4c1d-8344-9ccab6c6ed8e", + "metadata": {}, + "outputs": [], + "source": [ + "## some minor clean-up of names\n", + "y_clean.drop(\n", + " [\"cgdpo_pwt\", \"cgdpo_pc_pwt\", \"pop_pwt\", \"cgdpo_pc_equiv\", \"conv\"],\n", + " axis=1,\n", + " inplace=True,\n", + ")\n", + "ren_names = [\"cgdpo_pc\", \"cgdpo\", \"rgdpna_pc\", \"rgdpna\"]\n", + "y_clean.rename(\n", + " columns=dict(zip(ren_names, [x + \"_17\" for x in ren_names])), inplace=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "6320a549-32cd-48d0-aaad-a15291e4f7b8", + "metadata": {}, + "source": [ + "Creating `cgdpo_19` and `cgdpo_pc_19`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c33d1fd3-310a-427f-b826-8d4970faf3fd", + "metadata": {}, + "outputs": [], + "source": [ + "pwt100 = pd.read_excel(sset.PATH_PWT_RAW)\n", + "pwt100.rename(columns={\"countrycode\": \"ccode\"}, inplace=True)\n", + "pwt100.set_index([\"ccode\", \"year\"], inplace=True)\n", + "infla_1719 = pwt100.loc[(\"USA\", 2019), \"pl_gdpo\"] / pwt100.loc[(\"USA\", 2017), \"pl_gdpo\"]\n", + "\n", + "y_clean[\"cgdpo_19\"] = y_clean[\"cgdpo_17\"] * infla_1719\n", + "y_clean[\"cgdpo_pc_19\"] = y_clean[\"cgdpo_19\"] / y_clean[\"pop\"]" + ] + }, + { + "cell_type": "markdown", + "id": "1a4ed720-b223-4590-af99-a7a9a7c50b3b", + "metadata": {}, + "source": [ + "Creating `rgdpna_19` and `rgdpna_pc_19`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19b73abb-831d-4a7d-b17a-adec12f5dffb", + "metadata": {}, + "outputs": [], + "source": [ + "ccodes = y_clean.index.get_level_values(\"ccode\").unique()\n", + "y_clean[\"rgdpna_19\"] = 0\n", + "for cc in tqdm(ccodes):\n", + " cc_17 = y_clean.loc[(cc, 2019), \"rgdpna_17\"]\n", + " if cc_17 == 0:\n", + " continue\n", + " cc_vals = (\n", + " y_clean.loc[(cc, yrs_tgt), \"rgdpna_17\"].values\n", + " / cc_17\n", + " * y_clean.loc[(cc, 2019), \"cgdpo_19\"]\n", + " )\n", + " y_clean.loc[(cc, yrs_tgt), \"rgdpna_19\"] = cc_vals\n", + "\n", + "y_clean[\"rgdpna_pc_19\"] = y_clean[\"rgdpna_19\"] / y_clean[\"pop\"]" + ] + }, + { + "cell_type": "markdown", + "id": "30ded9f9-f1a9-430f-8fdb-181d5b8718c7", + "metadata": {}, + "source": [ + "Filling the `nan`s in with zeros (which are from zero population)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1de94649-6243-413c-b048-56a95e35cca7", + "metadata": {}, + "outputs": [], + "source": [ + "y_clean.loc[pd.isnull(y_clean.rgdpna_pc_19), \"rgdpna_pc_19\"] = 0\n", + "y_clean.loc[pd.isnull(y_clean.cgdpo_pc_19), \"cgdpo_pc_19\"] = 0" + ] + }, + { + "cell_type": "markdown", + "id": "6a574c24-0f2f-4f58-86da-3f0ddc4300ab", + "metadata": { + "tags": [] + }, + "source": [ + "## I-Y (investment to GDP) ratios and `delta` (depreciation rate) cleanup\n", + "\n", + "We do not extrapolate for all the missingness of I-Y ratio here since that will be done by notebooks to follow." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50c78400-f3d3-464e-8a44-e46fbdd385cc", + "metadata": {}, + "outputs": [], + "source": [ + "## from PWT\n", + "y_clean = y_clean.merge(\n", + " pwt100[[\"csh_i\", \"delta\"]].rename(columns={\"csh_i\": \"iy_ratio\"}),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "\n", + "## from WB WDI\n", + "wb_wdi = pd.read_parquet(sset.DIR_WB_WDI_RAW / \"wdi_pop_iy_gdp.parquet\")\n", + "y_clean = y_clean.merge(\n", + " wb_wdi[[\"NE.GDI.FTOT.ZS\"]].rename(columns={\"NE.GDI.FTOT.ZS\": \"wb_iy_ratio\"}),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "\n", + "## these values are in percentages, so change accordingly\n", + "y_clean[\"wb_iy_ratio\"] = y_clean[\"wb_iy_ratio\"] / 100" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03abfee9-28fd-4ed9-9697-92a72148fe9e", + "metadata": {}, + "outputs": [], + "source": [ + "# adding in the IMF iy ratios, while trying to avoid the ArrowInvalid error\n", + "imf = pd.read_excel(sset.PATH_IMF_WEO_RAW, na_values=[\"n/a\", \"--\"]).rename(\n", + " columns={\"ISO\": \"ccode\", \"Subject Descriptor\": \"subject\"}\n", + ")\n", + "imf = imf.loc[imf.ccode.isin(sset.ALL_ISOS_EXTENDED), :]\n", + "\n", + "# renaming and organizing in vertical format\n", + "imf.loc[imf.subject == \"Total investment\", \"subject\"] = \"imf_iy_ratio\"\n", + "v_names = dict(zip(list(range(1980, 2021)), [\"v_\" + str(x) for x in range(1980, 2021)]))\n", + "imf.rename(columns=v_names, inplace=True)\n", + "\n", + "imf_reorg = imf.loc[\n", + " imf.subject == \"imf_iy_ratio\", [\"ccode\"] + list(v_names.values())\n", + "].set_index([\"ccode\"])\n", + "imf_reorg = ypk_fn.organize_hor_to_ver(\n", + " imf_reorg, \"ccode\", None, \"imf_iy_ratio\", \"v_\", range(1980, 2021)\n", + ")\n", + "imf_reorg[\"imf_iy_ratio\"] /= 100\n", + "\n", + "# merging\n", + "y_clean = y_clean.merge(imf_reorg, how=\"outer\", left_index=True, right_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72c906f4-2f46-4fa6-8a65-f7c25ea1582f", + "metadata": {}, + "outputs": [], + "source": [ + "## IY ratio fill-in, not smoothly; PWT -> WB -> IMF\n", + "y_clean[\"iy_ratio_source\"] = np.nan\n", + "y_clean.loc[\n", + " pd.isnull(y_clean.iy_ratio) & ~pd.isnull(y_clean.wb_iy_ratio), \"iy_ratio_source\"\n", + "] = \"WB\"\n", + "y_clean.loc[\n", + " pd.isnull(y_clean.iy_ratio)\n", + " & pd.isnull(y_clean.wb_iy_ratio)\n", + " & ~pd.isnull(y_clean.imf_iy_ratio),\n", + " \"iy_ratio_source\",\n", + "] = \"IMF\"\n", + "y_clean.loc[~pd.isnull(y_clean.iy_ratio), \"iy_ratio_source\"] = \"PWT\"\n", + "\n", + "## filling in with WB values\n", + "y_clean.loc[pd.isnull(y_clean.iy_ratio), \"iy_ratio\"] = y_clean.loc[\n", + " pd.isnull(y_clean.iy_ratio), \"wb_iy_ratio\"\n", + "].values\n", + "y_clean.drop([\"wb_iy_ratio\"], inplace=True, axis=1)\n", + "\n", + "## filling in with IMF values\n", + "y_clean.loc[pd.isnull(y_clean.iy_ratio), \"iy_ratio\"] = y_clean.loc[\n", + " pd.isnull(y_clean.iy_ratio), \"imf_iy_ratio\"\n", + "].values\n", + "y_clean.drop([\"imf_iy_ratio\"], inplace=True, axis=1)\n", + "\n", + "## final source fill-in\n", + "y_clean.loc[pd.isnull(y_clean.iy_ratio_source), \"iy_ratio_source\"] = \"-\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "540c6776-47cf-4d58-a935-f8b1ed949923", + "metadata": {}, + "outputs": [], + "source": [ + "## filling in the delta information\n", + "y_clean[\"delta_source\"] = \"-\"\n", + "y_clean.loc[~pd.isnull(y_clean.delta), \"delta_source\"] = \"PWT\"\n", + "\n", + "### 2020 information is missing entirely, so just use 2019's values\n", + "y_clean.loc[(slice(None), 2020), \"delta\"] = y_clean.loc[\n", + " (slice(None), 2019), \"delta\"\n", + "].values\n", + "y_clean.loc[\n", + " (~pd.isnull(y_clean.delta)) & (y_clean.index.get_level_values(\"year\") == 2020),\n", + " \"delta_source\",\n", + "] = \"PWT_copy_2019\"\n", + "\n", + "### using annual global averages when values are missing;\n", + "gp_yrly_delta = y_clean.reset_index().groupby(\"year\").mean()[[\"delta\"]]\n", + "y_clean = y_clean.merge(\n", + " gp_yrly_delta.rename(columns={\"delta\": \"delta_yr_avg\"}),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "y_clean.loc[pd.isnull(y_clean.delta), \"delta\"] = y_clean.loc[\n", + " pd.isnull(y_clean.delta), \"delta_yr_avg\"\n", + "].values\n", + "y_clean.loc[y_clean.delta_source == \"-\", \"delta_source\"] = \"yearly_global_avg\"" + ] + }, + { + "cell_type": "markdown", + "id": "ad7d1d64-c44a-4c6a-accb-b16a2e0a0d9c", + "metadata": {}, + "source": [ + "## Capital ratio by category\n", + "\n", + "In the case of missing data, we will again use yearly global average and mark those as so." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed4d8b24-9fe6-4972-9f16-d8a6771746db", + "metadata": {}, + "outputs": [], + "source": [ + "## captial information\n", + "PWT_RAW_DIR = Path(os.path.dirname(sset.PATH_PWT_RAW))\n", + "pwt_capital = pd.read_excel(PWT_RAW_DIR / \"pwt_K_detail_100.xlsx\").rename(\n", + " columns={\"countrycode\": \"ccode\"}\n", + ")\n", + "capital_vals = [\"Nc_Struc\", \"Nc_Mach\", \"Nc_TraEq\", \"Nc_Other\"]\n", + "pwt_capital = pwt_capital.set_index([\"ccode\", \"year\"])[capital_vals]\n", + "for i in capital_vals:\n", + " pwt_capital[i] = pwt_capital[i].astype(\"float64\")\n", + "\n", + "## ratio of capital in each category to total capital\n", + "pwt_capital[\"total_cap\"] = pwt_capital[capital_vals].sum(axis=1)\n", + "newnames = []\n", + "for i in capital_vals:\n", + " newname = i.split(\"_\")[-1].lower() + \"_ratio_prep\"\n", + " newnames.append(newname)\n", + " pwt_capital[newname] = pwt_capital[i] / pwt_capital[\"total_cap\"]\n", + "\n", + "y_clean = y_clean.merge(\n", + " pwt_capital[newnames], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "\n", + "y_clean[\"k_ratio_source\"] = \"-\"\n", + "y_clean.loc[~pd.isnull(y_clean[newnames[0]]), \"k_ratio_source\"] = \"PWT\"\n", + "\n", + "## copying 2019 value into 2020 ones\n", + "for i in newnames:\n", + " y_clean.loc[(slice(None), 2020), i] = y_clean.loc[(slice(None), 2019), i].values\n", + "y_clean.loc[\n", + " (~pd.isnull(y_clean[i])) & (y_clean.index.get_level_values(\"year\") == 2020),\n", + " \"k_ratio_source\",\n", + "] = \"PWT_copy_2019\"\n", + "\n", + "k_ratio_names = []\n", + "for i in newnames:\n", + " yr_avg = i[0:-5] + \"_yr_avg\"\n", + " y_clean = y_clean.merge(\n", + " y_clean.reset_index().groupby(\"year\").mean()[[i]].rename(columns={i: yr_avg}),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + " )\n", + " name = \"k_\" + i[0:-5]\n", + " k_ratio_names.append(name)\n", + " y_clean[name] = y_clean[i]\n", + " y_clean.loc[pd.isnull(y_clean[i]), name] = y_clean.loc[\n", + " pd.isnull(y_clean[i]), yr_avg\n", + " ]\n", + " if i == newnames[0]:\n", + " y_clean.loc[pd.isnull(y_clean[i]), \"k_ratio_source\"] = \"yearly_global_avg\"" + ] + }, + { + "cell_type": "markdown", + "id": "f1567d69-fc76-4133-af74-1471cebc8f2c", + "metadata": {}, + "source": [ + "We also add the \"movable capital ratio\" (`k_movable_ratio`), which is the sum of `k_mach_ratio`, `k_traeq_ratio`, and `k_other_ratio`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c1c1cb7-8092-42b5-bb3d-cd1be647f922", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "y_clean[\"k_movable_ratio\"] = (\n", + " y_clean[\"k_mach_ratio\"] + y_clean[\"k_traeq_ratio\"] + y_clean[\"k_other_ratio\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e78308d8-249b-457c-9a77-70472c8b7563", + "metadata": {}, + "source": [ + "## Exporting\n", + "\n", + "Let us also clarify the current PPP, USD 2017 and constant 2017 PPP USD variables' names (by marking them with `_17`) to signal what units they are in." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9754405a-04f2-4c1f-abe9-5bf1f8ab1688", + "metadata": {}, + "outputs": [], + "source": [ + "y_clean_cop = y_clean.copy() ## due to pandas error, I will make a copy\n", + "y_clean_cop[\"pop_unit\"] = \"millions (of people)\"\n", + "y_clean_cop[\"gdp_unit\"] = \"millions (of USD)\"\n", + "y_clean_cop[\"gdppc_unit\"] = \"ones (of USD)\"\n", + "\n", + "## reorganizing the columns\n", + "gp_columns = [\n", + " \"pop_unit\",\n", + " \"gdppc_unit\",\n", + " \"gdp_unit\",\n", + " \"pop_source\",\n", + " \"gdp_source\",\n", + " \"iy_ratio_source\",\n", + " \"k_ratio_source\",\n", + " \"delta_source\",\n", + " \"pop\",\n", + " \"rgdpna_pc_17\",\n", + " \"rgdpna_17\",\n", + " \"rgdpna_pc_19\",\n", + " \"rgdpna_19\",\n", + " \"cgdpo_pc_17\",\n", + " \"cgdpo_17\",\n", + " \"cgdpo_pc_19\",\n", + " \"cgdpo_19\",\n", + " \"iy_ratio\",\n", + "]\n", + "gp_columns += k_ratio_names + [\"k_movable_ratio\", \"delta\"]\n", + "y_clean_cop = y_clean_cop[gp_columns].copy()\n", + "\n", + "## Exporting\n", + "y_clean_cop.to_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_capital_1950_2020_post_ypk3.parquet\"\n", + ")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0b9dcb8e7e194842ae99b1a9baea9759": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ee7a58fc46dd4b4d9da4f91588307bb2", + "style": "IPY_MODEL_561a97a4b45448a9a8eae441f8e5d0da", + "value": "100%" + } + }, + "1c73fdc454c6491fb61f02cb7ed9fb60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "1c9166276ee347d39c95faf165bc9450": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_53f1e8cca07a4d38aee57777f84c46e9", + "style": "IPY_MODEL_fdee249ae0a74cd5883c86469c39aab9", + "value": " 58/128 [00:03<00:03, 18.74it/s]" + } + }, + "2219a9c4f88340f88bdac773d3ff4b81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_0b9dcb8e7e194842ae99b1a9baea9759", + "IPY_MODEL_bfb81f9cf73640fa97dd0610729aff52", + "IPY_MODEL_7898ad926b0d4883bcba893ae7fc4767" + ], + "layout": "IPY_MODEL_fd84190ae61144e09e5218bfe17d1fc7" + } + }, + "28f49eb672ba4d298a6053625cd08683": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_93f37f94c1c743138ac2c6ee01c067a8", + "max": 41, + "style": "IPY_MODEL_7f3aaa711aac4b12852fd21f7e39945d", + "value": 41 + } + }, + "2ca5cda929ec4f598887d57499131c4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2cf7257329bc449a8f7f2cea82f102e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2f2ef046bcef46b8977cc0ec176e5e3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3e4ddebc6d8146c5aa104043051a7d9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7080a43f19074187898a40c3a20ee40d", + "style": "IPY_MODEL_ca9b28f1e0f14fc8b47d9c8744aed724", + "value": "100%" + } + }, + "3f5b1a2098e44766aa993c6b82496274": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_404dbe7264f44e20bfcf76a2442bc307", + "IPY_MODEL_d472be28fc3f41e9a88461090353c6e7", + "IPY_MODEL_1c9166276ee347d39c95faf165bc9450" + ], + "layout": "IPY_MODEL_9c15bafa92dc45289705416df944586c" + } + }, + "404dbe7264f44e20bfcf76a2442bc307": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d70e0b24d77f4ae8a376588cb6ed1950", + "style": "IPY_MODEL_7552bca25c9a43a2905ae9fde45c5edb", + "value": " 45%" + } + }, + "45da96f00ed548cfa6d134939acbadd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_c21431b349d84789982ea663823146b3", + "style": "IPY_MODEL_8cb6432b2f084c3cb409d6c7beba6632", + "value": "100%" + } + }, + "4d24dc58e4b84e11a720130e59a5cd77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_45da96f00ed548cfa6d134939acbadd5", + "IPY_MODEL_28f49eb672ba4d298a6053625cd08683", + "IPY_MODEL_f0842f58af714d499f34aedec233b7c9" + ], + "layout": "IPY_MODEL_1c73fdc454c6491fb61f02cb7ed9fb60" + } + }, + "50b4c5c87b804e0f9214977cd06fef37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_f1fd6be11513474aa87063932f6eac2b", + "max": 128, + "style": "IPY_MODEL_729bb13470b447e79b3caea1241f1e93", + "value": 128 + } + }, + "53f1e8cca07a4d38aee57777f84c46e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "55b9a6a30f8b416cbba6c9d62e2087fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_3e4ddebc6d8146c5aa104043051a7d9c", + "IPY_MODEL_50b4c5c87b804e0f9214977cd06fef37", + "IPY_MODEL_5c2902f5fee74ae3aa47520fef604943" + ], + "layout": "IPY_MODEL_63385f1808b547e6a8d3d4ed7b96b70a" + } + }, + "561a97a4b45448a9a8eae441f8e5d0da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5c2902f5fee74ae3aa47520fef604943": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f81dbdbbbbf54f7ca9164896bc1bff6e", + "style": "IPY_MODEL_2ca5cda929ec4f598887d57499131c4e", + "value": " 128/128 [00:06<00:00, 18.85it/s]" + } + }, + "63385f1808b547e6a8d3d4ed7b96b70a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "7080a43f19074187898a40c3a20ee40d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "729bb13470b447e79b3caea1241f1e93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "7552bca25c9a43a2905ae9fde45c5edb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "7898ad926b0d4883bcba893ae7fc4767": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a21a9092bda140fdafae94f953e21434", + "style": "IPY_MODEL_2cf7257329bc449a8f7f2cea82f102e2", + "value": " 229/229 [00:00<00:00, 517.42it/s]" + } + }, + "7f3aaa711aac4b12852fd21f7e39945d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "8b21dc66894e4f06aaf34585481aae6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "8cb6432b2f084c3cb409d6c7beba6632": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "93f37f94c1c743138ac2c6ee01c067a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "9c15bafa92dc45289705416df944586c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "a21a9092bda140fdafae94f953e21434": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "a2f1698ea33a4075b704c93fbfe2a56d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "ab97341f3436466aa6f4964db63be7f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "bfb81f9cf73640fa97dd0610729aff52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_8b21dc66894e4f06aaf34585481aae6e", + "max": 229, + "style": "IPY_MODEL_d578d2e01b464318a2a7aa63c44b45a2", + "value": 229 + } + }, + "c21431b349d84789982ea663823146b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "ca9b28f1e0f14fc8b47d9c8744aed724": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "d472be28fc3f41e9a88461090353c6e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "danger", + "layout": "IPY_MODEL_f300e0de6459495c925d508aa567cc10", + "max": 128, + "style": "IPY_MODEL_ab97341f3436466aa6f4964db63be7f6", + "value": 58 + } + }, + "d578d2e01b464318a2a7aa63c44b45a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "d70e0b24d77f4ae8a376588cb6ed1950": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "ee7a58fc46dd4b4d9da4f91588307bb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "f0842f58af714d499f34aedec233b7c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a2f1698ea33a4075b704c93fbfe2a56d", + "style": "IPY_MODEL_2f2ef046bcef46b8977cc0ec176e5e3d", + "value": " 41/41 [00:02<00:00, 17.28it/s]" + } + }, + "f1fd6be11513474aa87063932f6eac2b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "f300e0de6459495c925d508aa567cc10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "f81dbdbbbbf54f7ca9164896bc1bff6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "fd84190ae61144e09e5218bfe17d1fc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "fdee249ae0a74cd5883c86469c39aab9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk3_demo_ratios_historical_reg.ipynb b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk3_demo_ratios_historical_reg.ipynb new file mode 100644 index 0000000..c1f73d2 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk3_demo_ratios_historical_reg.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "68fee01c-c1cb-4120-8c8f-319624f439b1", + "metadata": {}, + "source": [ + "## Code for creating \"demographic ratios,\" \"demographic variables,\" other variables needed for the \"historical regression\" (based on Higgins, 1998, International Economic Review), and executing the said regression\n", + "\n", + "This notebook was written to execute the following tasks:\n", + "- Create \"demographic ratios,\" which are the shares of specific age-groups (0-4, 5-9, ..., 65-69, and 70+) for each country; these will be made in five-year moving averages, for the \"historical regression\" (based on Higgins, 1998, Int. Econ. Rev.)\n", + "- Create \"demographic variables,\" which are created from the demographic ratios and are used the historical regression\n", + "- Create other variables created from on GDPpc and its grwoth rate to be used in the historical regression\n", + "- Conduct the historical regression and project missing values for the I-Y ratios\n", + "\n", + "## Setting\n", + "\n", + "### Importing necessary modules" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27c2bff0-2778-4158-b2e1-129d1aabdd17", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "432995b6-2134-40d4-8704-8f14f0cea373", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "from tqdm.auto import tqdm\n", + "\n", + "from sliiders import country_level_ypk as ypk_fn\n", + "from sliiders import settings as sset" + ] + }, + { + "cell_type": "markdown", + "id": "9f59da9e-de72-4e2e-a0d7-83b16fe6dd1b", + "metadata": { + "tags": [] + }, + "source": [ + "## Creating (five-year averages of) demographic ratios\n", + "\n", + "### Importing necessary datasets\n", + "\n", + "We note that the population values in the dataset we cleaned up is in millions of people whereas the UN data is in thousands of people. Therefore, we will divide the columns `PopMale`, `PopFemale`, and `PopTotal` by 1000 to keep all values in millions of people." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca5b745b-4771-4099-8fec-8aa559dcb0b5", + "metadata": {}, + "outputs": [], + "source": [ + "# overall population stuff\n", + "pop = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_capital_1950_2020_post_ypk3.parquet\"\n", + ")\n", + "\n", + "# let us set aside the uninhabited areas\n", + "pop = pop.loc[\n", + " ~pop.index.get_level_values(\"ccode\").isin(sset.UNINHABITED_ISOS), :\n", + "].sort_index()\n", + "ccodes = pop.index.get_level_values(\"ccode\").unique()\n", + "\n", + "# by-age population\n", + "by_age = pd.read_parquet(sset.DIR_YPK_INT / \"un_population_by_age.parquet\")\n", + "for i in [\"PopMale\", \"PopFemale\", \"PopTotal\"]:\n", + " by_age[i] = by_age[i] / 1000" + ] + }, + { + "cell_type": "markdown", + "id": "97afbfd6-7d25-4472-95b3-4540d5b883fb", + "metadata": { + "tags": [] + }, + "source": [ + "### Gathering the age groups\n", + "\n", + "#### For all countries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3852080c-ecc9-499f-80d9-46df97bd168b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "## generating groups\n", + "yrs = np.arange(0, 70, 5)\n", + "groups = [\"-\".join([str(x), str(x + 4)]) for x in yrs]\n", + "\n", + "## easier mapping from group names to group numbering\n", + "dic = dict(zip(groups, range(1, len(groups) + 1)))\n", + "case_df = pd.DataFrame(\n", + " np.vstack([list(dic.keys()), list(dic.values())]).T, columns=[\"AgeGrp\", \"group_num\"]\n", + ")\n", + "\n", + "## group numbering attach\n", + "by_age_cleaning = by_age.reset_index().merge(case_df, on=\"AgeGrp\", how=\"left\")\n", + "\n", + "## if no group number (i.e., the highest age group), just create a new one\n", + "by_age_cleaning.loc[pd.isnull(by_age_cleaning.group_num), \"group_num\"] = (\n", + " max(list(dic.values())) + 1\n", + ")\n", + "\n", + "## gathering by the generated group numberings\n", + "by_age_cleaning = by_age_cleaning.groupby([\"ccode\", \"Time\", \"group_num\"]).sum()\n", + "by_age_cleaning.reset_index(inplace=True)\n", + "\n", + "## reorganizing, data type-setting\n", + "by_age_cleaning = by_age_cleaning.astype({\"Time\": \"int64\", \"group_num\": \"int64\"})\n", + "by_age_cleaning.rename(columns={\"Time\": \"year\"}, inplace=True)\n", + "by_age_cleaning.set_index([\"ccode\", \"year\", \"group_num\"], inplace=True)\n", + "by_age_cleaning.sort_index(inplace=True)\n", + "\n", + "## Only want 2020 and before\n", + "by_age_cleaning = by_age_cleaning.loc[\n", + " by_age_cleaning.index.get_level_values(\"year\") <= 2020, [\"PopTotal\"]\n", + "].copy()\n", + "\n", + "## again, cleaning and merging in the group names\n", + "case_df = case_df.astype({\"group_num\": \"int64\"}).set_index([\"group_num\"])\n", + "by_age_cleaning = by_age_cleaning.merge(\n", + " case_df, left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "\n", + "## if missing group name, this should be for over 70+\n", + "by_age_cleaning.loc[pd.isnull(by_age_cleaning.AgeGrp), \"AgeGrp\"] = \"70+\"" + ] + }, + { + "cell_type": "markdown", + "id": "dcfeaadf-08e1-4792-9528-50c8c2735552", + "metadata": {}, + "source": [ + "#### Taking care of the Channel Islands, and setting aside their information\n", + "\n", + "We find that the `grps_df` actually includes the information for the Channel Islands, which we can separate out to Guernsey and Jersey (`GGY` and `JEY`). In the said separation effort, what we will do is to use the average ratio of `GGY` population and `JEY` population between the years 2009-2019 as noted in the previous file (`ypk3_reorg_and_impute_ypk.ipynb`). The reason for using the years 2009-2019 is because we have actual data for `GGY` for those years in Guernsey Annual Electronic Report." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0eb9ac1c-b1d9-45f5-b216-0d7ac4564a51", + "metadata": {}, + "outputs": [], + "source": [ + "## GGY and JEY ratios\n", + "ggy_0919 = pop.loc[(\"GGY\", list(range(2009, 2020))), \"pop\"].values\n", + "jey_0919 = pop.loc[(\"JEY\", list(range(2009, 2020))), \"pop\"].values\n", + "ggy_ratio = (ggy_0919 / (ggy_0919 + jey_0919)).mean()\n", + "jey_ratio = (jey_0919 / (ggy_0919 + jey_0919)).mean()\n", + "\n", + "## separating out JEY and GGY\n", + "channel = by_age_cleaning.loc[(\"GGY+JEY\", slice(None), slice(None)), :].copy()\n", + "ggy, jey = channel.reset_index(), channel.reset_index()\n", + "ggy[\"PopTotal\"] = ggy[\"PopTotal\"].values * ggy_ratio\n", + "jey[\"PopTotal\"] = jey[\"PopTotal\"].values * jey_ratio\n", + "ggy[\"ccode\"], jey[\"ccode\"] = \"GGY\", \"JEY\"\n", + "ggy.set_index([\"ccode\", \"year\", \"group_num\"], inplace=True)\n", + "jey.set_index([\"ccode\", \"year\", \"group_num\"], inplace=True)\n", + "\n", + "## merging stuff together\n", + "by_age_cleaning = pd.concat(\n", + " [\n", + " ggy,\n", + " jey,\n", + " by_age_cleaning.loc[\n", + " by_age_cleaning.index.get_level_values(\"ccode\") != \"GGY+JEY\", :\n", + " ],\n", + " ],\n", + " axis=0,\n", + ").sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "f68b301c-2c4c-4d94-a0e8-68becace7c4a", + "metadata": {}, + "source": [ + "### Creating demographic ratios of age-group population 5-year-averages, and extrapolating for missing countries\n", + "\n", + "#### 5-year-averages of age-group population\n", + "\n", + "To be exact, this would be the 5 previous years' averages. If there are less than 5 previous years available (for 1950-1954), we use whatever previous years we have, with the exception of year 1950 where the 1950 values are copied due to lack of previous-years data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1864ce4b-d0c0-4e78-b34b-9b992cf537ee", + "metadata": {}, + "outputs": [], + "source": [ + "by_age_cleaning[\"avg_5_yrs\"] = np.nan\n", + "\n", + "for i in tqdm(range(1950, 2021)):\n", + " if i in [1950, 1951]:\n", + " by_age_cleaning.loc[(slice(None), i), \"avg_5_yrs\"] = by_age_cleaning.loc[\n", + " (slice(None), 1950), \"PopTotal\"\n", + " ].values\n", + " continue\n", + " elif i in [1952, 1953, 1954]:\n", + " prev_yrs = list(range(1950, i))\n", + " else:\n", + " prev_yrs = list(range(i - 5, i))\n", + "\n", + " for j, yr in enumerate(prev_yrs):\n", + " name = \"pop_{}\".format(yr)\n", + " yr_df = by_age_cleaning.loc[(slice(None), yr, slice(None)), [\"PopTotal\"]]\n", + " yr_df.reset_index(inplace=True)\n", + " yr_df.drop([\"year\"], inplace=True, axis=1)\n", + " yr_df.rename(columns={\"PopTotal\": name}, inplace=True)\n", + " yr_df.set_index([\"ccode\", \"group_num\"], inplace=True)\n", + "\n", + " if j == 0:\n", + " prev_df = yr_df.copy()\n", + " else:\n", + " prev_df = prev_df.merge(\n", + " yr_df, left_index=True, right_index=True, how=\"left\"\n", + " )\n", + "\n", + " prev_df[\"prev_mean\"] = prev_df[[\"pop_{}\".format(x) for x in prev_yrs]].mean(axis=1)\n", + " prev_df.reset_index(inplace=True)\n", + " prev_df[\"year\"] = i\n", + " prev_df.set_index([\"ccode\", \"year\", \"group_num\"], inplace=True)\n", + " by_age_cleaning = by_age_cleaning.merge(\n", + " prev_df[[\"prev_mean\"]], left_index=True, right_index=True, how=\"left\"\n", + " )\n", + " by_age_cleaning.loc[(slice(None), i), \"avg_5_yrs\"] = by_age_cleaning.loc[\n", + " (slice(None), i), \"prev_mean\"\n", + " ].values\n", + " by_age_cleaning.drop([\"prev_mean\"], inplace=True, axis=1)" + ] + }, + { + "cell_type": "markdown", + "id": "a1859a37-ee90-4950-a63b-97b82c79e6eb", + "metadata": {}, + "source": [ + "#### Creating the demographic ratios" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "934b555b-99b3-461a-8be4-e1cc93ae0759", + "metadata": {}, + "outputs": [], + "source": [ + "total = by_age_cleaning.reset_index().groupby([\"ccode\", \"year\"]).sum()[[\"avg_5_yrs\"]]\n", + "total.rename(columns={\"avg_5_yrs\": \"total\"}, inplace=True)\n", + "by_age_cleaning = by_age_cleaning.merge(\n", + " total, left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "by_age_cleaning[\"demo_ratio\"] = by_age_cleaning[\"avg_5_yrs\"] / by_age_cleaning[\"total\"]\n", + "\n", + "## setting aside the countries that we will actually use\n", + "by_age_cleaning = by_age_cleaning.loc[\n", + " by_age_cleaning.index.get_level_values(\"ccode\").isin(ccodes), :\n", + "].sort_index()\n", + "\n", + "by_age_cleaning.drop([\"total\"], inplace=True, axis=1)\n", + "by_age_cleaning[\"demo_ratio_source\"] = \"UN\"" + ] + }, + { + "cell_type": "markdown", + "id": "52eb1d2d-b4c9-41f5-8af3-7253ba1c8d97", + "metadata": {}, + "source": [ + "#### Finding the \"similar\" countries (in terms of population growth trajectory) creating demographic ratios by way of weighted averaging of similar countries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad208aef-6584-4064-b6cb-2f11022697d3", + "metadata": {}, + "outputs": [], + "source": [ + "## creating growth rates of population\n", + "pop_hor = ypk_fn.organize_ver_to_hor(\n", + " pop[[\"pop\"]], \"pop\", \"year\", \"ccode\", total_yrs=range(1950, 2021)\n", + ")\n", + "for i in range(1951, 2021):\n", + " v_, v_prev = \"v_{}\".format(i), \"v_{}\".format(i - 1)\n", + " newvar = \"r_{}\".format(i)\n", + " pop_hor[newvar] = pop_hor[v_] / pop_hor[v_prev] - 1\n", + "\n", + "## finding which countries we should extrapolate for, and extrapolate from\n", + "msng_ccodes = np.setdiff1d(\n", + " ccodes, by_age_cleaning.index.get_level_values(\"ccode\").unique()\n", + ")\n", + "valid_ccodes = np.intersect1d(\n", + " ccodes, by_age_cleaning.index.get_level_values(\"ccode\").unique()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65fecae9-adfe-436d-9579-6e181a0dccdf", + "metadata": {}, + "outputs": [], + "source": [ + "def find_similars_extrap_demog_ratio(\n", + " ctry, sim_df, demoratio_df, valid_ccodes, header=\"r_\", n_det=5\n", + "):\n", + " \"\"\"Find `n_det` most similar countries (in terms of population trajectories)\n", + " for a certain country, among those that are listed in valid_ccodes. Then,\n", + " take a weighted average of those countries' to extrapolate demographic ratio.\n", + "\n", + " Parameters\n", + " ----------\n", + " ctry : str\n", + " name of the country to find \"similar\"-trend countries for\n", + " sim_df : pandas DataFrame\n", + " wide-panel-format data to calculate trend-similarities for the `ctry` and other\n", + " countries. Should have yearly data that has column names starting with the\n", + " `header`\n", + " demoratio_df : pandas DataFrame\n", + " DataFrame containing information for the demographic ratio; should have the\n", + " column `demo_ratio` contained\n", + " valid_ccodes : array-like of str\n", + " DataFrame containing country codes which are \"valid\" ones to create extrapolated\n", + " demographic ratios from.\n", + " header : str\n", + " header of the columns in `sim_df` which are yearly variables to detect\n", + " similarities (in growth rate) from\n", + " n_det : int\n", + " number of country codes in `valid_ccodes` to created extrapolated demographic\n", + " ratios from; top `n_det` countries in terms of similaries are selected\n", + "\n", + " Returns\n", + " -------\n", + " extrap_df : pandas DataFrame\n", + " contains information about the extrapolated demographic ratios, specific for the\n", + " country code defined by `ctry`; has the variables `demo_ratio` for the\n", + " extrapolated demographic ratio, and `demo_ratio_source` for the countries whose\n", + " information was utilized to create the `demo_ratio` extrapolations. Has indices\n", + " `ccode`, `year`, and `group_num` for countrycode, year, and group numbering.\n", + "\n", + " \"\"\"\n", + " goodcols = [x for x in sim_df.columns if header in x]\n", + " df_sse = (\n", + " sim_df.loc[valid_ccodes, goodcols].sub(sim_df.loc[ctry, goodcols].values).copy()\n", + " )\n", + " df_sse[\"sse\"] = (df_sse[goodcols].values ** 2).sum(axis=1)\n", + " df_sse[\"sse_rank\"] = df_sse[\"sse\"].rank()\n", + " df_sse.sort_values([\"sse_rank\"], inplace=True)\n", + " df_sse = df_sse.loc[df_sse.sse_rank <= n_det, [\"sse\", \"sse_rank\"]].copy()\n", + "\n", + " extrap_df = demoratio_df.loc[\n", + " (df_sse.index.values, slice(None), slice(None)), [\"demo_ratio\"]\n", + " ].merge(df_sse[[\"sse\"]], left_index=True, right_index=True, how=\"left\")\n", + " denom = np.sum(1 / df_sse.sse)\n", + " extrap_df[\"numer\"] = extrap_df[\"demo_ratio\"] / extrap_df[\"sse\"]\n", + " extrap_df = extrap_df.reset_index().groupby([\"year\", \"group_num\"]).sum()[[\"numer\"]]\n", + " extrap_df[\"numer\"] = extrap_df[\"numer\"] / denom\n", + "\n", + " extrap_df = extrap_df.reset_index().rename(columns={\"numer\": \"demo_ratio\"})\n", + " extrap_df[\"ccode\"] = ctry\n", + " extrap_df.set_index([\"ccode\", \"year\", \"group_num\"], inplace=True)\n", + " extrap_df[\"demo_ratio_source\"] = \",\".join(df_sse.index.values)\n", + "\n", + " return extrap_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c8575a3-a863-4ff3-ad72-0f0b593fee00", + "metadata": {}, + "outputs": [], + "source": [ + "msng_extrap_dfs = []\n", + "for i in tqdm(msng_ccodes):\n", + " msng_extrap_dfs.append(\n", + " find_similars_extrap_demog_ratio(i, pop_hor, by_age_cleaning, valid_ccodes)\n", + " )\n", + "msng_extrap_dfs = pd.concat(msng_extrap_dfs, axis=0)\n", + "\n", + "## creating a finalized version of the demographic ratio dataset\n", + "demo_ratio_df = pd.concat(\n", + " [by_age_cleaning[[\"demo_ratio\", \"demo_ratio_source\"]], msng_extrap_dfs], axis=0\n", + ").sort_index()\n", + "\n", + "## attaching the Age Group indicators\n", + "demo_ratio_df = demo_ratio_df.merge(\n", + " case_df, how=\"left\", right_index=True, left_index=True\n", + ")\n", + "demo_ratio_df.loc[pd.isnull(demo_ratio_df.AgeGrp), \"AgeGrp\"] = \"70+\"" + ] + }, + { + "cell_type": "markdown", + "id": "dcfebd10-bcae-4878-87a5-ea73d8dea1a2", + "metadata": {}, + "source": [ + "### Exporting the demographic ratios results\n", + "\n", + "Note that the uninhabited areas are, again, left out from this dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27fdf070-0b31-401b-82a7-7a9472a9aa75", + "metadata": {}, + "outputs": [], + "source": [ + "demo_ratio_df.to_parquet(sset.DIR_YPK_INT / \"demo_ratio_1950_2020.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "7fee9545-7ecd-4f4e-bc8c-9688dffefa9b", + "metadata": {}, + "source": [ + "## Creating the \"demographic variables\"\n", + "\n", + "Demographic variables are a succinct way of representing different age group (demographic) ratios into just a few variables by assuming a functional (polynomial) form for how they enter the regression. If we assume a $l$th order polynomial form, there will be $k=1, 2, \\cdots, l$-order variables (so $l$ demographic variables to represent 15 demographic groups we have).\n", + "\n", + "For the $k$th order, we have\n", + "\n", + "$D_k = \\sum_{j=1}^J j^k p_j - \\frac{1}{J}\\sum_{j=1}^J j^k$\n", + "\n", + "where $J=15$ in our case (for the number of demographic groups considered) and $p_j$ is the demographic ratio of the $j$th group. Derivation of this form (and why we choose $l=3$ in this instance) is further explained in [Higgins (1995, International Economic Review, pp. 366-367)](https://www.jstor.org/stable/2527297)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e72d132b-c139-4274-8547-d59b89804a30", + "metadata": {}, + "outputs": [], + "source": [ + "demo = pd.read_parquet(sset.DIR_YPK_INT / \"demo_ratio_1950_2020.parquet\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6ffc47e-ea37-4240-abb8-6fa85158a75c", + "metadata": {}, + "outputs": [], + "source": [ + "def D_k_generator(df, k=1, v_name=\"demo_ratio\"):\n", + " \"\"\"Function to generate the k-order demographic variable for each country.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : pandas DataFrame\n", + " DataFrame containing column to generate the k-order demographic variable. Should\n", + " have indices `ccode`, `year`, and `group_num` to indicate country-code, year,\n", + " and group numbering for the country-year ratio variable (by groups)\n", + " k : int\n", + " order of the demographic variable to create\n", + " v_name : str\n", + " column name of the ratio variable, contained in the DataFrame `df`\n", + "\n", + " Returns\n", + " -------\n", + " demovar_df : pandas DataFrame\n", + " DataFrame with the same `ccode`, `year`, and `group_num` index information but\n", + " containing a single variable, which is the calculated `k`-th order demographic\n", + " variable with the name `D{k}`.\n", + "\n", + " \"\"\"\n", + "\n", + " astmsg = \"Assign the indices ccode, year, group_num correctly\"\n", + " assert [\"ccode\", \"year\", \"group_num\"] == demo.index.names, astmsg\n", + "\n", + " groups = np.sort(df.index.get_level_values(\"group_num\").unique())\n", + " N_groups = len(groups)\n", + " groups_pwr_k = groups**k\n", + " to_subtract = np.mean(groups_pwr_k)\n", + "\n", + " group_df = pd.DataFrame(data={\"grp_k\": groups_pwr_k, \"group_num\": groups})\n", + " group_df.set_index([\"group_num\"], inplace=True)\n", + "\n", + " demovar_df = df.merge(group_df, left_index=True, right_index=True, how=\"left\")\n", + " demovar_df[\"grp_k_prod_ratio\"] = demovar_df[v_name] * demovar_df[\"grp_k\"]\n", + " demovar_df = (\n", + " demovar_df.reset_index().groupby([\"ccode\", \"year\"]).sum()[[\"grp_k_prod_ratio\"]]\n", + " )\n", + " demovar_df[\"D{}\".format(k)] = demovar_df[\"grp_k_prod_ratio\"] - to_subtract\n", + "\n", + " return demovar_df[[\"D{}\".format(k)]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "168c6ac4-ca0a-49c2-a7b5-1046ae17338e", + "metadata": {}, + "outputs": [], + "source": [ + "## demographic variables (orders 1, 2, 3) and source\n", + "demovar_df = D_k_generator(demo).merge(\n", + " D_k_generator(demo, k=2), how=\"left\", right_index=True, left_index=True\n", + ")\n", + "demovar_df = demovar_df.merge(\n", + " D_k_generator(demo, k=3), how=\"left\", right_index=True, left_index=True\n", + ")\n", + "demo_source = demo.loc[(slice(None), 1950, 1), [\"demo_ratio_source\"]].reset_index()\n", + "demo_source.drop([\"year\", \"group_num\"], inplace=True, axis=1)\n", + "demo_source.set_index([\"ccode\"], inplace=True)\n", + "demovar_df = demovar_df.merge(\n", + " demo_source.rename(columns={\"demo_ratio_source\": \"demo_var_source\"}),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f953a55e-13de-4c11-a504-f7b4fcc92f02", + "metadata": {}, + "source": [ + "## Creating other variables to be used in the \"historical regression\" for I-Y ratios (based on Higgins, 1995, Int. Econ. Rev.)\n", + "\n", + "### Creating \"yhat\"\n", + "\n", + "By \"yhat\" or $\\hat{y}_t$, we mean the following:\n", + "\n", + "$$ \\hat{y}_t = \\frac{1}{5}\\sum_{i=1}^{5} y_{t-i} \\quad t \\geq 1955 $$\n", + "\n", + "where $y_{t}$ is year $t$'s value of GDP per capita (in ones of constant 2017 PPP USD). So essentially, it would be the 5-year average of GDPpc of a certain country for the 5 previous year to the year $t$. However, notice that for $t \\leq 1954$, since we only have data up to 1950, we won't be able to take the 5-year average. Therefore, instead, we will use the following $n \\in \\{1, 2, 3, 4\\}$-year averages:\n", + "\n", + "$$ \\hat{y}_t = \\begin{cases}\n", + " y_{1950} & \\text{ if }t = 1950, 1951 \\\\\n", + " \\frac{1}{n} \\sum_{j=1950}^{1949+n} y_{j} & \\text{ if }t \\in \\{1952, 1953, 1954\\} \\text{ (and $n = t - 1950 $)}\n", + "\\end{cases} $$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef7493c1-d408-44e2-918a-218da2eea5f1", + "metadata": {}, + "outputs": [], + "source": [ + "gdppc = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_capital_1950_2020_post_ypk3.parquet\"\n", + ")\n", + "yvar = \"rgdpna_pc_17\"\n", + "gdppc[\"yhat\"] = np.nan\n", + "\n", + "for i in tqdm(range(1950, 2021)):\n", + " if i in [1950, 1951]:\n", + " gdppc.loc[(slice(None), i), \"yhat\"] = gdppc.loc[\n", + " (slice(None), 1950), yvar\n", + " ].values\n", + " continue\n", + " elif i in [1952, 1953, 1954]:\n", + " prev_range = range(1950, i)\n", + " else:\n", + " prev_range = range(i - 5, i)\n", + "\n", + " for yr in prev_range:\n", + " yr_df = gdppc.loc[(slice(None), yr), [yvar]].reset_index()\n", + " yr_df = yr_df.drop([\"year\"], axis=1).rename(columns={yvar: \"y_{}\".format(yr)})\n", + " yr_df.set_index([\"ccode\"], inplace=True)\n", + " if yr == prev_range[0]:\n", + " prev_df = yr_df.copy()\n", + " else:\n", + " prev_df = prev_df.merge(\n", + " yr_df, left_index=True, right_index=True, how=\"left\"\n", + " )\n", + " prev_df[\"yhat_i\"] = prev_df[[\"y_{}\".format(x) for x in prev_range]].mean(axis=1)\n", + " gdppc = gdppc.merge(\n", + " prev_df[[\"yhat_i\"]], left_index=True, right_index=True, how=\"left\"\n", + " )\n", + " gdppc.loc[(slice(None), i), \"yhat\"] = gdppc.loc[(slice(None), i), \"yhat_i\"].values\n", + " gdppc.drop([\"yhat_i\"], inplace=True, axis=1)" + ] + }, + { + "cell_type": "markdown", + "id": "ebdeb42b-f966-4685-8c21-1425256c3b42", + "metadata": {}, + "source": [ + "### Creating \"ghat\"\n", + "\n", + "By \"ghat\" or $\\hat{g}_t$, we mean the following:\n", + "\n", + "$$ \\hat{g}_t = \\begin{cases} \\frac{\\hat{y}_{t}}{\\hat{y}_{t-1}} - 1 & \\text{ if $\\hat{y}_{t-1} > 0$} \n", + "\\\\ 1 & \\text{ if $\\hat{y}_{t-1} = 0$ and $\\hat{y}_{t} > 0$}\n", + "\\\\ 0 & \\text{ otherwise}\\end{cases} $$\n", + "\n", + "In other words, it would be the previous year's growth rate (of GDPpc) with respect to the 5-year average of the previous year's 5 previous years. Since we do not have information for the year 1949, I will set $\\hat{g}_{1950} = \\hat{g}_{1951}$. Note that \"ghat\" will be actually used as a regressor in the historical regression." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3cc81ee2-7590-4e10-b46e-e22b103c326e", + "metadata": {}, + "outputs": [], + "source": [ + "prev_yhat = gdppc[[\"yhat\"]].reset_index().rename(columns={\"yhat\": \"prev_yhat\"})\n", + "prev_yhat[\"year\"] = prev_yhat[\"year\"] + 1\n", + "prev_yhat.set_index([\"ccode\", \"year\"], inplace=True)\n", + "gdppc = gdppc.merge(prev_yhat, left_index=True, right_index=True, how=\"left\")\n", + "\n", + "gdppc[\"ghat\"] = gdppc[\"yhat\"] / gdppc[\"prev_yhat\"] - 1\n", + "gdppc.loc[(slice(None), 1950), \"ghat\"] = gdppc.loc[(slice(None), 1951), \"ghat\"].values" + ] + }, + { + "cell_type": "markdown", + "id": "d97df27d-31cf-416d-8b53-aeaae0f9ada5", + "metadata": {}, + "source": [ + "### Creating \"yhat rate\"\n", + "\n", + "By \"yhat rate\" or $\\hat{yr}_t$, I will mean the following:\n", + "\n", + "$$ \\hat{yr}_{i,t} = \\frac{\\hat{y}_{i,t}}{\\hat{y}_{US, t}}$$\n", + "\n", + "where $i$ is a country. Note that the \"yhat rate\" will be used as a regressor in the historical regression." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b81eb2ab-c411-4bee-b257-f32674ad1fef", + "metadata": {}, + "outputs": [], + "source": [ + "yhat_usa = gdppc.loc[(\"USA\", slice(None)), [\"yhat\"]].reset_index()\n", + "yhat_usa = (\n", + " yhat_usa.drop([\"ccode\"], axis=1)\n", + " .set_index([\"year\"])\n", + " .rename(columns={\"yhat\": \"yhat_us\"})\n", + ")\n", + "\n", + "gdppc = gdppc.merge(yhat_usa, left_index=True, right_index=True, how=\"left\")\n", + "gdppc[\"yhat_rate\"] = gdppc[\"yhat\"] / gdppc[\"yhat_us\"]" + ] + }, + { + "cell_type": "markdown", + "id": "65eb34fb-f955-4ca3-b88c-f799d33907aa", + "metadata": {}, + "source": [ + "### Organizing the dataframe for the historical regression and exporting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5cc72259-451b-4ce9-9db7-06e6e2436705", + "metadata": {}, + "outputs": [], + "source": [ + "hist_reg_df = gdppc[[\"iy_ratio\", \"yhat_rate\", \"ghat\", \"gdp_source\"]].copy()\n", + "hist_reg_df[\"yhr_sq\"] = hist_reg_df[\"yhat_rate\"] ** 2\n", + "hist_reg_df[\"ghat_sq\"] = hist_reg_df[\"ghat\"] ** 2\n", + "\n", + "hist_reg_df = hist_reg_df.merge(\n", + " demovar_df, left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "for i in [\"D1\", \"D2\", \"D3\"]:\n", + " hist_reg_df[\"{}_x_ghat\".format(i)] = hist_reg_df[i] * hist_reg_df[\"ghat\"]\n", + "\n", + "hist_reg_df.to_parquet(sset.DIR_YPK_INT / \"hist_reg_prep.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "9b1dbf13-f2cc-4ba5-8dcd-067de4d1033d", + "metadata": {}, + "source": [ + "## Historical regression\n", + "\n", + "### Conducting the fit\n", + "\n", + "To summarize, the regression **with** demographic variables can be written as:\n", + "\n", + "$$ \\left(\\frac{I}{Y}\\right)_{c, t} = \\alpha_c + \\beta_1 \\hat{yhr}_{c, t} + \\beta_2 (\\hat{yhr}_{c, t})^2 + \\beta_3 \\hat{g}_{c, t} + \\beta_4 (\\hat{g}_{c, t})^2 + \\sum_{k=1}^3 \\left(\\gamma_k D_{k, c, t} + \\zeta_k [D_{k, c, t} \\times \\hat{g}_{c, t}]\\right) + \\varepsilon_{c, t}$$\n", + "\n", + "where the demographic terms are the ones involving $D_{k,c, t}$ and should be removed in the version where demographic variables are *not* used.\n", + "\n", + "Brief conclusion with AIC, BIC, and adjusted $R^2$ comparison shows that it is better to include the demographic variables in terms of the model fit." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "456e81d9-dc61-46cb-8c63-d30469bcc1e6", + "metadata": {}, + "outputs": [], + "source": [ + "## DF to fit for the historical regression\n", + "hist_fit_df = hist_reg_df.loc[\n", + " ~pd.isnull(hist_reg_df[hist_reg_df.columns]).any(axis=1), :\n", + "].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73fc9b82-a8f8-4cd3-ad4f-c0ab1c8bceaf", + "metadata": {}, + "outputs": [], + "source": [ + "def ols_with_selected(\n", + " df_orig, lhs, fe=True, exclude_rhs=[\"gdp_source\", \"demo_var_source\"]\n", + "):\n", + " \"\"\"Running a OLS model with clustered standard errors (clustered at the country\n", + " level) and returning the fitting result.\n", + "\n", + " Parameters\n", + " ----------\n", + " df_orig : pandas DataFrame\n", + " containing information about the `lhs` variable as well as other variables to be\n", + " used as regressors in the OLS model. Should have `ccode` as one of the index\n", + " columns.\n", + " lhs : str\n", + " information in `df_orig` to be used as the regressand\n", + " fe : boolean\n", + " if True, creates and applies country-level fixed effects to the OLS; if False,\n", + " does not create the said fixed effects\n", + " exclude_rhs : array-like of str\n", + " contains column names in `df_orig` that should not be used as regressors\n", + "\n", + " Returns\n", + " -------\n", + " ols_results : statsmodels.regression.linear_model.RegressionResults\n", + " containing OLS results\n", + "\n", + " \"\"\"\n", + "\n", + " c = np.sort(df_orig.index.get_level_values(\"ccode\").unique())\n", + " rhs = [x for x in df_orig.columns if (x not in list(exclude_rhs) + [lhs])]\n", + " df = df_orig.reset_index()\n", + "\n", + " if fe:\n", + " df = pd.concat([df, pd.get_dummies(df[\"ccode\"])], axis=1)\n", + " ols_setup = sm.OLS(df[lhs], sm.add_constant(df[rhs + list(c[1:])]))\n", + " ols_results = ols_setup.fit(cov_kwds={\"groups\": df.ccode}, cov_type=\"cluster\")\n", + " else:\n", + " ols_setup = sm.OLS(df[lhs], sm.add_constant(df[rhs]))\n", + " ols_results = ols_setup.fit(cov_kwds={\"groups\": df.ccode}, cov_type=\"cluster\")\n", + "\n", + " return ols_results" + ] + }, + { + "cell_type": "markdown", + "id": "46ee6add-c3ff-4e93-ae12-a743cc979445", + "metadata": {}, + "source": [ + "Based on better adjusted $R^2$, AIC, and BIC values, we will stick with the regression with demographic variables included (as opposed to that without)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ef79fec-182e-4963-94f9-116d24d0853c", + "metadata": {}, + "outputs": [], + "source": [ + "histreg_demog = ols_with_selected(hist_fit_df, \"iy_ratio\")\n", + "demog_vars = [\n", + " x for x in hist_fit_df.columns if (\"D1\" in x) or (\"D2\" in x) or (\"D3\" in x)\n", + "]\n", + "demog_vars += [\"gdp_source\", \"demo_var_source\"]\n", + "histreg_nodemog = ols_with_selected(hist_fit_df, \"iy_ratio\", exclude_rhs=demog_vars)\n", + "\n", + "d_ar2 = round(histreg_demog.rsquared_adj, 4)\n", + "n_ar2 = round(histreg_nodemog.rsquared_adj, 4)\n", + "print(\"With demog. adj R2: {}, no demog. adj R2: {}\".format(d_ar2, n_ar2))\n", + "print(\"With demog. has better AIC:\", histreg_nodemog.aic > histreg_demog.aic)\n", + "print(\"With demog. has better BIC:\", histreg_nodemog.bic > histreg_demog.bic)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc9d1487-2e36-4a3c-a916-cad2ff7641e9", + "metadata": {}, + "outputs": [], + "source": [ + "res_cols = [\"ghat\", \"ghat_sq\", \"yhat_rate\", \"yhr_sq\", \"D1\", \"D2\", \"D3\"]\n", + "res_cols += [\"D1_x_ghat\", \"D2_x_ghat\", \"D3_x_ghat\"]\n", + "res_df = pd.DataFrame(histreg_demog.params, columns=[\"d_beta\"]).loc[res_cols, :]\n", + "d_bse, d_p = histreg_demog.bse, histreg_demog.pvalues\n", + "d_bse.name, d_p.name = \"d_se\", \"d_p\"\n", + "\n", + "nd_param = histreg_nodemog.params\n", + "nd_param.name = \"nd_beta\"\n", + "nd_bse, nd_p = histreg_nodemog.bse, histreg_nodemog.pvalues\n", + "nd_bse.name, nd_p.name = \"nd_se\", \"nd_p\"\n", + "\n", + "for l in [d_bse, d_p, nd_param, nd_bse, nd_p]:\n", + " res_df = res_df.join(l, how=\"left\")\n", + "\n", + "print(res_df)\n", + "\n", + "ctries = [x for x in d_p.index.values if (len(x) == 3) or (x not in res_cols)]\n", + "d_fes, nd_fes = d_p.loc[ctries].values, nd_p.loc[ctries].values\n", + "print()\n", + "print(\n", + " \"FEs significant (%), D:\",\n", + " round(len(d_fes[d_fes < 0.05]) / len(ctries), 4) * 100,\n", + " \"; ND:\",\n", + " round(len(nd_fes[nd_fes < 0.05]) / len(ctries), 4) * 100,\n", + ")\n", + "print()\n", + "print(histreg_nodemog.aic, histreg_demog.aic)\n", + "print(histreg_nodemog.bic, histreg_demog.bic)" + ] + }, + { + "cell_type": "markdown", + "id": "e3db9662-f4f2-45aa-bb87-e46c86af024e", + "metadata": {}, + "source": [ + "We will also estimate the model without fixed effects due to some countries having no I-Y information whatsoever (but we still need to estimate their information). Based on better adjusted $R^2$, AIC, and BIC values, we will again stick with the regression with demographic variables included. Unfortunately, the $R^2$ is not too high without the fixed effects involved." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f811708b-4614-4e11-b2d7-72f832729cf1", + "metadata": {}, + "outputs": [], + "source": [ + "histreg_demog_nofe = ols_with_selected(hist_fit_df, \"iy_ratio\", False)\n", + "histreg_nodemog_nofe = ols_with_selected(hist_fit_df, \"iy_ratio\", False, demog_vars)\n", + "\n", + "d_ar2 = round(histreg_demog_nofe.rsquared_adj, 4)\n", + "n_ar2 = round(histreg_nodemog_nofe.rsquared_adj, 4)\n", + "print(\"With demog. adj R2: {}, no demog. adj R2: {}\".format(d_ar2, n_ar2))\n", + "print(\"With demog. has better AIC:\", histreg_nodemog_nofe.aic > histreg_demog_nofe.aic)\n", + "print(\"With demog. has better BIC:\", histreg_nodemog_nofe.bic > histreg_demog_nofe.bic)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5aedb551-c95d-443f-bf8d-af5570cf5409", + "metadata": {}, + "outputs": [], + "source": [ + "res_df2 = pd.DataFrame(histreg_demog_nofe.params, columns=[\"d_beta\"]).loc[res_cols, :]\n", + "d_bse, d_p = histreg_demog_nofe.bse, histreg_demog_nofe.pvalues\n", + "d_bse.name, d_p.name = \"d_se\", \"d_p\"\n", + "\n", + "nd_param = histreg_nodemog_nofe.params\n", + "nd_param.name = \"nd_beta\"\n", + "nd_bse, nd_p = histreg_nodemog_nofe.bse, histreg_nodemog_nofe.pvalues\n", + "nd_bse.name, nd_p.name = \"nd_se\", \"nd_p\"\n", + "\n", + "for l in [d_bse, d_p, nd_param, nd_bse, nd_p]:\n", + " res_df2 = res_df2.join(l, how=\"left\")\n", + "\n", + "print(res_df2)\n", + "print()\n", + "print(histreg_nodemog_nofe.aic, histreg_demog_nofe.aic)\n", + "print(histreg_nodemog_nofe.bic, histreg_demog_nofe.bic)" + ] + }, + { + "cell_type": "markdown", + "id": "9adec3a9-3c54-462b-ae50-689fd17c35d8", + "metadata": {}, + "source": [ + "### Projections for missing I-Y ratios\n", + "\n", + "#### Projections for those with partial I-Y information" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4dadb3bd-daef-4173-8d33-5b02663f37ce", + "metadata": {}, + "outputs": [], + "source": [ + "yes_fe = np.sort(hist_fit_df.index.get_level_values(\"ccode\").unique())\n", + "yes_fe_fit = hist_reg_df.loc[(yes_fe, slice(None)), :].reset_index()\n", + "yes_fe_fit = pd.concat([yes_fe_fit, pd.get_dummies(yes_fe_fit.ccode)], axis=1)\n", + "yes_fe_fit[\"iy_ratio_pred\"] = histreg_demog.predict(\n", + " sm.add_constant(yes_fe_fit)[histreg_demog.params.index.values]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5209502c-5ea1-4675-9277-e3f743f8b7cf", + "metadata": {}, + "source": [ + "#### Projections for those with no I-Y information" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f326334a-9668-43cd-a22a-8e0b444fbdd1", + "metadata": {}, + "outputs": [], + "source": [ + "no_fe_fit = hist_reg_df.loc[\n", + " ~hist_reg_df.index.get_level_values(\"ccode\").isin(yes_fe), :\n", + "].reset_index()\n", + "no_fe_fit[\"iy_ratio_pred\"] = histreg_demog_nofe.predict(\n", + " sm.add_constant(no_fe_fit)[histreg_demog_nofe.params.index.values]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f1465492-f5a8-48f5-82af-bf65bcfb0aba", + "metadata": {}, + "source": [ + "#### Merging the two cases" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f17dbb06-7024-49a5-920b-295a7f4b02cb", + "metadata": {}, + "outputs": [], + "source": [ + "cols = [\"ccode\", \"year\", \"iy_ratio\", \"iy_ratio_pred\"]\n", + "fitted_iy = pd.concat([yes_fe_fit[cols], no_fe_fit[cols]], axis=0).set_index(cols[0:2])\n", + "fitted_iy[\"iy_ratio_fit\"] = fitted_iy[\"iy_ratio\"]\n", + "fitted_iy.loc[pd.isnull(fitted_iy.iy_ratio), \"iy_ratio_fit\"] = fitted_iy.loc[\n", + " pd.isnull(fitted_iy.iy_ratio), \"iy_ratio_pred\"\n", + "].values" + ] + }, + { + "cell_type": "markdown", + "id": "594ff4c5-5d0b-4775-b287-0a7df19db6be", + "metadata": {}, + "source": [ + "#### Some diagnostics (graphing, checking whether any values are above 1 or below 0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1cbd71a8-080e-4eef-9184-6962d0d0aafb", + "metadata": {}, + "outputs": [], + "source": [ + "def graph_trajectory(ctry, df=fitted_iy):\n", + " \"\"\"Creates a simple graph drawing the actual investment-to-GDP ratio in the data\n", + " and the fitted (or predicted) investment-to-GDP ratio using the OLS model, for a\n", + " single country specified by `ctry`\n", + "\n", + " Parameters\n", + " ----------\n", + " ctry : str\n", + " name of the country\n", + " df : pandas DataFrame\n", + " DataFrame containing the variables `iy_ratio` (for the actual investment-to-GDP\n", + " ratios) and `iy_ratio_pred` (for the predicted investment-to-GDP ratios)\n", + " with indices `ccode` (for country-codes) and `year`, in that order\n", + "\n", + " Returns\n", + " -------\n", + " None, but produces the aforementioned graphs for `ctry`\n", + "\n", + " \"\"\"\n", + " years = np.sort(df.index.get_level_values(\"year\").unique())\n", + " actual = df.loc[(ctry, slice(None)), \"iy_ratio\"].values\n", + " fitted = df.loc[(ctry, slice(None)), \"iy_ratio_pred\"].values\n", + "\n", + " plt.figure(figsize=(9, 6))\n", + " if not pd.isnull(actual).all():\n", + " plt.plot(years, actual, label=\"Actual I-Y\", color=\"black\")\n", + " plt.plot(years, fitted, label=\"Fitted I-Y\", color=\"orange\")\n", + " plt.xlabel(\"Year\")\n", + " plt.ylabel(\"Investment-to-GDP ratio\")\n", + " plt.title(\"Investment-to-GDP ratio for {}\".format(ctry))\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b931dbf-7758-4b10-91b1-2ee7aaa36435", + "metadata": {}, + "outputs": [], + "source": [ + "graph_trajectory(\"ARG\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bf582af-629b-465e-a63d-260a7d1e4522", + "metadata": {}, + "outputs": [], + "source": [ + "graph_trajectory(\"USA\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efb40f26-58bd-4d46-9f9f-138e7f161e6b", + "metadata": {}, + "outputs": [], + "source": [ + "## not-so-good case with Libya\n", + "graph_trajectory(\"LBY\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27af47ff-8d0f-4f9b-938b-effac035dcbf", + "metadata": {}, + "outputs": [], + "source": [ + "## not-so-good case with China\n", + "graph_trajectory(\"CHN\")" + ] + }, + { + "cell_type": "markdown", + "id": "0b2b0105-ec81-4ca7-82f1-a43a5ba81c78", + "metadata": {}, + "source": [ + "We can also see that there are some cases where the I-Y ratios are lesser than 0 or larger than 1; however, these are all from the original sources (mostly from PWT10.0's `csh_i` variable, except for `LBY` where the values are from IMF). Therefore, we will keep things as is and accept these values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a23feb54-3a99-4fb5-8c67-864a4e3c0aff", + "metadata": {}, + "outputs": [], + "source": [ + "fitted_iy.loc[(fitted_iy.iy_ratio_fit < 0) | (fitted_iy.iy_ratio_fit > 1)]" + ] + }, + { + "cell_type": "markdown", + "id": "ffbb21fc-509a-421e-b8c9-cefd8e27e89f", + "metadata": {}, + "source": [ + "## Updating the predicted I-Y ratios and re-exporting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe99bc37-ea40-4dda-97fb-7432e4e373ed", + "metadata": {}, + "outputs": [], + "source": [ + "iyinfo = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_capital_1950_2020_post_ypk3.parquet\"\n", + ")\n", + "iyinfo = iyinfo.merge(\n", + " fitted_iy[[\"iy_ratio_fit\"]],\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "\n", + "iyinfo.loc[\n", + " ~pd.isnull(iyinfo.iy_ratio_fit) & pd.isnull(iyinfo.iy_ratio), \"iy_ratio_source\"\n", + "] = \"hist_reg_project\"\n", + "\n", + "iyinfo.loc[(\"SHN\", list(range(1950, 2014))), \"iy_ratio_source\"] = \"hist_reg_project_avg\"\n", + "iyinfo.to_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_capital_1950_2020_post_ypk4.parquet\"\n", + ")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk4_impute_hist_capital.ipynb b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk4_impute_hist_capital.ipynb new file mode 100644 index 0000000..bcfe038 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk4_impute_hist_capital.ipynb @@ -0,0 +1,1304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1319c0da-f541-486b-bb36-b17b422b3551", + "metadata": { + "tags": [] + }, + "source": [ + "## Code for output of historical (1950-2020) country-level capital stock projections (and actual values whenever possible)\n", + "\n", + "Using the I-Y (investment-to-GDP) ratio projections and GDP projections in the previous notebooks, we project the capital stock values (at the country-level).\n", + "\n", + "## Setting\n", + "\n", + "### Importing necessary modules" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8317fc9e-85cb-4ba2-a70c-385af99ef86f", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "420b64af-3878-402a-91ae-84d17c6ee67c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "from sklearn.cluster import KMeans\n", + "from tqdm.auto import tqdm\n", + "\n", + "from sliiders import country_level_ypk as ypk_fn\n", + "from sliiders import settings as sset\n", + "\n", + "## variables header\n", + "v_ = [\"v_\" + str(x) for x in range(1950, 2020)]" + ] + }, + { + "cell_type": "markdown", + "id": "e82a028b-9a84-40bc-8245-a008be123d41", + "metadata": {}, + "source": [ + "## Getting the investment values\n", + "\n", + "The investment values can be found by multiplying the GDP values ($Y_{c, t}$) with investment-to-GDP ratios (i.e., I-Y ratios and denoted $\\left(\\frac{I}{Y}\\right)_{c, t}$). This is needed as we would like to project missing capital stock values in the years 1950-2020.\n", + "\n", + "We will use the GDP (`cgdpo` series) in conjunction with actual + predicted I-Y ratios as current PPP values are what are used in PWT's method of finding the \"initial capital stock value\" (at 1950 or a later year that is as early as possible).\n", + "\n", + "### Preparations and creating current PPP, 2017 USD" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd1ab6ef-1e0a-48db-9669-94f63fd4fc97", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "## importing GDP (cgdpo, current PPP, 2017 USD) and I-Y ratio and create investment\n", + "histinfo = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_capital_1950_2020_post_ypk4.parquet\"\n", + ")\n", + "histinfo.loc[pd.isnull(histinfo.iy_ratio_fit), \"iy_ratio_fit\"] = 0\n", + "histinfo[\"curr_ppp_invest\"] = histinfo[\"cgdpo_17\"] * histinfo[\"iy_ratio_fit\"]" + ] + }, + { + "cell_type": "markdown", + "id": "baecbd82-925c-45e0-aa39-e400c910a473", + "metadata": {}, + "source": [ + "### Fetching the PPP conversion table for year-to-year conversion\n", + "\n", + "For the PWT method of finding the initial capital, what we want is to add year-$t$ current PPP investment (generated above) to the year-$t$ current PPP capital stock, take care of capital depreciation, and get the year-$t+1$ capital stock. However, the said year-$t+1$ value will be in year-$t$ PPP, so we need to get year-$t$-to-year-$t+1$ PPP conversion rates." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00755f23-899f-43e6-9aa2-4066e7b2d586", + "metadata": {}, + "outputs": [], + "source": [ + "## ppp table for capital stock\n", + "ppp_to_2017_K = ypk_fn.ppp_conversion_specific_year(2017, True, True, pwtvar=\"pl_n\")\n", + "ppp_to_2017_K.loc[pd.isnull(ppp_to_2017_K.conv), \"conv\"] = 1\n", + "\n", + "ppp_K_yr_to_yr = ppp_to_2017_K[[\"conv\"]].rename(columns={\"conv\": \"conv_curr_yr\"})\n", + "ppp_K_next_yr = ppp_to_2017_K[[\"conv\"]].rename(columns={\"conv\": \"conv_next_yr\"})\n", + "ppp_K_next_yr.reset_index(inplace=True)\n", + "ppp_K_next_yr[\"year\"] = ppp_K_next_yr[\"year\"] - 1\n", + "ppp_K_yr_to_yr = ppp_K_yr_to_yr.merge(\n", + " ppp_K_next_yr.set_index([\"ccode\", \"year\"]),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "ppp_K_yr_to_yr[\"conv\"] = ppp_K_yr_to_yr[\"conv_curr_yr\"] / ppp_K_yr_to_yr[\"conv_next_yr\"]\n", + "\n", + "## we don't have 2019-to-2020 rates, so we will assume that there is no PPP rate change\n", + "ppp_K_yr_to_yr.loc[(slice(None), 2019), \"conv\"] = 1" + ] + }, + { + "cell_type": "markdown", + "id": "d2cda573-4c56-4dc6-a3c2-2c1faf55bb4f", + "metadata": {}, + "source": [ + "## Projecting missing values of capital stock\n", + "\n", + "The overall methodology for projection of missing capital stock values can be summarized as follows:\n", + "1) For countries whose information exist only in LitPop, organize 2014 data and use (estimated) investment and depreciation rate values to project 2015-2019 data.\n", + "2) For countries whose information exist only in GEG-15, organize 2005 data and use (estimated) investment and depreciation rate values to project 2006-2019 data.\n", + "3) After Steps 1 and 2, 2014-2019 capital stock values will be available for all countries. Turn those capital stock values into current PPP terms (for PWT10.0 ones, just use `cn`) and calculate the ratios of current-PPP capital stock to current-PPP GDP (`cgdpo`, current PPP, 2017 USD in particular).\n", + "4) Use `k`-nearest neighbors to make unsupervised classifications of countries based on the above-calculated capital-stock-to-GDP ratios.\n", + "\n", + "### Preparations (importing data, cleaning to current PPP, 2017 USD)\n", + "\n", + "We import the `cn` (current PPP, 2017 USD) and `rnna` (constant 2017 PPP USD) capital stock series from PWT. \n", + "\n", + "Also, we import LitPop data which is assumed to be in constant 2014 PPP USD (and are in ones of USD). LitPop's original source data for capital is from World Bank (link [here](https://datacatalog.worldbank.org/dataset/wealth-accounting)), which multiplies 1.24 to their values to also account for land values. We want only the capital values, so land values must be removed; LitPop already has taken care of this multiplier, so it can be used as is (can be confirmed by comparing numbers in the link above).\n", + "\n", + "Finally, we import GEG-15 data which is assumed to be in constant 2005 PPP USD (and are in millions of USD). This data also includes land values, so we divide the values by 1.24 to acquire only the capital stock values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "000ab181-d963-4d78-93aa-f1928e027da8", + "metadata": {}, + "outputs": [], + "source": [ + "# skip this cell if GEG has been already cleaned up at the country level\n", + "geg_coord = pd.read_parquet(sset.PATH_GEG15_INT).rename(columns={\"iso3\": \"ccode\"})\n", + "geg = geg_coord.groupby(\"ccode\")[\"tot_val\"].sum()\n", + "geg = pd.DataFrame(data={\"ccode\": geg.index, \"value\": geg.values})\n", + "\n", + "# country-level information\n", + "geg.to_parquet(sset.DIR_YPK_INT / \"geg-15_ctry_lv.parquet\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4235387-e433-4dac-aaa6-7c99b17772fc", + "metadata": {}, + "outputs": [], + "source": [ + "# PWT10.0\n", + "pwt100 = (\n", + " pd.read_excel(sset.PATH_PWT_RAW)\n", + " .rename(columns={\"countrycode\": \"ccode\"})\n", + " .set_index([\"ccode\", \"year\"])\n", + ")\n", + "capdata = histinfo[[\"cgdpo_17\", \"rgdpna_17\", \"curr_ppp_invest\", \"delta\"]].merge(\n", + " pwt100[[\"cn\", \"rnna\"]],\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "\n", + "# for litpop and geg-15, we retain current PPP but adjust from current USD to\n", + "# constant USD.\n", + "\n", + "# litpop\n", + "litpop_meta = pd.read_csv(sset.DIR_LITPOP_RAW / \"_metadata_countries_v1_2.csv\").rename(\n", + " columns={\"iso3\": \"ccode\", \"total_value [USD]\": \"litpop_cn\"}\n", + ")\n", + "litpop_meta = litpop_meta[~pd.isnull(litpop_meta.litpop_cn)]\n", + "litpop_meta[\"year\"] = 2014\n", + "usd_14_to_17 = pwt100.loc[(\"USA\", 2017), \"pl_n\"] / pwt100.loc[(\"USA\", 2014), \"pl_n\"]\n", + "litpop_meta[\"litpop_cn\"] = litpop_meta[\"litpop_cn\"] / 1000000 * usd_14_to_17\n", + "litpop_meta.set_index([\"ccode\", \"year\"], inplace=True)\n", + "\n", + "### geg-15\n", + "ctry_lv_geg = pd.read_parquet(sset.DIR_YPK_INT / \"geg-15_ctry_lv.parquet\").reset_index()\n", + "ctry_lv_geg[\"year\"] = 2005\n", + "ctry_lv_geg = ctry_lv_geg.astype({\"value\": \"float64\"}).set_index([\"ccode\", \"year\"])\n", + "usd_05_to_17 = pwt100.loc[(\"USA\", 2017), \"pl_n\"] / pwt100.loc[(\"USA\", 2005), \"pl_n\"]\n", + "ctry_lv_geg[\"value\"] = ctry_lv_geg[\"value\"] / 1.24 * usd_05_to_17\n", + "ctry_lv_geg.rename(columns={\"value\": \"geg_cn\"}, inplace=True)\n", + "\n", + "## merging all\n", + "capdata = capdata.merge(ctry_lv_geg, left_index=True, right_index=True, how=\"left\")\n", + "capdata = capdata.merge(\n", + " litpop_meta[[\"litpop_cn\"]], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "\n", + "## we also merge the year-to-year PPP conversion rates\n", + "capdata = capdata.merge(\n", + " ppp_K_yr_to_yr[[\"conv\"]], left_index=True, right_index=True, how=\"left\"\n", + ").drop([\"index\"], axis=1)\n", + "capdata.loc[pd.isnull(capdata.conv), \"conv\"] = 1" + ] + }, + { + "cell_type": "markdown", + "id": "8eeae094-d0d7-49b7-8ee5-433796862f75", + "metadata": {}, + "source": [ + "Let us fill in the capital values of uninhabited areas to be 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a56796f-ee84-4f67-81ac-f28bcf011162", + "metadata": {}, + "outputs": [], + "source": [ + "## uninhabited areas\n", + "for i in sset.UNINHABITED_ISOS:\n", + " capdata.loc[i, [\"cn\"]] = 0\n", + " capdata.loc[i, [\"rnna\"]] = 0" + ] + }, + { + "cell_type": "markdown", + "id": "b5d8656a-c466-4edc-887a-a9e7f14026ac", + "metadata": {}, + "source": [ + "### 2014-2020 projection for LitPop values, 2005-2020 projection for GEG-15 values, and 2020 projection for PWT10.0 (all in current PPP)\n", + "\n", + "#### Log-linear interpolation for LitPop and GEG-15\n", + "\n", + "In the case where 2014 value exists in LitPop and 2005 value exists in GEG-15, we will not try to extrapolate the 2005-2014 values via perpetual inventory method (PIM) but rather by log-linear interpolation. Note that this will only be done for countries *not* having PWT10.0 capital stock information." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85e4b9de-3858-42ff-b704-09340228e7e1", + "metadata": {}, + "outputs": [], + "source": [ + "## getting the relevant ccodes\n", + "ccodes = capdata.index.get_level_values(\"ccode\").unique()\n", + "pwt_cc = capdata.loc[~pd.isnull(capdata.cn), :].index.get_level_values(\"ccode\").unique()\n", + "lp_cc = (\n", + " capdata.loc[~pd.isnull(capdata.litpop_cn), :]\n", + " .index.get_level_values(\"ccode\")\n", + " .unique()\n", + ")\n", + "geg_cc = (\n", + " capdata.loc[~pd.isnull(capdata.geg_cn), :].index.get_level_values(\"ccode\").unique()\n", + ")\n", + "lp_cc = np.setdiff1d(lp_cc, pwt_cc)\n", + "geg_cc = np.setdiff1d(geg_cc, pwt_cc)" + ] + }, + { + "cell_type": "markdown", + "id": "f4b7d077-6e17-4a2b-8d2f-06406cc1ead3", + "metadata": {}, + "source": [ + "We notice, however, that there are some additional *inhabited* countries or regions that are absolutely missing all (1950-2020) capital stock information. In this case, we follow LitPop and assume that the 2014 value of capital stock for these countries is **1.247240** times the 2014 value of GDP (`cgdpo_17`, in this case). We will include these in the column `litpop_cn`. We will include these in the set of LitPop countries for now." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50e2a01c-c3d5-4a3a-9417-b9f1fa371ff5", + "metadata": {}, + "outputs": [], + "source": [ + "no_k_cc = np.setdiff1d(\n", + " ccodes,\n", + " np.union1d(np.union1d(np.union1d(lp_cc, geg_cc), pwt_cc), sset.UNINHABITED_ISOS),\n", + ")\n", + "print(no_k_cc)\n", + "\n", + "litpop_ky_ratio = 1.247240\n", + "for i in no_k_cc:\n", + " capdata.loc[(i, 2014), \"litpop_cn\"] = (\n", + " litpop_ky_ratio * capdata.loc[(i, 2014), \"cgdpo_17\"]\n", + " )\n", + "\n", + "lp_cc = np.union1d(lp_cc, no_k_cc)\n", + "lp_geg_cc = np.intersect1d(lp_cc, geg_cc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a12b978-f12e-41a9-b8fb-c62ca72a4d09", + "metadata": {}, + "outputs": [], + "source": [ + "## interpolating\n", + "capdata[\"litpop_geg_cn\"] = np.nan\n", + "for i in lp_geg_cc:\n", + " val05 = capdata.loc[(i, 2005), \"geg_cn\"]\n", + " val14 = capdata.loc[(i, 2014), \"litpop_cn\"]\n", + " val05_14 = np.exp(\n", + " np.interp(range(2005, 2015), [2005, 2014], np.log([val05, val14]))\n", + " )\n", + " capdata.loc[(i, list(range(2005, 2015))), \"litpop_geg_cn\"] = val05_14" + ] + }, + { + "cell_type": "markdown", + "id": "eb14c7a0-ee26-4b6c-9e4b-51e73817e58d", + "metadata": { + "tags": [] + }, + "source": [ + "#### PIM projection for LitPop-GEG (2014-2020), LitPop-only (2014-2020), GEG-15-only (2005-2020), and PWT10.0 (2019-2020)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e3f9c39-98ac-46c7-bc83-f9fc095c5d95", + "metadata": {}, + "outputs": [], + "source": [ + "def capital_perp_inven(\n", + " currK_var=\"litpop_cn\",\n", + " currI_var=\"curr_ppp_invest\",\n", + " depre_var=\"delta\",\n", + " ppp_conv_var=\"conv\",\n", + " begin_end=[2014, 2020],\n", + " df=capdata,\n", + "):\n", + " \"\"\"Using the investment values in `currI_var`, depreciation rate values in\n", + " `depre_var`, and capital stock values in `currK_var`, conduct the perpertual\n", + " inventory method to acquire capital stock values' estimates. In every step,\n", + " the capital values are calculated as current PPP values.\n", + "\n", + " Parameters\n", + " ----------\n", + " currK_var : str\n", + " variable name in `df` to contain known current-PPP capital stock values\n", + " currI_var : str\n", + " variable name in `df` to contain current-PPP investment values\n", + " depre_var : str\n", + " variable name in `df` to contain depreciation rate values\n", + " ppp_conv_var : str\n", + " variable name in `df` to contain the year-to-next-year conversion rates in PPP\n", + " begin_end : array-like of int\n", + " contains the year to begin the perpetual inventory method on and to end the said\n", + " method on\n", + " df : pandas DataFrame\n", + " containing the necessary variables (`currK_var`, `currI_var`, `depre_var`, and\n", + " `ppp_conv_var`) with indices `ccode` for country-code and `year`, in that order\n", + "\n", + " Returns\n", + " -------\n", + " df : pandas DataFrame\n", + " containing information with the perpetual inventory method applied to produce\n", + " estimates for (future) capital stock values\n", + "\n", + " \"\"\"\n", + "\n", + " newvar = currK_var + \"_proj\"\n", + " df[newvar] = df[currK_var].values\n", + " for i in range(begin_end[0], begin_end[-1]):\n", + " grossK = df.loc[\n", + " (slice(None), i), [newvar, currI_var, depre_var, ppp_conv_var]\n", + " ].copy()\n", + " grossK[\"next_year_K\"] = (\n", + " (grossK[newvar] + grossK[currI_var])\n", + " * (1 - grossK[depre_var])\n", + " * (grossK[ppp_conv_var])\n", + " )\n", + " grossK.reset_index(inplace=True)\n", + " grossK[\"year\"] = grossK[\"year\"] + 1\n", + " grossK.set_index([\"ccode\", \"year\"], inplace=True)\n", + " df = df.merge(\n", + " grossK[[\"next_year_K\"]], left_index=True, right_index=True, how=\"left\"\n", + " )\n", + " df.loc[(slice(None), i + 1), newvar] = df.loc[\n", + " (slice(None), i + 1), \"next_year_K\"\n", + " ].values\n", + " df.drop([\"next_year_K\"], axis=1, inplace=True)\n", + "\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cac9e416-d97c-4543-bbc8-59a6fda1db6a", + "metadata": {}, + "outputs": [], + "source": [ + "## updating litpop\n", + "capdata = capital_perp_inven(df=capdata)\n", + "\n", + "## updating geg-15\n", + "capdata = capital_perp_inven(\"geg_cn\", begin_end=[2005, 2020], df=capdata)\n", + "\n", + "## updating litpop-geg-15\n", + "capdata = capital_perp_inven(\"litpop_geg_cn\", df=capdata)\n", + "\n", + "## updating cn for PWT10.0\n", + "capdata = capital_perp_inven(\"cn\", begin_end=[2019, 2020], df=capdata)" + ] + }, + { + "cell_type": "markdown", + "id": "9776f721-9f65-4311-bbda-7ef6f3889455", + "metadata": {}, + "source": [ + "#### Creating a single current PPP, 2017 USD capital stock series (`cn_extrap`) for the data so far and tagging sources\n", + "\n", + "Again, we prioritize PWT10.0, then LitPop-GEG-15, then LitPop, then finally GEG-15." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9517dc36-1d6d-4d0d-8071-08896c37f58d", + "metadata": {}, + "outputs": [], + "source": [ + "## filling in the values\n", + "capdata[\"cn_extrap\"] = capdata[\"cn_proj\"].values\n", + "capdata.loc[(lp_geg_cc, slice(None)), \"cn_extrap\"] = capdata.loc[\n", + " (lp_geg_cc, slice(None)), \"litpop_geg_cn_proj\"\n", + "].values\n", + "lp_only = np.setdiff1d(lp_cc, lp_geg_cc)\n", + "capdata.loc[(lp_only, slice(None)), \"cn_extrap\"] = capdata.loc[\n", + " (lp_only, slice(None)), \"litpop_cn_proj\"\n", + "].values\n", + "geg_only = np.setdiff1d(geg_cc, lp_geg_cc)\n", + "capdata.loc[(geg_only, slice(None)), \"cn_extrap\"] = capdata.loc[\n", + " (geg_only, slice(None)), \"geg_cn_proj\"\n", + "].values\n", + "\n", + "## filling in the source information\n", + "capdata[\"cs\"] = \"-\"\n", + "capdata.loc[~pd.isnull(capdata.cn), \"cs\"] = \"PWT\"\n", + "capdata.loc[~pd.isnull(capdata.cn_proj) & (capdata.cs == \"-\"), \"cs\"] = \"PWT_perp_inven\"\n", + "capdata.loc[~pd.isnull(capdata.litpop_cn) & (capdata.cs == \"-\"), \"cs\"] = \"LitPop\"\n", + "capdata.loc[~pd.isnull(capdata.geg_cn) & (capdata.cs == \"-\"), \"cs\"] = \"GEG-15\"\n", + "\n", + "capdata.loc[\n", + " ~pd.isnull(capdata.litpop_geg_cn) & (capdata.cs == \"-\"), \"cs\"\n", + "] = \"LitPop_GEG-15_interp\"\n", + "capdata.loc[\n", + " ~pd.isnull(capdata.litpop_geg_cn_proj) & (capdata.cs == \"-\"),\n", + " \"cs\",\n", + "] = \"LitPop_perp_inven\"\n", + "capdata.loc[\n", + " ~pd.isnull(capdata.litpop_cn_proj) & (capdata.cs == \"-\"),\n", + " \"cs\",\n", + "] = \"LitPop_perp_inven\"\n", + "capdata.loc[\n", + " ~pd.isnull(capdata.geg_cn_proj) & (capdata.cs == \"-\"), \"cs\"\n", + "] = \"GEG-15_perp_inven\"\n", + "\n", + "capdata.loc[(no_k_cc, [2014]), \"cs\"] = \"mult_LitPop_ratio\"\n", + "capdata.loc[(no_k_cc, list(range(2015, 2021))), \"cs\"] = \"mult_LitPop_perp_inven\"" + ] + }, + { + "cell_type": "markdown", + "id": "48f3ba4b-9631-4b67-b3b3-2d518036b63d", + "metadata": { + "tags": [] + }, + "source": [ + "### Finding the initial capital stock (at the year 1950)\n", + "\n", + "#### Grouping the countries (via $k$-means) to find the optimal rate of change of capital intensity (capital to GDP ratio) and the range of initial capital\n", + "\n", + "The methodology implemented in PWT (as documented in [this PWT9.1 appendix](https://www.rug.nl/ggdc/docs/pwt91_capitalservices_ipmrevision.pdf)) to estimate the initial capital stock is as follows:\n", + "1. Set a lower bound and an upper bound of capital intensity at the initial available year ($t_0$), and multiple the year-$t_0$ value of current PPP GDP to get lower and upper bounds of year-$t_0$ capital stock estimates. In PWT9.1, the values of lower and upper bounds of year-$t_0$ capital intensities are 0.5 and 4.0.\n", + "2. Add on investment values and account for depreciation via the perpetual inventory method (PIM) and \"grow\" the upper and lower capital stocks.\n", + "3. Due to depreciation, there will be a year (call this $t^*$) at which the two (upper and lower) tracks of current-PPP capital become close; PWT9.1 sets the \"closeness\" as 10% (so upper-bound capital is less than 1.1 times lower-bound capital).\n", + "4. Calculate the upper and lower capital intensities at $t^*$, and calculate the simple mean of year-$t^*$ capital intensity (denote by $\\kappa_{t_0}$).\n", + "5. Decrease this year-$t^*$ capital intensity by per-annum capital intensity growth rate (set as $g_\\kappa=0.02$), until it reaches the initial year. So the new initial capital intensity at $t_0$ is $\\kappa_{t_0}= \\kappa_{t^*}- g_\\kappa(t^* - t_0) $.\n", + "6. Multiply this value with the GDP at year-$t_0$ to acquire the year-$t_0$ capital stock value.\n", + "\n", + "While we will follow this methodology, the problem is that the capital intensity growth rate seems to vary a lot country-by-country. Further, the initial lower and upper bounds of capital intensity being 0.5 and 4.0 each does not seem to fit the PWT10.0 update. Therefore, what we will do is the following:\n", + "\n", + "1. Group the countries via $k$-means using their available capital intensities.\n", + "2. For each group, find the earliest-year (preferably 1950) upper and lower bounds of capital intensity.\n", + "3. Also for each group, find the per-annum capital intensity growth rates.\n", + "4. Apply the above-mentioned methodology for each group, using the updated lower / upper bounds of capital intensity at the initial year (1950) and capital intensity growth rates.\n", + "\n", + "For grouping, we try regular $k$-means with only the years that are available currently for all countries (2014-2020) or by filling in the missing pieces using the EM algorithm. The former, in terms of balanced classification, seems to work better, so we go with the regular $k$-means methodology with $k=3$. The EM-augmented $k$-means algorithm is from this [Stack Overflow post](https://stackoverflow.com/questions/35611465/python-scikit-learn-clustering-with-missing-data)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a192c31-d056-4865-af91-ed9bbd39a522", + "metadata": {}, + "outputs": [], + "source": [ + "def kmeans_missing(X, n_clusters, max_iter=10, rand_state=60607):\n", + " \"\"\"Perform K-Means clustering on data with missing values.\n", + "\n", + " Parameters\n", + " ----------\n", + " X : array-like\n", + " wide-format array (with each row being different countries) to conduct the\n", + " EM algorithm and k-means clustering on\n", + " n_clusters : int\n", + " number of clusters to form\n", + " max_iter : int\n", + " maximum number of EM iterations to perform\n", + " rand_state : int\n", + " random state, for replicability\n", + "\n", + " Returns\n", + " -------\n", + " labels : array-like of int\n", + " containing integer labels, based on the EM-augmented k-means algorithm, for each\n", + " row in the array-like `X`\n", + " centroid : array-like\n", + " containing the centroid for each of the k-means label\n", + " X_hat : array-like\n", + " copy of `X` with the missing values filled in using the EM algorithm\n", + "\n", + " \"\"\"\n", + "\n", + " # Initialize missing values to their column means\n", + " missing = ~np.isfinite(X)\n", + " mu = np.nanmean(X, 0, keepdims=1)\n", + " X_hat = np.where(missing, mu, X)\n", + "\n", + " for i in range(max_iter):\n", + " if i > 0:\n", + " # initialize KMeans with the previous set of centroids. this is much\n", + " # faster and makes it easier to check convergence (since labels\n", + " # won't be permuted on every iteration), but might be more prone to\n", + " # getting stuck in local minima.\n", + " clus = KMeans(n_clusters, init=prev_centroids, random_state=rand_state)\n", + " else:\n", + " # do multiple random initializations in parallel\n", + " clus = KMeans(n_clusters, random_state=rand_state)\n", + "\n", + " # perform clustering on the filled-in data\n", + " labels = clus.fit_predict(X_hat)\n", + " centroids = clus.cluster_centers_\n", + "\n", + " # fill in the missing values based on their cluster centroids\n", + " X_hat[missing] = centroids[labels][missing]\n", + "\n", + " # when the labels have stopped changing then we have converged\n", + " if i > 0 and np.all(labels == prev_labels):\n", + " break\n", + "\n", + " prev_labels = labels\n", + " prev_centroids = clus.cluster_centers_\n", + "\n", + " return labels, centroids, X_hat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eeffa752-d181-4853-a81a-bc931619ebcb", + "metadata": {}, + "outputs": [], + "source": [ + "## set aside the uninhabited areas\n", + "uninh_capdata = capdata.loc[sset.UNINHABITED_ISOS, :].copy()\n", + "capdata = capdata.loc[\n", + " ~capdata.index.get_level_values(\"ccode\").isin(sset.UNINHABITED_ISOS), :\n", + "].sort_index()\n", + "\n", + "## creating K-Y ratios dataset, horizontal form (for k-means)\n", + "capdata[\"cap_intensity\"] = capdata[\"cn_extrap\"] / capdata[\"cgdpo_17\"]\n", + "cap_intensity = ypk_fn.organize_ver_to_hor(\n", + " capdata,\n", + " \"cap_intensity\",\n", + " \"year\",\n", + " \"ccode\",\n", + " range(1950, 2021),\n", + ")\n", + "all_kys = [\"v_\" + str(X) for X in range(1950, 2021)]\n", + "cap_intensity[all_kys] = cap_intensity[all_kys].astype(\"float64\")\n", + "\n", + "## we can use only the filled information; initializing clustering algorithms\n", + "cluster_3 = KMeans(n_clusters=3, random_state=60607)\n", + "comp_ky_s_filled = [\"v_\" + str(X) for X in range(2014, 2021)]\n", + "cap_intensity[\"cl3\"] = cluster_3.fit(cap_intensity[comp_ky_s_filled].values).labels_\n", + "\n", + "## based on balanced classification, 3 seems to be the most optimal\n", + "## with EM algorithm as well\n", + "em_kmeans = kmeans_missing(cap_intensity[all_kys], 3)\n", + "cap_intensity[\"cl3_em\"] = em_kmeans[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2848acfb-dde1-4016-9f38-97c2d9a06700", + "metadata": {}, + "outputs": [], + "source": [ + "## trying to see the balancedness between regular k-means and EM-augmented version\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n", + "ax1.hist(cap_intensity[\"cl3\"].astype(\"int64\"))\n", + "ax1.set_xticks([0, 1, 2])\n", + "\n", + "ax2.hist(cap_intensity[\"cl3_em\"].astype(\"int64\"))\n", + "ax2.set_xticks([0, 1, 2])\n", + "\n", + "ax1.set_ylim([0, 160]), ax2.set_ylim([0, 160])\n", + "ax1.set_yticks([0, 40, 80, 120, 160]), ax2.set_yticks([0, 40, 80, 120, 160])\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39c97da5-5b83-41fe-b6c5-805e48b16717", + "metadata": {}, + "outputs": [], + "source": [ + "# em grouping gives only 1 country assigned to the final group\n", + "cap_intensity.reset_index().groupby([\"cl3\"]).count()[[\"ccode\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2fb5792-53ab-4b42-8f40-5dfc38fd6c89", + "metadata": {}, + "outputs": [], + "source": [ + "# replication of Table 1 in Inklaar et al. (Intl Productivity Monitor 2019)\n", + "rows = []\n", + "for i in [1950, 1960, 1970, 1980, 1990, 2000, 2011, 2017]:\n", + " v = f\"v_{i}\"\n", + " row = [i, cap_intensity.loc[~pd.isnull(cap_intensity[v]), :].shape[0]]\n", + " row += [\n", + " round(cap_intensity[v].mean(), 1),\n", + " round(cap_intensity[v].std(), 1),\n", + " round(cap_intensity[v].min(), 1),\n", + " round(cap_intensity[v].max(), 1),\n", + " ]\n", + " rows.append(row)\n", + "np.set_printoptions(suppress=True)\n", + "print(np.array(rows))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2498b437-8ca5-4667-9832-14d301dcd9c3", + "metadata": {}, + "outputs": [], + "source": [ + "## attaching the cluster types\n", + "capdata = capdata.merge(\n", + " cap_intensity[\"cl3\"], left_index=True, right_index=True, how=\"left\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e85f524-75c0-47c8-9094-2e4be0a51494", + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_min_max_growthrate_by_group(\n", + " df=capdata, group=\"cl3\", ratio=\"cap_intensity\"\n", + "):\n", + " \"\"\"By specified `group` designation, calculate the lower and upper bounds of the\n", + " variable `ratio` contained in DataFrame `df`, as well as the said variable's average\n", + " annual growth rate.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : pandas DataFrame\n", + " containing information about the `group` and `ratio`. Should also contain the\n", + " variable `year` as growth rate values are calculated yearly.\n", + " group : str\n", + " column name in `df` that represents the grouping (by k-means clustering or\n", + " other methods)\n", + " ratio : str\n", + " column name in `df` that represents the variable for calculating the lower,\n", + " upper bounds and annual growth rates\n", + "\n", + " Returns\n", + " -------\n", + " growth_rate_df : pandas DataFrame\n", + " containing, by group, the information about lower bound of `ratio` (`ky_lower`,\n", + " and set to be the 10th quantile from the bottom), upper bound of `ratio`\n", + " (`ky_upper`, and set to be the 90th quantile from the bottom), and growth rate\n", + " per annum of `ratio` (`ky_growth`). Also stores the grouping information in the\n", + " variable `cl`.\n", + "\n", + " \"\"\"\n", + "\n", + " growth_rate_df = []\n", + " for cl in np.sort(df[group].unique()):\n", + " cl_df = df.loc[df[group] == cl, [ratio]].copy()\n", + " nona_ratios = cl_df[ratio].values\n", + " nona_ratios = nona_ratios[~pd.isnull(nona_ratios)]\n", + " cl_lower, cl_upper = np.quantile(nona_ratios, [0.1, 0.9])\n", + "\n", + " cl_df = cl_df.loc[~pd.isnull(cl_df[ratio]), :].reset_index()\n", + " cl_growth = sm.OLS(\n", + " cl_df[ratio].astype(\"float64\"),\n", + " sm.add_constant(cl_df[[\"year\"]]).astype(\"float64\"),\n", + " )\n", + " cl_growth = cl_growth.fit().params[\"year\"]\n", + " growth_rate_df.append([cl, cl_lower, cl_upper, cl_growth])\n", + "\n", + " growth_rate_df = pd.DataFrame(\n", + " np.vstack(growth_rate_df),\n", + " columns=[\"cl\", \"ky_lower\", \"ky_upper\", \"ky_growth\"],\n", + " )\n", + "\n", + " return growth_rate_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "377ca697-9eac-47c4-b020-aa2beea3e8c1", + "metadata": {}, + "outputs": [], + "source": [ + "## growth rates, upper and lower bounds for capital intensity\n", + "cl_gr = calculate_min_max_growthrate_by_group(df=capdata).rename(columns={\"cl\": \"cl3\"})\n", + "cl_gr[\"cl3\"] = cl_gr[\"cl3\"].astype(\"int64\")\n", + "capdata = (\n", + " capdata.reset_index()\n", + " .merge(cl_gr, on=[\"cl3\"], how=\"left\")\n", + " .set_index([\"ccode\", \"year\"])\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a8afb79-0b5c-412b-9e7f-c88c51682ae5", + "metadata": {}, + "outputs": [], + "source": [ + "cl_gr" + ] + }, + { + "cell_type": "markdown", + "id": "99832dcb-0c13-446b-9a15-3fc924b3be1d", + "metadata": {}, + "source": [ + "#### Applying PWT 9.1's method, cluster by cluster, and interpolating with the known values of capital\n", + "\n", + "We will also need our investment values to apply the PWT 9.1's method, so we will do so below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44211983-4acc-4563-a2db-8295f08152b0", + "metadata": {}, + "outputs": [], + "source": [ + "def find_init_k(\n", + " df=capdata,\n", + " begin_end=[1950, 2020],\n", + " lb=\"ky_lower\",\n", + " ub=\"ky_upper\",\n", + " gr=\"ky_growth\",\n", + " currK_var=\"cn\",\n", + " currY_var=\"cgdpo_17\",\n", + " currI_var=\"curr_ppp_invest\",\n", + " depre_var=\"delta\",\n", + " ytoy_ppp=\"conv\",\n", + " cluster=\"cl3\",\n", + " ub_lb_thresh=0.1,\n", + "):\n", + " \"\"\"Finding the initial value of capital (at the year specified by `begin_end`)\n", + " based on the methdology of PWT 9.1.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : pandas.DataFrame\n", + " DataFrame to contain all necessary information (current PPP GDP, investment,\n", + " depreciation rates, growth rate, lower bound and upper bound for the capital\n", + " intensity)\n", + " begin_end : array-like of ints\n", + " array-like containing two elements - initial year and the final year to be\n", + " considered by the process\n", + " lb : str\n", + " column name in `df` to indicate the lower bound of capital intensity\n", + " ub : str\n", + " column name in `df` to indicate the upper bound of capital intensity\n", + " gr : str\n", + " column name in `df` to indicate the average yearly growth of capital intensity\n", + " currK_var : str\n", + " column name in `df` for current-PPP capital\n", + " currY_var : str\n", + " column name in `df` for current-PPP GDP\n", + " currI_var : str\n", + " column name in `df` for current-PPP investment\n", + " depre_var : str\n", + " column name in `df` for depreciate rate\n", + " ytoy_ppp : str\n", + " column name in `df` for year-to-next-year PPP conversion rate\n", + " cluster : str\n", + " column name in `df` for cluster (based on capital intensity values)\n", + " ub_lb_thresh : float\n", + " difference between upper- and lower-bound capital stock values to halt and\n", + " acquire year `tstar`\n", + "\n", + " Returns\n", + " -------\n", + " estimated : pandas.DataFrame\n", + " DataFrame with `ccode` (country code) as the index containing initial-year\n", + " capital stock estimations (based on the PWT 9.1 method); only contains\n", + " information if a country was actually missing the initial-year capital stock\n", + "\n", + " \"\"\"\n", + "\n", + " cl_df = df[[cluster, lb, ub, gr, currY_var, currI_var, ytoy_ppp, depre_var]].copy()\n", + " cl_df[\"low_k\"], cl_df[\"high_k\"] = np.nan, np.nan\n", + " for yr in range(begin_end[0], begin_end[-1]):\n", + " ## setting the initial year's lower and upper bound capital\n", + " if yr == begin_end[0]:\n", + " cl_df.loc[(slice(None), yr), \"low_k\"] = (\n", + " cl_df.loc[(slice(None), yr), [currY_var, lb]].product(axis=1).values\n", + " )\n", + " cl_df.loc[(slice(None), yr), \"high_k\"] = (\n", + " cl_df.loc[(slice(None), yr), [currY_var, ub]].product(axis=1).values\n", + " )\n", + " nxt = yr + 1\n", + " for i in [\"low_k\", \"high_k\"]:\n", + " cl_df.loc[(slice(None), nxt), i] = (\n", + " cl_df.loc[(slice(None), yr), [i, currI_var]].sum(axis=1).values\n", + " * (1 - cl_df.loc[(slice(None), yr), depre_var].values)\n", + " * cl_df.loc[(slice(None), yr), ytoy_ppp].values\n", + " )\n", + " cl_df[\"hi_lo_ratio\"] = cl_df[\"high_k\"] / cl_df[\"low_k\"] - 1\n", + "\n", + " ## finding t-star, the year that high- and low-trajectories are lesser than\n", + " ## the threshold set by `ub_lb_thresh`\n", + " tstar_df = (\n", + " cl_df.loc[cl_df.hi_lo_ratio < ub_lb_thresh, :]\n", + " .reset_index()\n", + " .groupby([\"ccode\"])\n", + " .min()[[\"year\"]]\n", + " .rename(columns={\"year\": \"tstar\"})\n", + " )\n", + " cl_df = cl_df.merge(tstar_df, how=\"left\", left_index=True, right_index=True)\n", + "\n", + " ## if tstar is not acquired, get the latest year to be the tstar\n", + " cl_df.loc[pd.isnull(cl_df[\"tstar\"]), \"tstar\"] = begin_end[-1]\n", + "\n", + " ## country-by-country calculation of initial capital for those missing them\n", + " init = df.loc[(slice(None), begin_end[0]), [currK_var]].copy()\n", + " msng_ccodes = (\n", + " init.loc[pd.isnull(init[currK_var]), :].index.get_level_values(\"ccode\").unique()\n", + " )\n", + " estimated = []\n", + " for cc in msng_ccodes:\n", + " ## how many years from tstar to initial year\n", + " tstar = cl_df.loc[(cc, begin_end[0]), \"tstar\"]\n", + " tstar_t0 = tstar - begin_end[0]\n", + "\n", + " ## initial-year capital-to-GDP ratio\n", + " init_ky = cl_df.loc[(cc, [tstar]), [\"high_k\", \"low_k\"]].mean(axis=1).values[\n", + " 0\n", + " ] / cl_df.loc[(cc, tstar), currY_var] - (\n", + " tstar_t0 * cl_df.loc[(cc, begin_end[0]), gr]\n", + " )\n", + " if init_ky < cl_df.loc[(cc, tstar), lb]:\n", + " init_ky = cl_df.loc[(cc, tstar), lb]\n", + " elif init_ky > cl_df.loc[(cc, tstar), ub]:\n", + " init_ky = cl_df.loc[(cc, tstar), ub]\n", + "\n", + " ## initial-year capital value\n", + " init_K = init_ky * cl_df.loc[(cc, begin_end[0]), currY_var]\n", + " estimated.append([cc, init_K])\n", + " estimated = pd.DataFrame(\n", + " np.vstack(estimated), columns=[\"ccode\", \"cn_init_estim\"]\n", + " ).set_index([\"ccode\"])\n", + "\n", + " return estimated" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5912a76a-c9d0-437b-8e27-79a68494a3a3", + "metadata": {}, + "outputs": [], + "source": [ + "## estimating the \"cn_init_estim\" (missing initial-year capital)\n", + "cn_init_estim = find_init_k(capdata)\n", + "\n", + "## merging with the rest\n", + "capdata = capdata.merge(cn_init_estim, left_index=True, right_index=True, how=\"left\")\n", + "capdata.loc[\n", + " (capdata.cs == \"-\")\n", + " & (~pd.isnull(capdata.cn_init_estim))\n", + " & (capdata.index.get_level_values(\"year\") == 1950),\n", + " \"cs\",\n", + "] = \"init_K_estim\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "edc9a75d-a2aa-4ab9-9dd0-3af69deb1b98", + "metadata": {}, + "outputs": [], + "source": [ + "## interpolating the rest, and filling the said values to cn_extrap\n", + "msng_ccodes = (\n", + " capdata.loc[(~pd.isnull(capdata.cn_init_estim)), :]\n", + " .index.get_level_values(\"ccode\")\n", + " .unique()\n", + ")\n", + "capdata[\"cn_init_estim\"] = capdata[\"cn_init_estim\"].astype(\"float64\")\n", + "capdata[\"cn_extrap\"] = capdata[\"cn_extrap\"].astype(\"float64\")\n", + "for i in msng_ccodes:\n", + " ## initial capital that was estimated\n", + " init_K = capdata.loc[(i, 1950), \"cn_init_estim\"]\n", + "\n", + " filled_K = capdata.loc[\n", + " (capdata.index.get_level_values(\"ccode\") == i)\n", + " & (~pd.isnull(capdata.cn_extrap)),\n", + " [\"cn_extrap\"],\n", + " ]\n", + " filled_yr_min = filled_K.index.get_level_values(\"year\").min()\n", + " filled_yr_min_K = capdata.loc[(i, filled_yr_min), \"cn_extrap\"]\n", + "\n", + " interp_K = np.interp(\n", + " range(1950, filled_yr_min + 1),\n", + " [1950, filled_yr_min],\n", + " np.log([init_K, filled_yr_min_K]),\n", + " )\n", + " interp_K = np.exp(interp_K)\n", + " i_yrs = list(range(1950, filled_yr_min + 1))\n", + " capdata.loc[(i, i_yrs), \"cn_extrap\"] = interp_K\n", + " capdata.loc[(i, i_yrs[1:-1]), \"cs\"] = \"init_K_estim_interp\"\n", + "\n", + "## filling in information for ratio-extrapolated\n", + "capdata.loc[(no_k_cc, 2014), \"cs\"] = \"LitPop_ratio_extrap\"\n", + "\n", + "capdata = pd.concat([capdata, uninh_capdata], axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "b6f3711e-a0ce-49b3-8a0c-c896fd20251e", + "metadata": {}, + "source": [ + "We will merge the acquired result for current-PPP capital stock (and their sources) with the other historical data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2e8b379-9a7d-41c6-9f3e-b212e5c036ba", + "metadata": {}, + "outputs": [], + "source": [ + "histinfo = histinfo.merge(\n", + " capdata[[\"cn_extrap\", \"cs\"]].rename(columns={\"cs\": \"capital_source\"}),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3e6d8f66-e11c-408c-9e79-deb8d9ba0972", + "metadata": {}, + "source": [ + "## Filling in the missing `rnna` values, generating current PPP, 2019 USD capital values (`cn_19`) and constant 2019 PPP USD capital values (`rnna_19`)\n", + "\n", + "### For the missing `rnna` values (current PPP, 2017 USD)\n", + "\n", + "For these ones, we need to make sure that $rnna_{c, 2017} = cn_{c, 2017}$ for any country $c$. For the countries whose `rnna` information is missing entirely, we will use the (extrapolated) conversion rates to turn the `cgdpo` to `rnna` values. But for the countries whose `rnna` information does exist partially, we first apply the conversion rates, get `rnna` equivalents, get the growth rates of `rnna`-equivalents for the missing years, and apply them to the pre-existing `rnna` values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acc538be-0b1b-4c8a-ad81-a97bf5bff40e", + "metadata": {}, + "outputs": [], + "source": [ + "## conversion rates (PPP) attached (from current to 2017 PPP)\n", + "histinfo = histinfo.merge(\n", + " ppp_to_2017_K[[\"conv\"]].rename(columns={\"conv\": \"curr_to_cnst\"}),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "histinfo.loc[(slice(None), 2020), \"curr_to_cnst\"] = histinfo.loc[\n", + " (slice(None), 2019), \"curr_to_cnst\"\n", + "].values\n", + "histinfo.loc[pd.isnull(histinfo.curr_to_cnst), \"curr_to_cnst\"] = 1\n", + "\n", + "## creating `rnna equivalents`\n", + "histinfo[\"rnna_equiv\"] = histinfo[\"cn_extrap\"] * histinfo[\"curr_to_cnst\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "750e3be2-7035-4d5c-b24a-7120c80b02c5", + "metadata": {}, + "outputs": [], + "source": [ + "## merging the actual rnna values from PWT10.0, and detecting which are missing\n", + "## rnna values completely\n", + "histinfo = histinfo.merge(\n", + " pwt100[[\"rnna\"]], left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "\n", + "## detecting those that have some rnna information vs. don't\n", + "count_rnna = histinfo.reset_index().groupby(\"ccode\").count()[[\"rnna\"]]\n", + "no_rnna = count_rnna.loc[count_rnna.rnna == 0, :].index.values\n", + "some_rnna = count_rnna.loc[count_rnna.rnna > 0, :].index.values\n", + "\n", + "## filling in the information for those that absolutely do not have rnna information\n", + "histinfo[\"rnna_extrap\"] = np.nan\n", + "histinfo.loc[(no_rnna, slice(None)), \"rnna_extrap\"] = histinfo.loc[\n", + " (no_rnna, slice(None)), \"rnna_equiv\"\n", + "].values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "759dfd1b-35c7-401e-9141-a1ceb9eb7b41", + "metadata": {}, + "outputs": [], + "source": [ + "## for the partially-filled countries, fill in by using growth rates\n", + "for cc in tqdm(some_rnna):\n", + " nona_yrs = histinfo.loc[\n", + " (histinfo.index.get_level_values(\"ccode\") == cc) & (~pd.isnull(histinfo.rnna)),\n", + " :,\n", + " ]\n", + " nona_yrs = nona_yrs.index.get_level_values(\"year\")\n", + " nona_maxyr, nona_minyr = nona_yrs.max(), nona_yrs.min()\n", + "\n", + " ## copying information into the rnna_extrap column\n", + " histinfo.loc[(cc, nona_yrs), \"rnna_extrap\"] = histinfo.loc[\n", + " (cc, nona_yrs), \"rnna\"\n", + " ].values\n", + "\n", + " ## using growth rates for extrapolation\n", + " rnna_1950, rnna_2020 = histinfo.loc[(cc, [1950, 2020]), \"rnna\"].values\n", + " if pd.isnull(rnna_1950):\n", + " fill_yrs = list(range(1950, nona_minyr + 1))\n", + " equiv = histinfo.loc[(cc, fill_yrs), \"rnna_equiv\"].values\n", + " actual_extrap = (equiv / equiv[-1]) * histinfo.loc[(cc, nona_minyr), \"rnna\"]\n", + " histinfo.loc[(cc, fill_yrs), \"rnna_extrap\"] = actual_extrap\n", + "\n", + " if pd.isnull(rnna_2020):\n", + " fill_yrs = list(range(nona_maxyr, 2021))\n", + " equiv = histinfo.loc[(cc, fill_yrs), \"rnna_equiv\"].values\n", + " actual_extrap = (equiv / equiv[0]) * histinfo.loc[(cc, nona_maxyr), \"rnna\"]\n", + " histinfo.loc[(cc, fill_yrs), \"rnna_extrap\"] = actual_extrap" + ] + }, + { + "cell_type": "markdown", + "id": "c06d4c89-9483-4efe-8484-4c9f7c7a597a", + "metadata": {}, + "source": [ + "### Creating `cn_19` and `rnna_19`\n", + "\n", + "Again, for these, it must be that $cn\\_19_{c, 2019} = rnna\\_19_{c, 2019}$ for all countries." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6643385e-48c8-4f7d-91fc-e425429999ad", + "metadata": {}, + "outputs": [], + "source": [ + "## cn_19 is created simply by chaning from USD of 2017 to USD of 2019\n", + "usd_17_19 = pwt100.loc[(\"USA\", 2019), \"pl_n\"] / pwt100.loc[(\"USA\", 2017), \"pl_n\"]\n", + "histinfo[\"cn_19\"] = histinfo[\"cn_extrap\"] * usd_17_19\n", + "\n", + "## creating rnna_19; first creating scale factors with 2019 values being 1\n", + "rnna_17_2019_vals = (\n", + " histinfo.loc[(slice(None), 2019), [\"rnna_extrap\"]]\n", + " .reset_index()\n", + " .drop([\"year\"], axis=1)\n", + " .set_index([\"ccode\"])\n", + " .rename(columns={\"rnna_extrap\": \"rnna_2019_vals\"})\n", + ")\n", + "histinfo = histinfo.merge(\n", + " rnna_17_2019_vals, left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "histinfo[\"rnna_2019_scale\"] = histinfo[\"rnna_extrap\"] / histinfo[\"rnna_2019_vals\"]\n", + "\n", + "## multiplying the cn_19 values of 2019\n", + "cn_19_2019_vals = (\n", + " histinfo.loc[(slice(None), 2019), [\"cn_19\"]]\n", + " .reset_index()\n", + " .drop([\"year\"], axis=1)\n", + " .set_index([\"ccode\"])\n", + " .rename(columns={\"cn_19\": \"cn_19_2019\"})\n", + ")\n", + "histinfo = histinfo.merge(\n", + " cn_19_2019_vals, left_index=True, right_index=True, how=\"left\"\n", + ")\n", + "histinfo[\"rnna_19\"] = histinfo[\"rnna_2019_scale\"] * histinfo[\"cn_19_2019\"]" + ] + }, + { + "cell_type": "markdown", + "id": "552db7d5-3e75-46f2-88e5-587bfb2ded18", + "metadata": {}, + "source": [ + "## Creating capital and population scales, organizing the variable names, and exporting\n", + "\n", + "### Creating capital scale (with respect to `cn_19` of 2019) and population scale (with respect to `pop` of 2019)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7938bf65-53cf-45cb-9cc6-c82b3f9ff3aa", + "metadata": {}, + "outputs": [], + "source": [ + "## pop scale\n", + "pop2019 = (\n", + " histinfo.loc[(slice(None), 2019), [\"pop\"]]\n", + " .reset_index()\n", + " .drop([\"year\"], axis=1)\n", + " .set_index([\"ccode\"])\n", + " .rename(columns={\"pop\": \"pop_2019\"})\n", + ")\n", + "histinfo = histinfo.merge(pop2019, left_index=True, right_index=True, how=\"left\")\n", + "histinfo[\"pop_scale\"] = histinfo[\"pop\"] / histinfo[\"pop_2019\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca274a42-929b-4e16-8919-6de744263559", + "metadata": {}, + "outputs": [], + "source": [ + "## capital scale\n", + "cn2019 = (\n", + " histinfo.loc[(slice(None), 2019), [\"cn_19\"]]\n", + " .reset_index()\n", + " .drop([\"year\"], axis=1)\n", + " .set_index([\"ccode\"])\n", + " .rename(columns={\"cn_19\": \"cn_2019\"})\n", + ")\n", + "histinfo = histinfo.merge(cn2014, left_index=True, right_index=True, how=\"left\")\n", + "histinfo[\"rnna_19_scale\"] = histinfo[\"rnna_19\"] / histinfo[\"cn_2019\"]\n", + "histinfo[\"cn_19_scale\"] = histinfo[\"cn_19\"] / histinfo[\"cn_2019\"]" + ] + }, + { + "cell_type": "markdown", + "id": "b945ef5d-a024-4f29-856b-704a7f1d12f1", + "metadata": {}, + "source": [ + "### Variable name cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1074ed0c-efbe-45ae-915b-62e8942caf82", + "metadata": {}, + "outputs": [], + "source": [ + "histinfo_columns = [\n", + " \"pop_unit\",\n", + " \"gdppc_unit\",\n", + " \"gdp_capital_unit\",\n", + " \"pop_source\",\n", + " \"gdp_source\",\n", + " \"iy_ratio_source\",\n", + " \"k_ratio_source\",\n", + " \"delta_source\",\n", + " \"capital_source\",\n", + " \"pop\",\n", + " \"pop_scale\",\n", + " \"rgdpna_pc_17\",\n", + " \"rgdpna_17\",\n", + " \"rgdpna_pc_19\",\n", + " \"rgdpna_19\",\n", + " \"cgdpo_pc_17\",\n", + " \"cgdpo_17\",\n", + " \"cgdpo_pc_19\",\n", + " \"cgdpo_19\",\n", + " \"iy_ratio\",\n", + " \"iy_ratio_fit\",\n", + " \"k_movable_ratio\",\n", + " \"k_struc_ratio\",\n", + " \"k_mach_ratio\",\n", + " \"k_traeq_ratio\",\n", + " \"k_other_ratio\",\n", + " \"delta\",\n", + " \"rnna_17\",\n", + " \"rnna_19\",\n", + " \"rnna_19_scale\",\n", + " \"cn_17\",\n", + " \"cn_19\",\n", + " \"cn_19_scale\",\n", + "]\n", + "histinfo_final = histinfo.copy()\n", + "histinfo_final.rename(\n", + " columns={\n", + " \"rnna_extrap\": \"rnna_17\",\n", + " \"cn_extrap\": \"cn_17\",\n", + " \"gdp_unit\": \"gdp_capital_unit\",\n", + " },\n", + " inplace=True,\n", + ")\n", + "\n", + "## filling in the nan's with 0s\n", + "fill0 = [\n", + " \"rnna_17\",\n", + " \"rnna_19\",\n", + " \"rnna_19_scale\",\n", + " \"cn_17\",\n", + " \"cn_19\",\n", + " \"cn_19_scale\",\n", + " \"pop_scale\",\n", + "]\n", + "for i in fill0:\n", + " histinfo_final.loc[pd.isnull(histinfo_final[i]), i] = 0\n", + "\n", + "histinfo_final = histinfo_final[histinfo_columns].copy()" + ] + }, + { + "cell_type": "markdown", + "id": "e9174477-b7d0-4553-b33c-a4cabb0321ff", + "metadata": {}, + "source": [ + "### Exporting the data" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "ae83a2c3-fc71-497b-b676-3bdca885a3f8", + "metadata": {}, + "outputs": [], + "source": [ + "os.makedirs(sset.DIR_YPK_FINAL, exist_ok=True)\n", + "histinfo_final.to_parquet(\n", + " sset.DIR_YPK_FINAL / \"gdp_gdppc_pop_capital_1950_2020.parquet\"\n", + ")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk5_projected_yp.ipynb b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk5_projected_yp.ipynb new file mode 100644 index 0000000..d67acde --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk5_projected_yp.ipynb @@ -0,0 +1,745 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "abb30260", + "metadata": {}, + "source": [ + "## Clean up and impute missing projected (2010-2100) GDPpc, GDP, and population values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8be17532", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a56987e", + "metadata": {}, + "outputs": [], + "source": [ + "import dask.dataframe as ddf\n", + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "from dask_gateway import Gateway\n", + "from shapely.geometry import MultiPolygon, Point, Polygon\n", + "from tqdm.auto import tqdm\n", + "\n", + "from sliiders.spatial import iso_poly_box_getter\n", + "from sliiders import country_level_ypk as ypk_fn\n", + "from sliiders import settings as sset\n", + "\n", + "# dask gateway setup\n", + "gateway = Gateway()\n", + "image_name = sset.DASK_IMAGE" + ] + }, + { + "cell_type": "markdown", + "id": "1cececc9", + "metadata": {}, + "source": [ + "## Importing and cleaning SSP-IAM projections\n", + "\n", + "### Raw data re-formatting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a94cef05", + "metadata": {}, + "outputs": [], + "source": [ + "iiasa_raw_df = pd.read_csv(\n", + " sset.DIR_IIASA_PROJECTIONS / \"SspDb_country_data_2013-06-12.csv\"\n", + ")\n", + "iiasa_pop = iiasa_raw_df.loc[iiasa_raw_df.VARIABLE == \"Population\", :].sort_values(\n", + " [\"SCENARIO\", \"MODEL\", \"REGION\"]\n", + ")\n", + "iiasa_gdp = iiasa_raw_df.loc[iiasa_raw_df.VARIABLE == \"GDP|PPP\", :].sort_values(\n", + " [\"SCENARIO\", \"MODEL\", \"REGION\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cf013e35", + "metadata": {}, + "source": [ + "### Population\n", + "\n", + "We will only take IIASA projections, with the exception of countries whose information are in OECD projections but not in IIASA.\n", + "\n", + "#### Basic cleaning" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1736cc0f", + "metadata": {}, + "outputs": [], + "source": [ + "# Cleaning the projections\n", + "ii_pop_clean = ypk_fn.ssp_and_model_simplify(\"SCENARIO\", \"MODEL\", iiasa_pop)\n", + "ii_pop_clean.sort_values([\"ccode\", \"ssp\", \"iam\"], inplace=True)\n", + "\n", + "# double-checking if IIASA and IIASA-WiC values are same\n", + "v_ = [str(y) for y in np.arange(2010, 2105, 5)]\n", + "for i in set(ii_pop_clean.ccode):\n", + " row = ii_pop_clean[ii_pop_clean.ccode == i]\n", + " iams = set(row.iam)\n", + " if (\"IIASA\" in iams) and (\"IIASA-WiC\" in iams):\n", + " w1 = row.loc[row.iam == \"IIASA\", v_].values\n", + " w2 = row.loc[row.iam == \"IIASA-WiC\", v_].values\n", + " if not (w1 == w2).all():\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f53976a4", + "metadata": {}, + "outputs": [], + "source": [ + "# cleaning up by gathering only two population IAMs per country:\n", + "# IIASA (or equivalently, IIASA-WiC), and OECD\n", + "ii_pop = pd.DataFrame(ii_pop_clean[[\"ccode\", \"ssp\", \"iam\"] + v_])\n", + "new_v_ = [\"v_\" + str(y) for y in v_]\n", + "\n", + "for i, ccode in enumerate(list(set(ii_pop_clean.ccode))):\n", + " j = 0\n", + " indiv_df = []\n", + " case = ii_pop[ii_pop.ccode == ccode]\n", + " get_these = []\n", + " ## add oecd if existing\n", + " if \"OECD\" in set(case.iam):\n", + " indiv_df.append(case[case.iam == \"OECD\"].values)\n", + " j += 1\n", + " ## add only one of IIASA OR IIASA-WiC\n", + " if \"IIASA\" in set(case.iam):\n", + " indiv_df.append(case[case.iam == \"IIASA\"].values)\n", + " j += 1\n", + " elif \"IIASA-WiC\" in set(case.iam):\n", + " indiv_df.append(case[case.iam == \"IIASA-WiC\"].values)\n", + " j += 1\n", + "\n", + " indiv_df = pd.DataFrame(\n", + " np.vstack(indiv_df), columns=[\"ccode\", \"ssp\", \"iam\"] + new_v_\n", + " )\n", + " indiv_df[\"howmany_iam\"] = j\n", + " if i == 0:\n", + " agg_df = indiv_df.copy()\n", + " else:\n", + " agg_df = pd.concat([agg_df, indiv_df], axis=0)\n", + "\n", + "agg_df[\"unit\"] = \"millions\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e07e3967", + "metadata": {}, + "outputs": [], + "source": [ + "# brief clean-ups\n", + "ii_pop = agg_df.copy()\n", + "ii_pop[\"iam_fill\"] = \"-\"\n", + "ii_pop.loc[ii_pop.iam == \"IIASA-WiC\", \"iam\"] = \"IIASA\"\n", + "\n", + "# adding the extra rows for missing iams\n", + "for i, ccode in enumerate(set(ii_pop.ccode)):\n", + " case = ii_pop[ii_pop.ccode == ccode]\n", + " if case[\"howmany_iam\"][0] == 1:\n", + " copy_case = pd.DataFrame(case)\n", + " if set([\"OECD\"]) == set(copy_case.iam):\n", + " copy_case[\"iam\"], copy_case[\"iam_fill\"] = \"IIASA\", \"OECD\"\n", + " elif set([\"IIASA\"]) == set(copy_case.iam):\n", + " copy_case[\"iam\"], copy_case[\"iam_fill\"] = \"OECD\", \"IIASA\"\n", + " ii_pop = pd.concat([ii_pop, copy_case], axis=0)\n", + "\n", + "## further re-ordering cleanups\n", + "ii_pop.sort_values([\"ccode\", \"ssp\", \"iam\"], inplace=True)\n", + "ii_pop.set_index([\"ccode\", \"ssp\", \"iam\"], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "ee42d035", + "metadata": {}, + "source": [ + "#### Cleaning up for the case of France\n", + "\n", + "In the French case, IIASA's version has the 5 overseas departments (i.e., `MYT`, `MTQ`, `GUF`, `GLP`, and `REU`) **excluded** when it calculates the French populations. This is different in the OECD's version of the French population since it seems to **include** the said overseas departments. This can be confirmed below as the values for the sum of IIASA's populations for `MYT`, `MTQ`, `GUF`, `GLP`, `REU` and `FRA` is approximately the same as the values for OECD's French population.\n", + "\n", + "From here on, the French case for both IIASA and OECD will **exclude** the five overseas departments and keep them separately logged." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "744b2830", + "metadata": {}, + "outputs": [], + "source": [ + "## checking\n", + "fra_dept = [\"FRA\", \"MYT\", \"MTQ\", \"GUF\", \"GLP\", \"REU\"]\n", + "v_fut_5 = [x for x in ii_pop.columns if \"v_\" in x]\n", + "for ssp in [\"SSP{}\".format(i) for i in range(1, 6)]:\n", + " ## OECD case\n", + " oecd_val = ii_pop.loc[(\"FRA\", ssp, \"OECD\"), v_fut_5].values\n", + "\n", + " ## IIASA case\n", + " iiasa_val = ii_pop.loc[(fra_dept, ssp, \"IIASA\"), v_fut_5].values\n", + " iiasa_val = np.sum(iiasa_val, axis=0)\n", + "\n", + " jointhese = [ssp, str(round(np.sum((oecd_val - iiasa_val) ** 2), 4))]\n", + " print(\": \".join(jointhese))" + ] + }, + { + "cell_type": "markdown", + "id": "b482929d", + "metadata": {}, + "source": [ + "The above confirms that OECD cases do include all of the five overseas departments when calculating their population. So we will subtract these values to get the \"mainland France\" population values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dcb3ce56", + "metadata": {}, + "outputs": [], + "source": [ + "ii_pop_fra = ii_pop.copy()\n", + "csi = [\"ccode\", \"ssp\", \"iam\"]\n", + "for ssp in [\"SSP{}\".format(i) for i in range(1, 6)]:\n", + " fra_dept_oecd = ii_pop.loc[(fra_dept[1:], ssp, \"OECD\"), v_fut_5].values\n", + " fra_dept_oecd = np.sum(fra_dept_oecd, axis=0)\n", + " fra_overall_oecd = ii_pop.loc[(\"FRA\", ssp, \"OECD\"), v_fut_5].values\n", + "\n", + " ii_pop_fra.loc[(\"FRA\", ssp, \"OECD\"), v_fut_5] = fra_overall_oecd - fra_dept_oecd" + ] + }, + { + "cell_type": "markdown", + "id": "54be959d", + "metadata": {}, + "source": [ + "#### Interpolating, turning into a long-panel format, and taking only the IIASA cases\n", + "\n", + "Projections are given every five years, so we will use interpolation to fill in the missing years' information. We will assume that the between any known adjacent two years' values (e.g., 2015 and 2020), the values grow log-linearly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26dff56c", + "metadata": {}, + "outputs": [], + "source": [ + "# interpolate log-linearly and turning into a long-panel format\n", + "ii_pop = ypk_fn.organize_hor_to_ver(\n", + " ypk_fn.log_lin_interpolate(ii_pop_fra),\n", + " \"ccode\",\n", + " [\"ssp\", \"iam\"],\n", + " \"pop\",\n", + " yrs=list(range(2010, 2101)),\n", + ")\n", + "\n", + "# selecting only the IIASA cases\n", + "ii_pop = (\n", + " ii_pop.loc[(slice(None), slice(None), slice(None), \"IIASA\"), :]\n", + " .reset_index()\n", + " .drop([\"howmany_iam\", \"iam_fill\", \"iam\"], axis=1)\n", + " .set_index([\"ccode\", \"year\", \"ssp\"])\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fcb7a6cd", + "metadata": {}, + "source": [ + "#### Detecting those ISOs that are missing, and getting the country-level population estimates for these ISOs (from LandScan 2019)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfe54e94", + "metadata": {}, + "outputs": [], + "source": [ + "# cluster setup\n", + "cluster = gateway.new_cluster(worker_image=image_name, profile=\"micro\")\n", + "client = cluster.get_client()\n", + "cluster.scale(20)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9452c7d4", + "metadata": {}, + "outputs": [], + "source": [ + "# detecting which ISOs are missing\n", + "isos_pop_wproj = ii_pop.index.get_level_values(\"ccode\").unique()\n", + "need_landscan = np.sort(np.setdiff1d(sset.ALL_ISOS, isos_pop_wproj))\n", + "\n", + "# landscan and (raw) coordinates\n", + "ls19 = ddf.read_parquet(\n", + " sset.DIR_LANDSCAN_INT / \"population_with_xy.parquet\"\n", + ").repartition(npartitions=20)\n", + "ls19 = ls19.persist()\n", + "\n", + "# shapefiles requiring information from LandScan\n", + "ctries_shp = gpd.read_parquet(sset.PATH_GADM_ADM1)\n", + "\n", + "# fixing ISO codes to be consistent with our convention\n", + "ctries_shp.loc[ctries_shp.GID_0 == \"XKO\", \"GID_0\"] = \"KO-\"\n", + "ctries_shp.loc[ctries_shp.GID_0 == \"XCL\", \"GID_0\"] = \"CL-\"\n", + "\n", + "# subsetting the shapefiles for those missing projections\n", + "ctries_shp = ctries_shp.set_index([\"GID_0\"]).sort_index().loc[need_landscan]" + ] + }, + { + "cell_type": "markdown", + "id": "f37fe493", + "metadata": {}, + "source": [ + "Note that the current shapefile information we are using often has more than one MultiPolygon per ISO code, so we will create a shapefile dataset with one MultiPolygon per ISO code." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8939a774", + "metadata": {}, + "outputs": [], + "source": [ + "ctries_shp_lst = []\n", + "for iso in tqdm(need_landscan):\n", + " iso_lst = []\n", + " for i in ctries_shp.loc[[iso], \"geometry\"].values:\n", + " if type(i) == MultiPolygon:\n", + " j = [x for x in i.geoms]\n", + " elif type(i) == Polygon:\n", + " j = [i]\n", + " iso_lst += j\n", + " ctries_shp_lst.append(MultiPolygon(iso_lst))\n", + "\n", + "ctries_shp_df = gpd.GeoDataFrame(\n", + " data={\"ccode\": need_landscan, \"geometry\": ctries_shp_lst}\n", + ")\n", + "ctries_shp_df.set_index([\"ccode\"], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "31adba1c", + "metadata": {}, + "source": [ + "Based on the ISO-relevant shapefiles and grid-level population in LandScan 2019, let us find the country-level population information." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa2df5cf", + "metadata": {}, + "outputs": [], + "source": [ + "def subset_grid_find_pop(iso, shp_df=ctries_shp_df, ls_df=ls19):\n", + " poly_bounds = iso_poly_box_getter(iso, shp_df)\n", + " geom = shp_df.loc[iso, \"geometry\"]\n", + "\n", + " sub_dfs = []\n", + " for bd in poly_bounds:\n", + " x_mn, x_mx, y_mn, y_mx = bd\n", + " sub_df = ls_df.loc[\n", + " (ls_df.x > x_mn) & (ls_df.y > y_mn) & (ls_df.x < x_mx) & (ls_df.y < y_mx), :\n", + " ].compute()\n", + " sub_dfs.append(sub_df)\n", + " sub_df = pd.concat(sub_dfs, axis=0).drop_duplicates([\"x_ix\", \"y_ix\"])\n", + "\n", + " if sub_df.shape[0] == 0:\n", + " return 0\n", + "\n", + " pop = 0\n", + " for l in range(sub_df.shape[0]):\n", + " pt = Point(sub_df.iloc[l, :][\"x\"], sub_df.iloc[l, :][\"y\"])\n", + " if geom.contains(pt):\n", + " pop += sub_df.iloc[l, :][\"population\"]\n", + "\n", + " return pop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ed2a60a", + "metadata": {}, + "outputs": [], + "source": [ + "# this may take a while\n", + "ls_msng_pop = []\n", + "for iso in tqdm(need_landscan):\n", + " ls_msng_pop.append(subset_grid_find_pop(iso))\n", + "\n", + "msng_from_proj_pop = pd.DataFrame(data={\"pop\": ls_msng_pop, \"ccode\": need_landscan})\n", + "msng_from_proj_pop.to_parquet(sset.DIR_YPK_INT / \"msng_from_iiasa_proj_pop.parquet\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2bebb46", + "metadata": {}, + "outputs": [], + "source": [ + "cluster.scale(0)\n", + "cluster.close()\n", + "client.close()\n", + "cluster.shutdown()" + ] + }, + { + "cell_type": "markdown", + "id": "64903a47", + "metadata": {}, + "source": [ + "#### Attaching LandScan 2019 values to the overall population projections" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2859792b", + "metadata": {}, + "outputs": [], + "source": [ + "msng_from_proj_pop = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"msng_from_iiasa_proj_pop.parquet\"\n", + ").set_index([\"ccode\"])\n", + "\n", + "pop_from_landscan = []\n", + "for i in msng_from_proj_pop.index.get_level_values(\"ccode\"):\n", + " i_shell = ii_pop.loc[[\"USA\"], :].reset_index().copy()\n", + " i_shell[\"ccode\"] = i\n", + "\n", + " ## adjusting it to millions of people\n", + " i_shell[\"pop\"] = msng_from_proj_pop.loc[i, \"pop\"] / 1000000\n", + " i_shell.set_index(ii_pop.index.names, inplace=True)\n", + " pop_from_landscan.append(i_shell)\n", + "\n", + "ii_pop = pd.concat([ii_pop] + pop_from_landscan, axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "edc0ff29", + "metadata": {}, + "source": [ + "### GDPpc and GDP\n", + "\n", + "We will use IAMs `IIASA` and `OECD`.\n", + "\n", + "#### Basic cleaning" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "883d2312", + "metadata": {}, + "outputs": [], + "source": [ + "## cleaning the imported dataset\n", + "csi = [\"ccode\", \"ssp\", \"iam\"]\n", + "ii_gdp_clean = ypk_fn.ssp_and_model_simplify(\"SCENARIO\", \"MODEL\", iiasa_gdp)\n", + "ii_gdp_clean.set_index(csi, inplace=True)\n", + "ii_gdp_clean.sort_index(axis=0, inplace=True)\n", + "\n", + "num_v = [str(x) for x in np.arange(2010, 2105, 5)]\n", + "v_name = [\"v_\" + str(v) for v in num_v]\n", + "ii_gdp_clean.rename(columns=dict(zip(num_v, v_name)), inplace=True)\n", + "ii_gdp_clean = ii_gdp_clean[v_name]\n", + "\n", + "## changing the values from billions of dollars to millions of dollars\n", + "ii_gdp_clean[v_name] = ii_gdp_clean[v_name] * 1000\n", + "\n", + "## double-checking if IIASA and IIASA-WiC values are same\n", + "## it's verifiable that IIASA and IIASA-WiC ones are the same\n", + "for i in set(ii_gdp_clean.index.get_level_values(\"ccode\")):\n", + " row = ii_gdp_clean.loc[(i, slice(None), slice(None)), :]\n", + " iams = set(row.index.get_level_values(\"iam\"))\n", + " if (\"IIASA\" in iams) and (\"IIASA-WiC\" in iams):\n", + " w1 = row.loc[(slice(None), slice(None), \"IIASA\"), v_name].values\n", + " w2 = row.loc[(slice(None), slice(None), \"IIASA-WiC\"), v_name].values\n", + " if not (w1 == w2).all():\n", + " print(i)\n", + "\n", + "## getting only IIASA and OECD cases\n", + "clean_ccodes = ii_gdp_clean.index.get_level_values(\"ccode\")\n", + "for i, ccode in enumerate(list(set(clean_ccodes))):\n", + " j = 0\n", + " indiv_df = []\n", + " case = ii_gdp_clean.loc[(ccode, slice(None), slice(None)), :]\n", + " get_these = []\n", + " ## add oecd if existing\n", + " if \"OECD\" in set(case.index.get_level_values(\"iam\")):\n", + " indiv_df.append(case.loc[(slice(None), slice(None), \"OECD\"), :])\n", + " j += 1\n", + " ## add only one of IIASA OR IIASA-WiC\n", + " if \"IIASA\" in set(case.index.get_level_values(\"iam\")):\n", + " indiv_df.append(case.loc[(slice(None), slice(None), \"IIASA\"), :])\n", + " j += 1\n", + " elif \"IIASA-WiC\" in set(case.index.get_level_values(\"iam\")):\n", + " indiv_df.append(case.loc[(slice(None), slice(None), \"IIASA-WiC\"), :])\n", + " j += 1\n", + "\n", + " indiv_df = pd.concat(indiv_df, axis=0)\n", + " indiv_df[\"howmany_iam\"] = j\n", + " if i == 0:\n", + " agg_df = indiv_df.copy()\n", + " else:\n", + " agg_df = pd.concat([agg_df, indiv_df], axis=0)\n", + "\n", + "ii_gdp = agg_df.copy().reset_index()\n", + "ii_gdp[\"iam_fill\"] = \"-\"\n", + "ii_gdp.loc[ii_gdp.iam == \"IIASA-WiC\", \"iam\"] = \"IIASA\"\n", + "ii_gdp.set_index(csi, inplace=True)\n", + "\n", + "## If either OECD or IIASA track is missing, fill in using the other track\n", + "for i, ccode in enumerate(set(ii_gdp.index.get_level_values(\"ccode\"))):\n", + " case = ii_gdp.loc[(ccode, slice(None), slice(None)), :]\n", + " if case[\"howmany_iam\"][0] == 1:\n", + " copy_case = case.copy().reset_index()\n", + " if set([\"OECD\"]) == set(copy_case.iam):\n", + " copy_case[\"iam\"], copy_case[\"iam_fill\"] = \"IIASA\", \"OECD\"\n", + " elif set([\"IIASA\"]) == set(copy_case.iam):\n", + " copy_case[\"iam\"], copy_case[\"iam_fill\"] = \"OECD\", \"IIASA\"\n", + " ii_gdp = pd.concat([ii_gdp, copy_case.set_index(csi)], axis=0)\n", + "\n", + "ii_gdp = ypk_fn.organize_hor_to_ver(\n", + " ii_gdp.sort_index(axis=0), \"ccode\", [\"ssp\", \"iam\"], \"gdp\", yrs=range(2010, 2101)\n", + ").drop([\"howmany_iam\"], axis=1)\n", + "ii_gdp[\"unit\"] = \"millions\"" + ] + }, + { + "cell_type": "markdown", + "id": "bb2bf593", + "metadata": {}, + "source": [ + "#### Attaching the population values, creating GDPpc, and log-linearly interpolating" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd08ffc7", + "metadata": {}, + "outputs": [], + "source": [ + "ii_gdppc = ii_gdp.merge(ii_pop[[\"pop\"]], how=\"left\", left_index=True, right_index=True)\n", + "ii_gdppc[\"gdppc\"] = ii_gdppc[\"gdp\"] / ii_gdppc[\"pop\"]\n", + "scenarios = sset.SCENARIOS\n", + "scen_dfs = []\n", + "for scen in tqdm(scenarios):\n", + " ssp, iam = scen\n", + " scen_df = (\n", + " ii_gdppc.loc[(slice(None), slice(None), ssp, iam), [\"gdppc\"]]\n", + " .reset_index()\n", + " .drop([\"ssp\", \"iam\"], axis=1)\n", + " .set_index([\"ccode\", \"year\"])\n", + " )\n", + " scen_df = ypk_fn.log_lin_interpolate(\n", + " ypk_fn.organize_ver_to_hor(\n", + " scen_df, \"gdppc\", \"year\", \"ccode\", range(2010, 2101)\n", + " ),\n", + " ).reset_index()\n", + " scen_df[\"ssp\"], scen_df[\"iam\"] = ssp, iam\n", + " scen_dfs.append(scen_df.set_index([\"ccode\", \"ssp\", \"iam\"]))\n", + "ii_gdppc = ypk_fn.organize_hor_to_ver(\n", + " pd.concat(scen_dfs, axis=0), \"ccode\", [\"ssp\", \"iam\"], \"gdppc\", yrs=range(2010, 2101)\n", + ")\n", + "ii_gdppc[\"unit\"] = \"ones\"" + ] + }, + { + "cell_type": "markdown", + "id": "52f32d19", + "metadata": {}, + "source": [ + "#### Getting the by-scenario global GDPpc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0407ecf4", + "metadata": {}, + "outputs": [], + "source": [ + "ii_gdppc_w_pop = ii_gdppc.merge(\n", + " ii_pop[[\"pop\"]], how=\"left\", left_index=True, right_index=True\n", + ")\n", + "ii_gdppc_w_pop[\"gdp\"] = ii_gdppc_w_pop[\"pop\"] * ii_gdppc_w_pop[\"gdppc\"]\n", + "scen_agg_dfs = []\n", + "for scen in tqdm(scenarios):\n", + " ssp, iam = scen\n", + " scen_agg_df = (\n", + " ii_gdppc_w_pop.loc[(slice(None), slice(None), ssp, iam)]\n", + " .reset_index()\n", + " .groupby([\"year\"])\n", + " .sum()[[\"pop\", \"gdp\"]]\n", + " .reset_index()\n", + " )\n", + " scen_agg_df[\"ssp\"], scen_agg_df[\"iam\"] = ssp, iam\n", + " scen_agg_df.set_index([\"year\", \"ssp\", \"iam\"], inplace=True)\n", + " scen_agg_dfs.append(scen_agg_df)\n", + "global_df = pd.concat(scen_agg_dfs, axis=0).sort_index()\n", + "global_df[\"gdppc\"] = global_df[\"gdp\"] / global_df[\"pop\"]" + ] + }, + { + "cell_type": "markdown", + "id": "4b776cc4", + "metadata": {}, + "source": [ + "#### GDPpc for countries that are not in the current projections (subbing in the global GDPpc), and attaching it with the existing projections" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc910fe4", + "metadata": {}, + "outputs": [], + "source": [ + "gdppc_yesproj = np.sort(ii_gdppc.index.get_level_values(\"ccode\").unique())\n", + "gdppc_noproj = np.setdiff1d(sset.ALL_ISOS, gdppc_yesproj)\n", + "missing_gdps = []\n", + "for iso in tqdm(gdppc_noproj):\n", + " iso_df = global_df.reset_index()\n", + " iso_df[\"ccode\"], iso_df[\"unit\"] = iso, \"ones\"\n", + " iso_df.set_index([\"ccode\", \"year\", \"ssp\", \"iam\"], inplace=True)\n", + " missing_gdps.append(iso_df[[\"gdppc\", \"unit\"]])\n", + "missing_gdps = pd.concat(missing_gdps, axis=0).sort_index()\n", + "\n", + "ii_gdppc = pd.concat([ii_gdppc, missing_gdps], axis=0).sort_index()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d54ed5e7", + "metadata": {}, + "outputs": [], + "source": [ + "ii_yp = ii_gdppc.merge(ii_pop, left_index=True, right_index=True, how=\"left\")\n", + "ii_yp[\"pop_unit\"] = \"millions (of people)\"\n", + "ii_yp[\"gdppc_unit\"] = \"ones (of USD)\"\n", + "ii_yp[\"gdp_unit\"] = \"millions (of USD)\"\n", + "ii_yp.drop([\"unit_x\", \"unit_y\"], inplace=True, axis=1)\n", + "ii_yp[\"gdp\"] = ii_yp[\"gdppc\"] * ii_yp[\"pop\"]\n", + "\n", + "## if population is 0, then GDPpc and GDP should also be 0 (no economic activity)\n", + "ii_yp.loc[ii_yp[\"pop\"] == 0, \"gdppc\"] = 0" + ] + }, + { + "cell_type": "markdown", + "id": "7278d8e5", + "metadata": { + "tags": [] + }, + "source": [ + "#### Turning the GDP and GDPpc values to 2019 USD" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5497598", + "metadata": {}, + "outputs": [], + "source": [ + "## inflator from 2005 to 2019\n", + "pwt = (\n", + " pd.read_excel(sset.PATH_PWT_RAW)\n", + " .rename(columns={\"countrycode\": \"ccode\"})\n", + " .set_index([\"ccode\", \"year\"])\n", + ")\n", + "infla = pwt.loc[(\"USA\", 2019), \"pl_gdpo\"] / pwt.loc[(\"USA\", 2005), \"pl_gdpo\"]\n", + "ii_yp[\"gdp\"] *= infla\n", + "ii_yp[\"gdppc\"] *= infla" + ] + }, + { + "cell_type": "markdown", + "id": "d7213e95", + "metadata": {}, + "source": [ + "#### Organizing and exporting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "602991c8", + "metadata": {}, + "outputs": [], + "source": [ + "ii_yp = ii_yp[[\"gdp\", \"gdppc\", \"pop\", \"gdp_unit\", \"gdppc_unit\", \"pop_unit\"]].copy()\n", + "ii_yp.to_parquet(sset.DIR_YPK_INT / \"gdp_gdppc_pop_proj_2010_2100_post_ypk6.parquet\")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk6_projected_capital.ipynb b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk6_projected_capital.ipynb new file mode 100644 index 0000000..2205036 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/country_level_ypk/ypk6_projected_capital.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3d62e24d", + "metadata": {}, + "source": [ + "## Projecting capital stock values (2010-2100) according to Dellink et al. (2017)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e86388c", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9bf979ef", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import os\n", + "import zipfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "import xarray as xr\n", + "from dask_gateway import Gateway\n", + "from tqdm.auto import tqdm\n", + "\n", + "## settings and utility functions for SLIIDERS\n", + "from sliiders import __file__ as slfile\n", + "from sliiders import country_level_ypk as ypk_fn\n", + "from sliiders import settings as sset\n", + "\n", + "# dask gateway setup\n", + "gateway = Gateway()\n", + "image_name = sset.DASK_IMAGE" + ] + }, + { + "cell_type": "markdown", + "id": "7de17e72", + "metadata": { + "tags": [] + }, + "source": [ + "## Capital projection\n", + "\n", + "We incorporate historical 2010 capital stock values and projected GDP, GDPpc, and population values.\n", + "\n", + "### Importing and merging capital 2010 values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3419bbb", + "metadata": {}, + "outputs": [], + "source": [ + "## historical data and projected gdp, gdppc, and population\n", + "hist_df = pd.read_parquet(\n", + " sset.DIR_YPK_FINAL / \"gdp_gdppc_pop_capital_1950_2020.parquet\"\n", + ")\n", + "proj_yp_df = pd.read_parquet(\n", + " sset.DIR_YPK_INT / \"gdp_gdppc_pop_proj_2010_2100_post_ypk6.parquet\"\n", + ")\n", + "\n", + "## merging 2010 capital values\n", + "proj_ypk_df = proj_yp_df.merge(\n", + " (\n", + " hist_df.loc[(slice(None), 2010), [\"rnna_19\"]].rename(\n", + " columns={\"rnna_19\": \"capital\"}\n", + " )\n", + " ),\n", + " how=\"left\",\n", + " left_index=True,\n", + " right_index=True,\n", + ")\n", + "\n", + "# readjusting the values to ones (of dollars and people)\n", + "for i in [\"gdp\", \"pop\", \"capital\"]:\n", + " unitname = f\"{i}_unit\"\n", + " proj_ypk_df[i] *= 1000000\n", + " proj_ypk_df[unitname] = \"ones (of USD)\"\n", + " if i == \"pop\":\n", + " proj_ypk_df[unitname] = \"ones (of people)\"" + ] + }, + { + "cell_type": "markdown", + "id": "782f31fb", + "metadata": {}, + "source": [ + "### Getting the overall GDP elasticity with respect to capital\n", + "\n", + "We first need to calculate the overall GDP elasticity w.r.t. capital, and here we assume a simple Cobb-Douglas production function with population being an approximation of the labor force. Alternatively, we may use IIASA approximation (from Crespo Cuaresma, 2017) of the said elasticity being approximately 0.326." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f378d31f", + "metadata": {}, + "outputs": [], + "source": [ + "## let us subset values for 2010\n", + "k2010 = proj_ypk_df.loc[(slice(None), 2010), :]\n", + "\n", + "# since 2010 values are same across all SSP (but could be different across iams)\n", + "# we subset SSP2 here and calculate the GDP elasticity wrt capital\n", + "k2010_pos_y = k2010.loc[\n", + " (k2010.gdp > 0) & (k2010.index.get_level_values(\"ssp\") == \"SSP2\"), :\n", + "].sort_index()\n", + "overall_elas_ols = sm.OLS(\n", + " np.log(k2010_pos_y[\"gdp\"]), sm.add_constant(np.log(k2010_pos_y[[\"pop\", \"capital\"]]))\n", + ")\n", + "overall_elas_ols = overall_elas_ols.fit()\n", + "\n", + "OVERALL_E = overall_elas_ols.params[\"capital\"]\n", + "OVERALL_E_IIASA = 0.326" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eca8cb4c", + "metadata": {}, + "outputs": [], + "source": [ + "# for seeing the regression summary\n", + "overall_elas_ols.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "27f22a84", + "metadata": {}, + "source": [ + "#### Calculating the initial marginal product of capital (${MPK}_{r, t_0}$, with $t_0 = 2010$) and appending other necessary information\n", + "\n", + "**Four options of calculating MPK**\n", + "\n", + "If we assume a simple, Cobb-Douglas form for the production function (i.e., $Y = AK^\\alpha L^{1-\\alpha}$), the marginal product of capital (MPK) can be written as:\n", + "$$ \\frac{\\partial Y}{\\partial K} = \\alpha \\cdot \\underbrace{A{K}^\\alpha{L}^{1-\\alpha}}_{=Y}\\cdot \\frac{1}{K} = \\alpha \\frac{Y}{K} = \\alpha \\frac{Y/L}{K/L} $$\n", + "and similarly if we are going to assume some form like $Y = AK^\\alpha$, we can write:\n", + "$$ \\frac{\\partial Y}{\\partial K} = \\alpha \\cdot \\underbrace{AK^{\\alpha}}_{=Y} \\cdot \\frac{1}{K} = \\alpha \\frac{Y}{K} $$\n", + "so essentially the MPK can be written as the ratio of GDP ($Y$) and capital ($K$) multiplied by the GDP elasticity w.r.t. capital ($\\alpha$).\n", + "\n", + "We have acquired two different estimates (one ours, one IIASA's) of $\\alpha$ from above, but we can further look at calculating $\\alpha$ for each country by fitting either a Cobb-Douglas function or a capital-only function. So there are four options for calculating a country's MPK:\n", + "1. Use $\\alpha$ from IIASA\n", + "2. Use $\\alpha$ from our estimation\n", + "3. Use $\\alpha$ from fitting a Cobb-Douglas function\n", + "4. Use $\\alpha$ from fitting a capital-only function\n", + "\n", + "and we can multiply the value of $\\frac{Y}{K}$ (in the year 2010) afterwards." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57a27e17", + "metadata": {}, + "outputs": [], + "source": [ + "MPK_init_calc_lamb = lambda x: ypk_fn.MPK_init_calc(\n", + " x, hist_df, k2010, [OVERALL_E, OVERALL_E_IIASA]\n", + ")\n", + "\n", + "# for the inhabited areas\n", + "mpk_calc = []\n", + "inhabited_isos = np.setdiff1d(sset.ALL_ISOS, sset.UNINHABITED_ISOS)\n", + "for i in tqdm(inhabited_isos):\n", + " lst_mpks = MPK_init_calc_lamb(i)\n", + " mpk_calc.append(lst_mpks)\n", + "mpk_calc = pd.concat(mpk_calc, axis=0)\n", + "\n", + "# there are some cases in which the TPK and elasticities per country are not\n", + "# found via optimization (minimization); in this case, we will clip it with\n", + "# the minimum MPK garnered either from `mpk_our`, `mpk_iiasa`, or itself (whichever\n", + "# is lesser yet above 0)\n", + "for i in [\"mpk_ctry_cd\", \"mpk_ctry_co\"]:\n", + " cd_values = mpk_calc[[\"mpk_our\", \"mpk_iiasa\", i]].values\n", + " mpk_calc.loc[mpk_calc[i] == 0, i] = cd_values[cd_values > 0].min()\n", + "\n", + "# attaching the uninhabited areas; by default, their Y/K ratios and MPK values will\n", + "# be set to 0 (doesn't matter too much, since their projected capitals will be 0)\n", + "mpk_calc_uninhabited = k2010.reset_index().set_index([\"ccode\", \"ssp\", \"iam\"])\n", + "mpk_calc_uninhabited = mpk_calc_uninhabited.loc[\n", + " (sset.UNINHABITED_ISOS, slice(None), slice(None)), [\"gdp\", \"capital\", \"pop\"]\n", + "]\n", + "for i in [\"yk\", \"mpk_our\", \"mpk_iiasa\", \"mpk_ctry_cd\", \"mpk_ctry_co\"]:\n", + " mpk_calc_uninhabited[i] = 0\n", + "mpk_calc = pd.concat([mpk_calc, mpk_calc_uninhabited], axis=0).sort_index()" + ] + }, + { + "cell_type": "markdown", + "id": "4217f3b9", + "metadata": {}, + "source": [ + "### Using the perpetual inventory method (PIM) with the dynamic parameter equations specified in Dellink et al. (2017)\n", + "\n", + "The method in Dellink et al. (2017) is basically a PIM, but its parameters are dynamic (and evolving on their own) so that they approach converge to specific long-term values. Below is (with `dask` parallelization) an application of the Dellink et al. (2017) methodology using the MPKs (in 4 different methods) we have calculated above for each country.\n", + "\n", + "First, we load the 2010 historical values (some estimated) of capital stock into our projection dataset. Also, we calculate the by-country average depreciation rates (from PWT 10.0) and overall average (average of the by-country rates) rates (also from PWT 10.0) which are used in the PIM process. If a country is missing from the PWT 10.0 dataset, we will simply use the overall average depreciation rate for the country-specific values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca9057b2", + "metadata": {}, + "outputs": [], + "source": [ + "## importing the (initial) iy ratios in 2010\n", + "iy_org = hist_df.loc[(slice(None), [2010]), [\"iy_ratio_fit\", \"delta\"]]\n", + "iy_org = (\n", + " iy_org.reset_index()\n", + " .rename(columns={\"delta\": \"delta_c\", \"iy_ratio_fit\": \"iy_ratio\"})\n", + " .drop([\"year\"], axis=1)\n", + " .set_index([\"ccode\"])\n", + ")\n", + "\n", + "## AFG has the average delta value\n", + "delta_overall = iy_org.loc[\"AFG\", \"delta_c\"]\n", + "\n", + "## merge this with the 2010 (starting point) dataset\n", + "mpk_calc = mpk_calc.merge(iy_org, left_index=True, right_index=True, how=\"left\")\n", + "mpk_calc[\"delta\"] = delta_overall" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c5f73ef", + "metadata": {}, + "outputs": [], + "source": [ + "## cluster setup\n", + "N_CLUSTER = 20\n", + "cluster = gateway.new_cluster(worker_image=image_name, profile=\"micro\")\n", + "client = cluster.get_client()\n", + "cluster.scale(N_CLUSTER)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93355c2f", + "metadata": {}, + "outputs": [], + "source": [ + "## getting the ccodes and ccode-specific DFs necessary\n", + "ccodes_pos_y = (\n", + " proj_ypk_df.loc[proj_ypk_df.gdp > 0, :].index.get_level_values(\"ccode\").unique()\n", + ")\n", + "ccodes_dfs = [proj_ypk_df.loc[[cc], :].copy() for cc in ccodes_pos_y]\n", + "\n", + "## uninhabited ones set aside\n", + "cc_dfs_uninh = proj_ypk_df.loc[\n", + " ~proj_ypk_df.index.get_level_values(\"ccode\").isin(ccodes_pos_y), :\n", + "].sort_index()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb94a190", + "metadata": {}, + "outputs": [], + "source": [ + "# making sure SLIIDERS functions are compatible with Dask workflow\n", + "# run this when all the workers are available\n", + "sliiders_dir = Path(slfile).parent\n", + "zipf = zipfile.ZipFile(\"sliiders.zip\", \"w\", zipfile.ZIP_DEFLATED)\n", + "for root, dirs, files in os.walk(sliiders_dir):\n", + " for file in files:\n", + " zipf.write(\n", + " os.path.join(root, file),\n", + " os.path.relpath(os.path.join(root, file), os.path.join(sliiders_dir, \"..\")),\n", + " )\n", + "zipf.close()\n", + "client.upload_file(\"sliiders.zip\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa952c3c", + "metadata": {}, + "outputs": [], + "source": [ + "MPK_var_cases = [\"mpk_our\", \"mpk_ctry_cd\", \"mpk_ctry_co\"] * 2\n", + "MPK_case_len = len(MPK_var_cases)\n", + "all_cases = []\n", + "for i, case in enumerate(MPK_var_cases):\n", + " if i < (MPK_case_len // 2):\n", + " pim_lamb = lambda x: ypk_fn.pim_single_ctry(x, mpk_calc, OVERALL_E, case)\n", + " else:\n", + " pim_lamb = lambda x: ypk_fn.pim_single_ctry(x, mpk_calc, OVERALL_E_IIASA, case)\n", + " pim_dfs = client.map(pim_lamb, ccodes_dfs)\n", + " pim_dfs = client.gather(pim_dfs)\n", + " pim_dfs = pd.concat(pim_dfs, axis=0)\n", + " all_cases.append(pim_dfs)\n", + " j = i + 1\n", + " print(f\"Step {j}/{MPK_case_len} done\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dab4482", + "metadata": {}, + "outputs": [], + "source": [ + "# shutting down cluster\n", + "cluster.scale(0)\n", + "client.close()\n", + "cluster.close()\n", + "cluster.shutdown()\n", + "\n", + "# removing the .zip file that's been uploaded to Dask\n", + "os.remove(\"sliiders.zip\")" + ] + }, + { + "cell_type": "markdown", + "id": "84ea369b", + "metadata": {}, + "source": [ + "### Checking against the Dellink et al. (2017)'s Figure 6 (capital intensity plots)" + ] + }, + { + "cell_type": "markdown", + "id": "7b66b707", + "metadata": {}, + "source": [ + "We examine our 6 options as below. After examination with the graph as well as the SSE values, it seems that the case utilizing by-country MPK, **capital-only** production function, and the IIASA overall MPK are the ones that perform the best, at least with the four countries whose information are available.\n", + "\n", + "However, since the SSEs for the numbers are very similar between the two cases (varying only by **capital-and-labor** production versus **capital-only** production) and because capital-only one has been used previously to produce capital stock estimates, we will use estimates from `all_cases[-1]` as our main capital stock estimates and those from `all_cases[-2]` as alternative estimates." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c1d3944", + "metadata": {}, + "outputs": [], + "source": [ + "all_cases_sse = []\n", + "for i in all_cases:\n", + " all_cases_sse.append(ypk_fn.examine_against_fig6(i))" + ] + }, + { + "cell_type": "markdown", + "id": "418aedca", + "metadata": {}, + "source": [ + "For sanity check, we will also graph top ten and bottom cases of capital stock (in natural logarithm) for some specified SSP (SSP3 below) and some year (2100 below)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de9cdc57", + "metadata": {}, + "outputs": [], + "source": [ + "ypk_fn.top_bottom_10(all_cases[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46819cfa", + "metadata": {}, + "outputs": [], + "source": [ + "ypk_fn.top_bottom_10(all_cases[-2])" + ] + }, + { + "cell_type": "markdown", + "id": "8e240b14", + "metadata": {}, + "source": [ + "## Re-organizing the dataset and exporting\n", + "\n", + "### Data re-organization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "042d6543", + "metadata": {}, + "outputs": [], + "source": [ + "# capital stock estimates\n", + "pim_dfs_iiasa_co = all_cases[-1].copy()\n", + "pim_dfs_iiasa_cd = all_cases[-2].copy()\n", + "\n", + "# creating gdppc, unit changes, and changing the name to be matched\n", + "output_df = proj_ypk_df.rename(\n", + " columns={\"gdp\": \"rgdpna_19\", \"gdppc\": \"rgdpna_pc_19\"}\n", + ").drop([\"capital\"], axis=1)\n", + "output_df[\"pop\"] /= 1000000\n", + "output_df[\"rgdpna_19\"] /= 1000000\n", + "\n", + "## attaching the capital stock estimates\n", + "necess_cols = [\"capital_estim\", \"MPK\", \"IY\", \"KY\"]\n", + "output_df = output_df.merge(\n", + " pim_dfs_iiasa_co[necess_cols].rename(columns={\"capital_estim\": \"rnna_19\"}),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "output_df[\"rnna_19\"] /= 1000000\n", + "\n", + "alt_name = \"rnna_19_alternative\"\n", + "output_df = output_df.merge(\n", + " pim_dfs_iiasa_cd[[\"capital_estim\"]].rename(columns={\"capital_estim\": alt_name}),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"left\",\n", + ")\n", + "output_df[alt_name] /= 1000000\n", + "\n", + "for i in necess_cols[1:] + [alt_name, \"rnna_19\"]:\n", + " output_df.loc[pd.isnull(output_df[i]), i] = 0\n", + "\n", + "## adding the unit information and reordering\n", + "output_df[\"gdp_capital_unit\"] = \"millions (of USD)\"\n", + "output_df[\"gdppc_unit\"] = \"ones (of USD)\"\n", + "output_df[\"pop_unit\"] = \"millions (of people)\"\n", + "output_df.sort_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "0132fe16", + "metadata": {}, + "source": [ + "### Scale creation with respect to historical 2019 values of population and current-PPP (2019 USD) capital stock" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "636201d0", + "metadata": {}, + "outputs": [], + "source": [ + "## fetching the 2019 historical values\n", + "hist_gp = (\n", + " hist_df.loc[(slice(None), 2019), [\"cn_19\", \"pop\"]]\n", + " .reset_index()\n", + " .drop([\"year\"], axis=1)\n", + " .set_index([\"ccode\"])\n", + " .rename(columns={\"pop\": \"pop_2019\", \"cn_19\": \"cn_19_2019\"})\n", + ")\n", + "\n", + "## merge and create scales\n", + "output_df = output_df.merge(hist_gp, left_index=True, right_index=True, how=\"left\")\n", + "output_df[\"pop_scale\"] = output_df[\"pop\"] / output_df[\"pop_2019\"]\n", + "output_df[\"rnna_19_scale\"] = output_df[\"rnna_19\"] / output_df[\"cn_19_2019\"]\n", + "output_df[\"rnna_19_alternative_scale\"] = (\n", + " output_df[\"rnna_19_alternative\"] / output_df[\"cn_19_2019\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8298c07a", + "metadata": {}, + "source": [ + "### Exporting: historical 2019 values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3156eb87", + "metadata": {}, + "outputs": [], + "source": [ + "hist2019 = hist_df.loc[\n", + " (slice(None), 2019),\n", + " [\n", + " \"gdp_capital_unit\",\n", + " \"gdppc_unit\",\n", + " \"pop_unit\",\n", + " \"cgdpo_19\",\n", + " \"cgdpo_pc_19\",\n", + " \"pop\",\n", + " \"cn_19\",\n", + " ],\n", + "].reset_index()\n", + "hist2019 = hist2019.drop([\"year\"], axis=1).set_index([\"ccode\"])\n", + "hist2019.to_parquet(sset.DIR_YPK_FINAL / \"gdp_gdppc_pop_capital_hist2019.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "282846eb", + "metadata": {}, + "source": [ + "### Exporting: projected values (2010-2100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8205448f", + "metadata": {}, + "outputs": [], + "source": [ + "col_ordering = [\n", + " \"gdp_capital_unit\",\n", + " \"gdppc_unit\",\n", + " \"pop_unit\",\n", + " \"rgdpna_19\",\n", + " \"rgdpna_pc_19\",\n", + " \"rnna_19\",\n", + " \"rnna_19_scale\",\n", + " \"rnna_19_alternative\",\n", + " \"rnna_19_alternative_scale\",\n", + " \"cn_19_2019\",\n", + " \"pop\",\n", + " \"pop_scale\",\n", + " \"pop_2019\",\n", + " \"MPK\",\n", + " \"IY\",\n", + " \"KY\",\n", + "]\n", + "\n", + "## filling in the nan's with 0, for uninhabited areas\n", + "output_df = output_df[col_ordering].copy().sort_index()\n", + "for i in [\"rgdpna_pc_19\", \"rnna_19_scale\", \"rnna_19_alternative_scale\", \"pop_scale\"]:\n", + " output_df.loc[pd.isnull(output_df[i]), i] = 0\n", + "\n", + "output_df.to_parquet(\n", + " sset.DIR_YPK_FINAL / \"gdp_gdppc_pop_capital_proj_2010_2100.parquet\"\n", + ")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/create-SLIIDERS-ECON.ipynb b/notebooks/create-SLIIDERS-ECON/create-SLIIDERS-ECON.ipynb new file mode 100644 index 0000000..0aeb3b9 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/create-SLIIDERS-ECON.ipynb @@ -0,0 +1,3409 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create SLIIDERS-ECON" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook creates the SLIIDERS-ECON dataset, starting from a segment X ADM1 X elevation dataset of capital stock and population + country-level scaling factors following the SSPs." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import OrderedDict\n", + "\n", + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from dask_gateway import Gateway\n", + "from gcsfs import GCSFileSystem\n", + "from scipy.stats import gumbel_r\n", + "\n", + "from sliiders.settings import (\n", + " EXPOSURE_BIN_WIDTH_V,\n", + " PATH_CIAM_2016,\n", + " PATH_CIAM_ADM1_VORONOI_INTERSECTIONS,\n", + " PATH_CIAM_COASTLINES,\n", + " PATH_SEG_CENTROIDS,\n", + " PATH_COUNTRY_LEVEL_EXPOSURE,\n", + " PATH_COUNTRY_LEVEL_EXPOSURE_PROJ,\n", + " PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION,\n", + " PATH_EXPOSURE_BINNED_WITHELEV,\n", + " PATH_EXPOSURE_LINCKE,\n", + " PATH_EXPOSURE_WB_ICP,\n", + " PATH_GADM,\n", + " PATH_GTSM_SURGE,\n", + " PATH_PWT_RAW,\n", + " PATH_SLIIDERS_ECON,\n", + " PATH_SLIIDERS_SLR,\n", + " SVALS,\n", + ")\n", + "from sliiders.spatial import coastlen_poly, get_great_circle_nearest_index\n", + "from sliiders.utils import upload_pkg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Start Dask Cluster" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This section can be modified for whatever computing resources you have. But the result must be a dask distributed `Client` object assigned to `client`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce1123bfbc4b4d78994359ec6424e8b4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value='

GatewayCluster

'), HBox(children=(HTML(value='\\n
\\n
<xarray.Dataset>\n",
+       "Dimensions:         (elev: 200, bound: 2, seg_adm: 11709, country: 204,\n",
+       "                     params: 2, return_period: 4, ssp: 5, iam: 2, year: 101)\n",
+       "Coordinates:\n",
+       "    seg             (seg_adm) object dask.array<chunksize=(500,), meta=np.ndarray>\n",
+       "    adm1            (seg_adm) object dask.array<chunksize=(500,), meta=np.ndarray>\n",
+       "  * country         (country) object 'GRC' 'ITA' 'CYP' ... 'NRU' 'TKL' 'SXM'\n",
+       "    seg_country     (seg_adm) object dask.array<chunksize=(500,), meta=np.ndarray>\n",
+       "  * seg_adm         (seg_adm) object 'seg_00001_adm1_GRC.4_1' ... 'seg_99015_...\n",
+       "  * params          (params) <U5 'loc' 'scale'\n",
+       "  * return_period   (return_period) int64 10 100 1000 10000\n",
+       "  * year            (year) int64 2000 2001 2002 2003 ... 2097 2098 2099 2100\n",
+       "  * ssp             (ssp) object 'SSP1' 'SSP2' 'SSP3' 'SSP4' 'SSP5'\n",
+       "  * iam             (iam) object 'IIASA' 'OECD'\n",
+       "  * elev            (elev) float64 0.05 0.15 0.25 0.35 ... 19.75 19.85 19.95\n",
+       "  * bound           (bound) object 'lower' 'upper'\n",
+       "Data variables: (12/17)\n",
+       "    elev_bounds     (elev, bound) float32 dask.array<chunksize=(200, 2), meta=np.ndarray>\n",
+       "    SLR_site_id     (seg_adm) object dask.array<chunksize=(500,), meta=np.ndarray>\n",
+       "    length          (seg_adm) float32 dask.array<chunksize=(500,), meta=np.ndarray>\n",
+       "    pc              (country) float32 dask.array<chunksize=(204,), meta=np.ndarray>\n",
+       "    mobcapfrac      (country) float32 dask.array<chunksize=(204,), meta=np.ndarray>\n",
+       "    gumbel_params   (seg_adm, params) float32 dask.array<chunksize=(500, 2), meta=np.ndarray>\n",
+       "    ...              ...\n",
+       "    pop_scale       (ssp, iam, year, country) float32 dask.array<chunksize=(5, 2, 101, 204), meta=np.ndarray>\n",
+       "    ypcc            (ssp, iam, year, country) float32 dask.array<chunksize=(5, 2, 101, 204), meta=np.ndarray>\n",
+       "    landarea        (seg_adm, elev) float32 dask.array<chunksize=(500, 200), meta=np.ndarray>\n",
+       "    interior        (ssp, iam, year, country) float32 dask.array<chunksize=(5, 2, 101, 204), meta=np.ndarray>\n",
+       "    wetland         (seg_adm, elev) float32 dask.array<chunksize=(500, 200), meta=np.ndarray>\n",
+       "    wetlandservice  (ssp, iam, year, country) float32 dask.array<chunksize=(5, 2, 101, 204), meta=np.ndarray>
" + ], + "text/plain": [ + "\n", + "Dimensions: (elev: 200, bound: 2, seg_adm: 11709, country: 204,\n", + " params: 2, return_period: 4, ssp: 5, iam: 2, year: 101)\n", + "Coordinates:\n", + " seg (seg_adm) object dask.array\n", + " adm1 (seg_adm) object dask.array\n", + " * country (country) object 'GRC' 'ITA' 'CYP' ... 'NRU' 'TKL' 'SXM'\n", + " seg_country (seg_adm) object dask.array\n", + " * seg_adm (seg_adm) object 'seg_00001_adm1_GRC.4_1' ... 'seg_99015_...\n", + " * params (params) \n", + " SLR_site_id (seg_adm) object dask.array\n", + " length (seg_adm) float32 dask.array\n", + " pc (country) float32 dask.array\n", + " mobcapfrac (country) float32 dask.array\n", + " gumbel_params (seg_adm, params) float32 dask.array\n", + " ... ...\n", + " pop_scale (ssp, iam, year, country) float32 dask.array\n", + " ypcc (ssp, iam, year, country) float32 dask.array\n", + " landarea (seg_adm, elev) float32 dask.array\n", + " interior (ssp, iam, year, country) float32 dask.array\n", + " wetland (seg_adm, elev) float32 dask.array\n", + " wetlandservice (ssp, iam, year, country) float32 dask.array" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dollar_units = \"2019 USD PPP\"\n", + "\n", + "# coords\n", + "out.seg_adm.attrs.update(\n", + " {\n", + " \"description\": (\n", + " \"Unique combinations of coastline segment and ADM1 unit. Each is treated \"\n", + " \"as an independent unit in pyCIAM.\"\n", + " )\n", + " }\n", + ")\n", + "out.params.attrs.update(\n", + " {\"description\": \"Gumbel parameters for ESL/storm surge distribution\"}\n", + ")\n", + "out.return_period.attrs.update({\"long_name\": \"Return periods\", \"units\": \"y\"})\n", + "out.elev.attrs.update(\n", + " {\n", + " \"long_name\": \"Elevation\",\n", + " \"description\": (\n", + " \"Midpoint elevation for each coastal elevation bin employed in pyCIAM\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "out.ssp.attrs.update(\n", + " {\n", + " \"long_name\": \"Shared Socioeconomic Pathway\",\n", + " \"description\": \"Trajectories of income, capital, and population growth\",\n", + " }\n", + ")\n", + "out.iam.attrs.update(\n", + " {\n", + " \"long_name\": \"Growth Model\",\n", + " \"description\": (\n", + " \"Independent models used to simulate income and capital growth for each \"\n", + " \"SSP\",\n", + " ),\n", + " }\n", + ")\n", + "out.country.attrs.update(\n", + " {\n", + " \"description\": (\n", + " \"Dimension used for variables that exhibit only country-level variance\"\n", + " )\n", + " }\n", + ")\n", + "\n", + "# alternate coords\n", + "out.seg.attrs.update({\"description\": \"Segment associated with each seg-ADM1\"})\n", + "out.adm1.attrs.update({\"description\": \"ADM1 unit associated with each seg-ADM1\"})\n", + "out.seg_country.attrs.update(\n", + " {\"description\": (\"Country associated with each analysis unit\")}\n", + ")\n", + "\n", + "# data_vars\n", + "out.interior.attrs.update(\n", + " {\n", + " \"long_name\": \"Value of non-coastal land\",\n", + " \"units\": f\"{dollar_units} per km2\",\n", + " }\n", + ")\n", + "out.SLR_site_id.attrs.update(\n", + " {\n", + " \"long_name\": \"SLR Site ID\",\n", + " \"description\": \"SLR Site ID for closest 2-deg LSLR projection grid cell\",\n", + " }\n", + ")\n", + "out.elev_bounds.attrs.update(\n", + " {\n", + " \"long_name\": \"Elevation bounds\",\n", + " \"description\": (\n", + " \"Lower and upper bounds for each coastal elevation bin employed in pyCIAM\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "out.length.attrs.update(\n", + " {\n", + " \"description\": \"Length of coastline associated with each analysis unit\",\n", + " \"units\": \"km\",\n", + " }\n", + ")\n", + "out.gumbel_params.attrs.update(\n", + " {\"description\": \"Parameters describing ESL distribution\", \"units\": \"m\"}\n", + ")\n", + "out.surge_height.attrs.update(\n", + " {\"description\": \"Estimated ESL/storm surge heights\", \"units\": \"m\"}\n", + ")\n", + "out.wetland.attrs.update(\n", + " {\n", + " \"description\": \"Estimated area for all wetland by elevation\",\n", + " \"units\": \"km^2\",\n", + " }\n", + ")\n", + "out.wetlandservice.attrs.update(\n", + " {\n", + " \"description\": \"Value of wetlands\",\n", + " \"units\": f\"{dollar_units} per km^2\",\n", + " }\n", + ")\n", + "out.K_2019.attrs.update(\n", + " {\n", + " \"long_name\": \"2019 Capital stock\",\n", + " \"description\": (\n", + " \"Estimated value of physical capital in 2019, under actual conditions \"\n", + " \"(i.e. observed, not SSP)\"\n", + " ),\n", + " \"units\": dollar_units,\n", + " }\n", + ")\n", + "out.pop_2019.attrs.update(\n", + " {\n", + " \"long_name\": \"2019 population\",\n", + " \"description\": (\n", + " \"Estimated population in 2019, under actual conditions (i.e. observed, not \"\n", + " \"SSP)\"\n", + " ),\n", + " \"units\": \"people\",\n", + " }\n", + ")\n", + "out.K_scale.attrs.update(\n", + " {\n", + " \"long_name\": \"Capital scaling factor\",\n", + " \"description\": (\n", + " \"Country-level change factor in capital stock specific to SSP/IAM, \"\n", + " \"relative to K_2019\"\n", + " ),\n", + " }\n", + ")\n", + "out.pop_scale.attrs.update(\n", + " {\n", + " \"long_name\": \"Population scaling factor\",\n", + " \"description\": (\n", + " \"Country-level change factor in population specific to SSP/IAM, relative \"\n", + " \"to pop_2019\"\n", + " ),\n", + " }\n", + ")\n", + "out.ypcc.attrs.update(\n", + " {\n", + " \"long_name\": \"Country-level income per capita\",\n", + " \"units\": f\"{dollar_units} per person\",\n", + " }\n", + ")\n", + "out.landarea.attrs.update(\n", + " {\n", + " \"long_name\": \"Total Land Area\",\n", + " \"units\": \"km^2\",\n", + " }\n", + ")\n", + "out.pc.attrs.update(\n", + " {\n", + " \"description\": \"Protection cost (quadratic with height)\",\n", + " \"units\": f\"{dollar_units} per km per vert m^2\",\n", + " }\n", + ")\n", + "out.mobcapfrac.attrs.update(\n", + " {\n", + " \"description\": \"Fraction of capital that is mobile\",\n", + " }\n", + ")\n", + "out.rho.attrs.update(\n", + " {\n", + " \"description\": (\n", + " \"Resilience factor scaling depth-damage and depth-mortality functions\"\n", + " ),\n", + " }\n", + ")\n", + "out.dr.attrs.update({\"description\": \"Discount rate\"})\n", + "out.wmaxrate.attrs.update(\n", + " {\n", + " \"units\": \"m per year\",\n", + " }\n", + ")\n", + "\n", + "# values we need to save\n", + "to_keep = [\n", + " \"elev_bounds\",\n", + " \"seg\",\n", + " \"adm1\",\n", + " \"country\",\n", + " \"seg_country\",\n", + " \"SLR_site_id\",\n", + " \"length\",\n", + " \"pc\",\n", + " \"mobcapfrac\",\n", + " \"gumbel_params\",\n", + " \"surge_height\",\n", + " \"rho\",\n", + " \"K_2019\",\n", + " \"pop_2019\",\n", + " \"K_scale\",\n", + " \"pop_scale\",\n", + " \"ypcc\",\n", + " \"landarea\",\n", + " \"interior\",\n", + " \"wetland\",\n", + " \"wetlandservice\",\n", + "]\n", + "\n", + "# print dataset to verify it looks as expected\n", + "out[to_keep]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/srv/conda/envs/notebook/lib/python3.9/site-packages/xarray/conventions.py:205: SerializationWarning: variable None has data in the form of a dask array with dtype=object, which means it is being loaded into memory to determine a data type that can be safely stored on disk. To avoid this, coerce this variable to a fixed-size dtype with astype() before saving it.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out[to_keep].to_zarr(PATH_SLIIDERS_ECON, mode=\"w\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(None, None)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cluster.close(), client.close()" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-ECON/download-sliiders-econ-input-data.ipynb b/notebooks/create-SLIIDERS-ECON/download-sliiders-econ-input-data.ipynb new file mode 100644 index 0000000..f9391ae --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/download-sliiders-econ-input-data.ipynb @@ -0,0 +1,760 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9c487926-08b8-49b2-928d-c95730c36d44", + "metadata": {}, + "source": [ + "## Notebook for downloading inputs to create SLIIDERS-ECON\n", + "\n", + "This notebook contains directions for downloading various input datasets to create the final product for this directory, the **SLIIDERS-ECON** dataset.\n", + "\n", + "In general, we will keep the format, file name, and data unaltered, but apply changes when\n", + "- file name is not human-readable, too long, or is not much informative about the dataset (assign appropriate file names)\n", + "- file format causes errors (save in a similar file format that is not error-prone)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "517784ca-badd-41fe-a88c-7b4370260e5c", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import ssl\n", + "import subprocess\n", + "import tarfile\n", + "from io import BytesIO\n", + "from pathlib import Path\n", + "from urllib import request as urequest\n", + "from zipfile import ZipFile\n", + "\n", + "import dask.distributed as dd\n", + "import pandas as pd\n", + "import requests\n", + "from dask_gateway import Gateway\n", + "from pandas_datareader import wb as dr_wb\n", + "from tqdm.auto import tqdm\n", + "\n", + "from sliiders import settings as sset\n", + "\n", + "# dask gateway setup\n", + "gateway = Gateway()\n", + "image_name = sset.DASK_IMAGE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19fc306c-cfca-44dd-9044-0d8c6bf1d2c3", + "metadata": {}, + "outputs": [], + "source": [ + "# creating select directories\n", + "PWT_DIRECTORY = sset.PATH_PWT_RAW.parent\n", + "IMF_WEO_DIRECTORY = sset.PATH_IMF_WEO_RAW.parent\n", + "MPD_DIRECTORY = sset.PATH_MPD_RAW.parent\n", + "GWDB_DIRECTORY = sset.PATH_GWDB2021_RAW.parent\n", + "SRTM15PLUS_DIRECTORY = sset.PATH_SRTM15_PLUS.parent\n", + "MDT_DIRECTORY = sset.PATH_GEOG_MDT_RAW.parent\n", + "\n", + "directories_to_create = [\n", + " PWT_DIRECTORY,\n", + " IMF_WEO_DIRECTORY,\n", + " MPD_DIRECTORY,\n", + " GWDB_DIRECTORY,\n", + " SRTM15PLUS_DIRECTORY,\n", + " MDT_DIRECTORY,\n", + " sset.DIR_WB_WDI_RAW,\n", + " sset.DIR_LITPOP_RAW,\n", + " sset.DIR_GEG15_RAW,\n", + " sset.DIR_CCI_RAW,\n", + " sset.DIR_UN_WPP_RAW,\n", + " sset.DIR_UN_AMA_RAW,\n", + " sset.DIR_ALAND_STATISTICS_RAW,\n", + " sset.DIR_OECD_REGIONS_RAW,\n", + " sset.DIR_LANDSCAN_RAW,\n", + " sset.DIR_IIASA_PROJECTIONS,\n", + " sset.DIR_GEOG_DATUMS_XGM2019e_WGS84,\n", + " sset.DIR_GEOG_DATUMS_EGM96_WGS84,\n", + "]\n", + "for direc in directories_to_create:\n", + " direc.mkdir(exist_ok=True, parents=True)" + ] + }, + { + "cell_type": "markdown", + "id": "9e1d4cce-5cc8-4c4d-b3cd-1aaf56e90ce9", + "metadata": { + "tags": [] + }, + "source": [ + "## Fetching raw data from various sources" + ] + }, + { + "cell_type": "markdown", + "id": "83c92a29-bd27-4b1d-838c-7989d7561757", + "metadata": {}, + "source": [ + "### Penn World Tables 10.0 (PWT 10.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "029359fb-e17a-44c8-a536-4696f7d8c00c", + "metadata": {}, + "outputs": [], + "source": [ + "# PWT10.0\n", + "pwt100_data = pd.read_excel(\"https://www.rug.nl/ggdc/docs/pwt100.xlsx\", sheet_name=2)\n", + "\n", + "# PWT10.0 capital details\n", + "pwt100_data_K = pd.read_excel(\n", + " \"https://www.rug.nl/ggdc/docs/pwt100-capital-detail.xlsx\", sheet_name=2\n", + ")\n", + "\n", + "pwt_filenames = [\"pwt_100.xlsx\", \"pwt_K_detail_100.xlsx\"]\n", + "for i, data in enumerate([pwt100_data, pwt100_data_K]):\n", + " data.to_excel(\n", + " excel_writer=(PWT_DIRECTORY / pwt_filenames[i]),\n", + " sheet_name=\"Sheet1\",\n", + " index=False,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "d08579cb-0c3e-4722-8ae3-944b46297b68", + "metadata": {}, + "source": [ + "### Maddison Project Dataset (MPD, Maddison Project Database 2020)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb664e52-bdbe-4e2e-b30e-3102fdf8ae83", + "metadata": {}, + "outputs": [], + "source": [ + "madd = pd.read_excel(\n", + " \"https://www.rug.nl/ggdc/historicaldevelopment/maddison/data/mpd2020.xlsx\",\n", + " sheet_name=2,\n", + ")\n", + "madd.to_excel(\n", + " excel_writer=(sset.PATH_MPD_RAW),\n", + " index=False,\n", + " sheet_name=\"Sheet1\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8b3c486f-f4b0-4ad1-849a-542e2a875a11", + "metadata": {}, + "source": [ + "### World Bank WDI (WB WDI)\n", + "\n", + "#### Investment-to-GDP ratio, GDP and GDPpc (nominal and PPP), and Population" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b33996e7-fa36-4496-bda9-1f8a459cde1f", + "metadata": {}, + "outputs": [], + "source": [ + "# country name and iso3 country code information\n", + "country_info = dr_wb.get_countries()[[\"name\", \"iso3c\"]].rename(\n", + " columns={\"name\": \"country\", \"iso3c\": \"ccode\"}\n", + ")\n", + "\n", + "# relevant indicator information for the `dr_wb` module to fetch the variables\n", + "wbwdi_indicators = [\n", + " \"SP.POP.TOTL\", # population\n", + " \"NE.GDI.FTOT.ZS\", # investment-to-GDP ratio\n", + " \"NY.GDP.MKTP.PP.KD\", # GDP PPP\n", + " \"NY.GDP.PCAP.PP.KD\", # GDP per capita PPP\n", + " \"NY.GDP.MKTP.KD\", # GDP nominal\n", + " \"NY.GDP.PCAP.KD\", # GDP per capita nominal\n", + "]\n", + "\n", + "j = 0\n", + "for indi in wbwdi_indicators:\n", + " indi_info = (\n", + " dr_wb.download(indicator=indi, country=\"all\", start=1950, end=2020)\n", + " .reset_index()\n", + " .astype({\"year\": \"int64\"})\n", + " .merge(country_info, on=[\"country\"], how=\"left\")\n", + " .set_index([\"ccode\", \"year\"])\n", + " )\n", + "\n", + " if j == 0:\n", + " j += 1\n", + " wbwdi_info = indi_info.copy()\n", + " else:\n", + " wbwdi_info = wbwdi_info.merge(\n", + " indi_info.drop([\"country\"], axis=1),\n", + " left_index=True,\n", + " right_index=True,\n", + " how=\"outer\",\n", + " )\n", + "\n", + "# excluding those that have no information and saving the data\n", + "wb_info_vars = [x for x in wbwdi_info.columns if x != \"country\"]\n", + "wbwdi_info = wbwdi_info.loc[~pd.isnull(wbwdi_info[wb_info_vars]).all(axis=1), :]\n", + "wbwdi_info.to_parquet(sset.DIR_WB_WDI_RAW / \"wdi_pop_iy_gdp.parquet\")" + ] + }, + { + "cell_type": "markdown", + "id": "bdec086b-c676-4690-9f2f-93585172e4d7", + "metadata": {}, + "source": [ + "#### WB WDI: exchange rate" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e766dc90-ef52-4f10-ba4c-0fdae8c768c9", + "metadata": {}, + "outputs": [], + "source": [ + "# country name and iso3 country code information\n", + "country_info = dr_wb.get_countries()[[\"name\", \"iso3c\"]].rename(\n", + " columns={\"name\": \"country\", \"iso3c\": \"ccode\"}\n", + ")\n", + "\n", + "xr_code = \"PA.NUS.FCRF\"\n", + "xr_wb = dr_wb.download(indicator=xr_code, country=\"all\", start=1950, end=2019)\n", + "xr_wb = (\n", + " xr_wb.reset_index()\n", + " .astype({\"year\": \"int64\"})\n", + " .merge(country_info, on=[\"country\"], how=\"left\")\n", + ")\n", + "(\n", + " xr_wb.set_index([\"ccode\", \"year\"])\n", + " .rename(columns={xr_code: \"xrate\"})\n", + " .to_parquet(sset.DIR_WB_WDI_RAW / \"wdi_xr.parquet\")\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "df339e99-0571-4c23-8c7f-6e691b7c39c6", + "metadata": {}, + "source": [ + "### UN WPP populations (overall and by-population-group data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c01b3a3-63ca-4c8e-9d84-8d0ede6c7c33", + "metadata": {}, + "outputs": [], + "source": [ + "# overall information\n", + "un_df = pd.read_csv(\n", + " \"https://population.un.org/wpp/Download/Files/\"\n", + " \"1_Indicators%20(Standard)/CSV_FILES/WPP2019_TotalPopulationBySex.csv\"\n", + ")\n", + "\n", + "# by_age_group\n", + "by_age = pd.read_csv(\n", + " \"https://population.un.org/wpp/Download/Files/1_Indicators\"\n", + " \"%20(Standard)/CSV_FILES/WPP2019_PopulationByAgeSex_Medium.csv\"\n", + ")\n", + "\n", + "# exporting\n", + "un_df.to_csv(sset.DIR_UN_WPP_RAW / \"UN_WPP2019_TotalPopulation.csv\", index=False)\n", + "by_age.to_csv(sset.DIR_UN_WPP_RAW / \"UN_WPP2019_Population_by_Age.csv\", index=False)" + ] + }, + { + "cell_type": "markdown", + "id": "8cdb4d29-7c84-49e0-ba3e-4fb7663ecd32", + "metadata": {}, + "source": [ + "### Åland Island GDP and population (from Statistics and Research Åland or ÅSUB)\n", + "\n", + "Note when newer versions are available, old links from ÅSUB will become deprecated; the below links in `ALA_GDP_LINK` and `ALA_POP_LINK` are valid as of 2022-03-29." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "792b59d8-44fa-4d85-93db-8682b1857e24", + "metadata": {}, + "outputs": [], + "source": [ + "# links\n", + "ALA_GDP_LINK = (\n", + " \"https://www.asub.ax/sites/www.asub.ax/files/attachments/page/nr005en.xls\"\n", + ")\n", + "ALA_POP_LINK = (\n", + " \"https://www.asub.ax/sites/www.asub.ax/files/attachments/page/alv01_aland_faroe\"\n", + " \"_islands_and_greenland_-_an_overview_with_comparable_data.xlsx\"\n", + ")\n", + "\n", + "# datasets read-in\n", + "ala_gdp = pd.read_excel(ALA_GDP_LINK, header=3)\n", + "ala_pop = pd.read_excel(ALA_POP_LINK, header=2, sheet_name=\"Population development\")\n", + "\n", + "# exporting\n", + "ala_gdp.to_excel(sset.DIR_ALAND_STATISTICS_RAW / \"aland_gdp.xlsx\", index=False)\n", + "ala_pop.to_excel(sset.DIR_ALAND_STATISTICS_RAW / \"aland_pop.xlsx\", index=False)" + ] + }, + { + "cell_type": "markdown", + "id": "3fe8a00c-5822-467a-80a8-b4b6722eea3c", + "metadata": { + "tags": [] + }, + "source": [ + "### Global Wealth Databook (from Credit Suisse)\n", + "\n", + "We download the 2021 vintage (latest as of 2022-03-21)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81d2a06a-52eb-4f4f-94fd-8d01e9c32042", + "metadata": {}, + "outputs": [], + "source": [ + "URL_GWDB = (\n", + " \"https://www.credit-suisse.com/media/assets/corporate/docs/about-us/research\"\n", + " \"/publications/global-wealth-databook-2021.pdf\"\n", + ")\n", + "\n", + "gwr_raw = urequest.urlopen(URL_GWDB)\n", + "file = open(str(sset.PATH_GWDB2021_RAW), \"wb\")\n", + "file.write(gwr_raw.read())\n", + "file.close()" + ] + }, + { + "cell_type": "markdown", + "id": "a9f0b8fa-7c93-4735-9caa-e07777d150a2", + "metadata": {}, + "source": [ + "### LitPop (Eberenz et al. 2020, Earth Syst. Sci. Data)\n", + "\n", + "#### Download Data from the Internet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ed65443-7818-406e-a23a-1f62aba91a5d", + "metadata": {}, + "outputs": [], + "source": [ + "# link for downloading the LitPop files\n", + "link_base = (\n", + " \"https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/331316\"\n", + ")\n", + "\n", + "# readme, data, normalized data, and metadata\n", + "links = [\n", + " link_base + \"/_readme_v1_2.txt?sequence=18&isAllowed=y\",\n", + " link_base + \"/LitPop_v1_2.tar?sequence=16&isAllowed=y\",\n", + " link_base + \"/Lit_Pop_norm_v1.tar?sequence=4&isAllowed=y\",\n", + " link_base + \"/_metadata_countries_v1_2.csv?sequence=12&isAllowed=y\",\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ff7328f-8976-4f0c-b981-adff491472c8", + "metadata": {}, + "outputs": [], + "source": [ + "def litpop_download(link, direc=sset.DIR_LITPOP_RAW):\n", + " \"\"\"Given a URL link, downloads (LitPop-related) data from the web and saves it in\n", + " the specified local directory. The file name is parsed so that anything after the\n", + " string `?sequence` is dropped (e.g., `file.txt?sequence=..` to `file.txt`).\n", + "\n", + " Parameters\n", + " ----------\n", + " link : str\n", + " URL link for the file online\n", + " direc : str or pathlib.Path\n", + " directory to store the LitPop datasets\n", + "\n", + " Returns\n", + " -------\n", + " None, but saves the file downloaded from online to `direc`.\n", + "\n", + " \"\"\"\n", + " if type(direc) is str:\n", + " direc = Path(direc)\n", + "\n", + " stop = link.find(\"?sequence\")\n", + " start = link.rfind(\"/\", 0, stop) + 1\n", + " urequest.urlretrieve(link, direc / link[start:stop])\n", + "\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1dfe03b-cc1f-4fa8-a89e-3952b856b309", + "metadata": {}, + "outputs": [], + "source": [ + "# cluster setup\n", + "N_CLUSTER = len(links)\n", + "cluster = gateway.new_cluster(worker_image=image_name, profile=\"micro\")\n", + "client = cluster.get_client()\n", + "cluster.scale(N_CLUSTER)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0e059a0-cc7f-4193-b682-aeb2155967e9", + "metadata": {}, + "outputs": [], + "source": [ + "# takes approximately 20 minutes\n", + "futures = client.map(litpop_download, links)\n", + "dd.progress(futures)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a39c609-0e3b-4caa-9181-28b4570e097f", + "metadata": {}, + "outputs": [], + "source": [ + "cluster.scale(0)\n", + "client.close()\n", + "cluster.close()\n", + "cluster.shutdown()" + ] + }, + { + "cell_type": "markdown", + "id": "ae5d6120-d2f8-474a-891e-5b59838d3b11", + "metadata": {}, + "source": [ + "#### Un-tar and clear storage\n", + "\n", + "We only un-tar the regular (not normalized) LitPop data here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d685d7d9-0c7a-4c99-af5f-639cdd3c618d", + "metadata": {}, + "outputs": [], + "source": [ + "# un-tar\n", + "regular_litpop = sset.DIR_LITPOP_RAW / \"LitPop_v1_2.tar\"\n", + "with tarfile.open(regular_litpop) as file:\n", + " file.extractall(sset.DIR_LITPOP_RAW)\n", + "\n", + "# clear storage for the existing tar file\n", + "os.remove(regular_litpop)" + ] + }, + { + "cell_type": "markdown", + "id": "4702790c-75dd-484a-b8e3-0acdf36d5c35", + "metadata": {}, + "source": [ + "### GEG-15\n", + "\n", + "We download 2'30\" GEG15 and unzip." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d3109c6-fa04-406d-9def-21b745f6d83c", + "metadata": {}, + "outputs": [], + "source": [ + "# downloading\n", + "zip_url = (\n", + " \"https://data.humdata.org/dataset/1c9cf1eb-c20a-4a06-8309-9416464af746/\"\n", + " \"resource/e321d56d-022e-4070-80ac-f7860646408d/download/gar-exp.zip\"\n", + ")\n", + "zip_path = sset.DIR_GEG15_RAW / \"gar-exp.zip\"\n", + "urequest.urlretrieve(zip_url, zip_path)\n", + "\n", + "# unzipping\n", + "outpath = sset.DIR_GEG15_RAW / zip_path.stem\n", + "os.makedirs(outpath, exist_ok=True)\n", + "subprocess.Popen([\"unzip\", f\"{zip_path}\", \"-d\", f\"{outpath}\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e9ef63f-9a5a-40f9-8bd8-c5f33f524616", + "metadata": {}, + "outputs": [], + "source": [ + "# remove zip file (use after unzipping)\n", + "os.remove(zip_path)" + ] + }, + { + "cell_type": "markdown", + "id": "96bd9ff7-2b4f-4082-9d4c-0042c2b3ee9f", + "metadata": {}, + "source": [ + "### Country-level Construction Cost Index from [Lincke and Hinkel (2021, *Earth's Future*)](https://agupubs.onlinelibrary.wiley.com/doi/full/10.1029/2020EF001965?campaign=woletoc)\n", + "\n", + "The accompanying GitHub repository to Lincke and Hinkel (2021) is at [this link](https://github.com/daniellincke/DIVA_paper_migration)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cb05b93-c8cc-4f9e-9e99-ce5b7d511d16", + "metadata": {}, + "outputs": [], + "source": [ + "# raw data file from the GitHub repo\n", + "lincke_hinkel_cci_url = (\n", + " \"https://raw.githubusercontent.com/daniellincke/\"\n", + " \"DIVA_paper_migration/master/data/csv/country_input.csv\"\n", + ")\n", + "\n", + "# data read-in\n", + "lincke_hinkel_df = pd.read_csv(lincke_hinkel_cci_url)\n", + "\n", + "# saving at PATH_EXPOSURE_LINCKE\n", + "lincke_hinkel_df.to_parquet(sset.PATH_EXPOSURE_LINCKE)" + ] + }, + { + "cell_type": "markdown", + "id": "342a0f73-06b7-4ed9-8ae8-113775265c15", + "metadata": {}, + "source": [ + "### SRTM 15+\n", + "\n", + "We use version 2.3." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7eb84251-5e5a-4180-b59c-793fc06dd913", + "metadata": {}, + "outputs": [], + "source": [ + "# Workaround for urllib request error\n", + "ssl._create_default_https_context = ssl._create_unverified_context\n", + "URL_SRTM15 = \"https://topex.ucsd.edu/pub/srtm15_plus/SRTM15_V2.3.nc\"\n", + "\n", + "urequest.urlretrieve(URL_SRTM15, SRTM15PLUS_DIRECTORY / URL_SRTM15.split(\"/\")[-1])" + ] + }, + { + "cell_type": "markdown", + "id": "d5efcb44-1f60-4377-9d01-e970b918ca5e", + "metadata": { + "tags": [] + }, + "source": [ + "## Further data requiring separate manual instructions\n", + "\n", + "In all cases below, `sset` is defined by `from sliiders import settings as sset` as above.\n", + "\n", + "### UN Statistics National Accounts (Analysis of Main Aggregates; abbreviated as UN AMA)\n", + "\n", + "#### UN AMA nominal (current prices) GDP per capita information\n", + "\n", + "1. Travel to this [link](https://unstats.un.org/unsd/snaama/Basic) to get to the UN Statistics National Accounts search page.\n", + "2. Select all countries and all years available, and select \"GDP, Per Capita GDP - US Dollars\".\n", + "3. Select \"Export to CSV\", and you will download the file `Results.csv`. Rename this file as `un_snaama_nom_gdppc.csv`. We save this in `sset.DIR_UN_AMA_RAW`.\n", + "\n", + "#### UN AMA nominal (current prices) GDP information\n", + "\n", + "1. Similar to the nominal GDP per capita information, travel to this [link](https://unstats.un.org/unsd/snaama/Basic) to get to the UN Statistics National Accounts search page.\n", + "2. Select all countries and all years available, and select \"GDP, at current prices - US Dollars\".\n", + "3. Select \"Export to CSV\", and you will download the file `Results.csv`. Rename this file as `un_snaama_nom_gdp.csv`. We save this in `sset.DIR_UN_AMA_RAW`.\n", + "\n", + "### OECD region-level information\n", + "\n", + "#### OECD: population (region-level)\n", + "1. Go to the following OECD Stat website: link [here](https://stats.oecd.org/)\n", + "2. On the left, find the header \"Regions and Cities\" and click the \"+\" button.\n", + "3. From the drop down menu, click on \"Regional Statistics\".\n", + "4. Again from the drop down menu, click on \"Regional Demography.\"\n", + "5. Finally, select \"Population by 5-year age groups, small regions TL3.\" Make sure that \"Indicator\" is selected as \"Population, All ages\".\n", + "6. Download the file by selecting \"Export,\" then \"Text File (CSV).\"\n", + "7. When a pop-up appears, select \"Default format\" then \"Download.\" Rename the file as `REGION_DEMOGR.csv` (due to it having random-ish numeric parts in the name). Note that this step may take a longer time than others.\n", + "8. Finally, move the said file to `sset.DIR_OECD_REGIONS_RAW`.\n", + "\n", + "#### OECD: GDP (region-level, in millions of constant 2015 PPP USD)\n", + "1. Similar to the population information, go to the following OECD Stat website: link [here](https://stats.oecd.org/)\n", + "2. On the left, find the header \"Regions and Cities\" and click the \"+\" button.\n", + "3. From the drop down menu, click on \"Regional Statistics\".\n", + "4. Again from the drop down menu, click on \"Regional Economy.\"\n", + "5. Finally, select \"Gross Domestic Product, Small regions TL3.\" Make sure that \"Measure\" is selected as \"Millions USD, constant prices, constant PPP, base year 2015\".\n", + "6. Download the file by selecting \"Export,\" then \"Text File (CSV).\"\n", + "7. When a pop-up appears, select \"Default format\" then \"Download.\" Rename the file as `REGION_ECONOM.csv` (due to it having random-ish numeric parts in the name). Note that this step may take a longer time than others.\n", + "8. Finally, move the said file to `sset.DIR_OECD_REGIONS_RAW`.\n", + "\n", + "### IMF investment-to-GDP ratio, population, and GDP\n", + "\n", + "1. Travel to this [link](https://www.imf.org/en/Publications/SPROLLs/world-economic-outlook-databases#sort=%40imfdate%20descending) to get to the World Economic Outlook Databases page.\n", + "2. Click on the latest \"World Economic Outlook Database\" link on the page; for our purposes, we have used the latest available one, which was \"World Economic Outlook Database, October 2021\" (may be updated in the future).\n", + "3. Click \"By Countries\", then click \"ALL COUNTRIES\", then click \"CONTINUE\" on the page that says \"Select Countries.\"\n", + "4. Under the \"NATIONAL ACCOUNTS\" tab, check the following categories:\n", + " - Gross domestic product, current prices (U.S. DOLLARS)\n", + " - Gross domestic product per capita, current prices (U.S. DOLLARS)\n", + " - Gross domestic product per capita, constant prices (PURCHASING POWER PARITY; 2017 INTERNATIONAL DOLLARS)\n", + " - Total investment (PERCENT OF GDP)\n", + "5. Under the \"PEOPLE\" tab, check the category \"Population,\" then click on \"CONTINUE.\"\n", + "6. Under the tab \"DATE RANGE,\" use the earliest year for \"Start Year\" (1980, in our case), and the latest non-future year for \"End Year\" (2020, in our case).\n", + "7. Under the tab \"ADVANCED SETTINGS\", click on \"ISO Alpha-3 Code\" for getting country codes. \n", + "8. Click on \"PREPARE REPORT.\" Then, click on \"DOWNLOAD REPORT.\" Saved data should be in Excel format and be named `WEO_Data.xls`.\n", + "9. Open the said file on Excel, and re-save it in a preferred format of choice (we chose `.xlsx`); this is because the original file formatting is incompatible with Python and causes the error `ValueError: Excel file format cannot be determined, you must specify an engine manually.`\n", + "10. In our implementation, we save this file as `sset.PATH_IMF_WEO_RAW`.\n", + "\n", + "### World Bank Intercomparison Project 2017 (WB ICP 2017): Construction Cost Index\n", + "\n", + "While most World Bank data can be downloaded by using `pandas_datareader.wb`, it seems that variables in WB ICP 2017 - including `1501200:CONSTRUCTION`, which is necessary for SLIIDERS-ECON - cannot be downloaded using the said module (despite being searchable in the module using `pandas_datareader.wb.search`). Therefore, we follow the below manual process for downloading the WB ICP 2017 dataset.\n", + "1. Use [this link](https://databank.worldbank.org/embed/ICP-2017-Cycle/id/4add74e?inf=n) to access WB ICP 2017 in table format.\n", + "2. Upon entering the webpage, look to the upper right corner and click on the icon with downward arrow with an underline. This should prompt the download.\n", + "3. When the download finishes, there should be a `.zip` file called `ICP 2017 Cycle.zip`. Access the `.csv` file whose name ends in `_Data.csv` (there should be two files in the `.zip` file, the other being a file whose name ends in `_Series - Metadata.csv`).\n", + "4. Save that `.csv` file as `sset.PATH_EXPOSURE_WB_ICP`.\n", + "\n", + "### IIASA and OECD models' GDP and population projections (2010-2100, every 5 years)\n", + "\n", + "1. Go to the following IIASA SSP Database website: link [here](https://tntcat.iiasa.ac.at/SspDb); you may need to register and create your log-in.\n", + "2. In the above tabs, there is a tab called \"Download\"; click on it.\n", + "3. Under \"SSP Database Version 2 Downloads (2018)\" and under the sub-header \"Basic Elements\", there is a download link for `SspDb_country_data_2013-06-12.csv.zip`. Click and download the said `.zip` file.\n", + "4. Extract and save the `SspDb_country_data_2013-06-12.csv`. Again, for our purposes, we save this in `sset.DIR_IIASA_PROJECTIONS`.\n", + "\n", + "### LandScan 2019\n", + "\n", + "1. To download this dataset, you need to first apply for an Oak Ridge National Laboratory account (link [here](https://landscan.ornl.gov/user/apply)).\n", + "2. After having gained access, go to the said website, click on \"DOWNLOAD\" -> \"LandScan Datasets\" -> \"Continue to download\" next to LandScan 2019.\n", + "3. Click on \"By downloading LandScan 2019 I agree to the above terms\" in the following webpage; this will download the file `LandScan Global 2019.zip`. We save this in `sset.DIR_LANDSCAN_RAW`.\n", + "\n", + "### Global geoids, based on select Earth Gravitational Models (EGMs)\n", + "1. Go to the following International Centre for Global Earth Models (ICGEM) website (link [here](http://icgem.gfz-potsdam.de/calcgrid)) to reach the page \"Calculation of Gravity Field Functionals on Ellipsoidal Grids\".\n", + "2. Under **Model Selection**, select `XGM2019e_2159`.\n", + "3. Under **Functional Selection**, select `geoid`.\n", + "4. Under **Grid selection**, there's a **Grid Step [°]** option. Change the value to **0.05**. Also, make sure that the **Reference System** is `WGS84`.\n", + "5. Due to download size constraints, we need to download this data in 4 chunks. Do the following:\n", + " - Split the full range of latitudes and longitudes in half, which yields the following 4 combinations of longitude-latitude ranges: $([-180, 0], [-90, 0]), ([-180, 0], [0, 90]), ([0, 180], [-90, 0])$, and $([0, 180], [0, 90])$.\n", + " - Under **Grid selection** again, one can select the range of longitudes and latitudes. Select one of the above combinations and press `start computation`.\n", + " - This will open up a new tab for calculations, which may take some time to complete. Once this is done, press **Download Grid**.\n", + " - Once the download is complete, go back to the previous page with **Model selection**, **Functional selection**, and more. Make sure the selections you made are intact, select another longitude-latitude combination, and repeat the process until there are no combinations left.\n", + "6. Once the above steps are done, go back to Step 2 above; but instead of selecting `XGM2019e_2159` for **Model selection**, select `EGM96`. Go through the Steps 3 to 5 again with this new selection.\n", + "7. Once the downloads for `XGM2019e_2159` and `EGM96` are complete, you should have 4 files for each model (8 in total, in `.gdf` format). Save the `XGM2019e_2159` files in `sset.DIR_GEOG_DATUMS_XGM2019e_WGS84` and `EGM96` files in `sset.DIR_GEOG_DATUMS_EGM96_WGS84`.\n", + "\n", + "### Global Mean Dynamic Ocean Topography (MDT) from AVISO+\n", + "**Note**: While this dataset has a relatively open license, you will first need to obtain a MY AVISO+ account, which requires verification from the AVISO+ team and may take several days or weeks.\n", + "1. Go to the following AVISO+ website for **MDT CNES-CLS18**: link [here](https://www.aviso.altimetry.fr/en/data/products/auxiliary-products/mdt/mdt-global-cnes-cls18.html).\n", + "2. Once on the page, download the dataset through your MY AVISO+ account (click on `access via MY AVISO+` link and follow the instructions).\n", + "3. After following the instructions, you will acquire the file `mdt_cnes_cls18_global.nc.gz`. Extract the file `mdt_cnes_cls18_global.nc` from the `.gz` file and save it as `sset.PATH_GEOG_MDT_RAW`.\n", + "\n", + "### CIA World Factbook (compiled by Coleman [2020])\n", + "\n", + "1. Travel to this [link](https://github.com/iancoleman/cia_world_factbook_api) (credit to Coleman [2020]), and scroll down to the `readme.md`.\n", + "2. In the **Data** section of the `readme.md` file, there should be a link on \"Historical\"; click on this link to travel to a `mega.nz` website having `weekly_json.7z` file.\n", + "3. After checking that the filename to download is `weekly_json.7z`, download the said file by clicking on the \"Download\" button.\n", + "4. When download is successful, import `weekly_json.7z` to the preferred directory (`sset.DIR_YPK_RAW` in this implementation).\n", + "\n", + "### HydroSHEDS\n", + "1. Go to https://hydrosheds.org/downloads\n", + "2. Download the \"standard\" level-0 HydroBASINS files for each continent (use the Dropbox link if available--this appears as \"NOTE: you may also download data from here.\" as of 8/16/21. Download the shapefiles into the directory defined in `sset.DIR_HYDROBASINS_RAW`" + ] + }, + { + "cell_type": "markdown", + "id": "438f5274-f65c-41a3-8deb-7e62069f6138", + "metadata": {}, + "source": [ + "### Other SLIIDERS input datasets" + ] + }, + { + "cell_type": "markdown", + "id": "8b048d8c-ef4e-4119-9de5-9ec341f0d5a5", + "metadata": {}, + "source": [ + "There are three datasets that were manually constructed for use in `SLIIDERS`. They are available for download on Zenodo. Please download each file from Zenodo and copy to the paths designated for each dataset.\n", + "\n", + "#### 1. `ne_coastline_lines_CIAM_wexp_or_gtsm.shp`\n", + "Path: `sset.PATH_CIAM_COASTLINES` (Download all files with the name `ne_coastline_lines_CIAM_wexp_or_gtsm` (but different extensions) to this directory.) \n", + "Link: [TODO - include Zenodo link]\n", + "\n", + "Using the global coastlines derived from the Natural Earth layers, we included individual land masses formed by these coastlines only if they have either i) a non-zero value of exposure based on our exposure grid for population and capital assets, OR ii) if they have an associated coastal segment point, as derived primarily from the CoDEC GTSM station points. Association of a given land mass to nearby CoDEC point(s) was determined through manual inspection of the subset of land masses (n=636) with zero exposure in order to assess whether an intersecting or nearby station point represented that land area, resulting in the inclusion of 171 small land masses for which no population or capital is present but for which a coast point is associated.\n", + "\n", + "#### 2. `gtsm_stations_eur_tothin.shp`\n", + "Path: `sset.DIR_GTSM_STATIONS_TOTHIN` (Download all files with the name `gtsm_stations_eur_tothin` (but different extensions) to this directory.) \n", + "Link: [TODO - include Zenodo link]\n", + "\n", + "These 5,637 station points are a subset of the full CoDEC dataset (n=14,110) representing sites along European coastlines that are roughly five times more densely-spaced compared to the rest of the globe, as described in Muis et al. 2020. This subset of points are those that will be thinned by 5x to approximately match the density of CoDEC coast stations globally. Some manual inclusion criteria for this subset was applied in GIS due to the fact that simply seeking to select dense European stations based on the “station_name” field in the dataset, which contains the substring “eur” for all European locations, results in an over-selection of desired points (n=6,132), with many North African coastal points that are not densely-spaced containing this substring in their “station_name” as well. Therefore, European points were manually identified, with small islands, such as in the Mediterranean, included if their land mass contained 5 or more station points, which guarantees that they will be represented by at least one station point following the 5x thinning process. The resultant subset of points is used as a data input for the coastal segment construction in the preprocessing of the SLIIDERS dataset.\n", + "\n", + "#### 3. `us_manual_protected_areas.parquet`\n", + "Path: `sset.PATH_US_MANUAL_PROTECTED_AREAS` \n", + "Link: [TODO - include Zenodo link]\n", + "\n", + "The regions defined in this dataset represent a few areas in the United States that may have low-lying elevations, but are not vulnerable to flooding due to constructed barriers or since they are completely separated from the coastline by topographical features with much higher elevations. Areas protected by Louisiana levees were downloaded from the National Levee Database (https://levees.sec.usace.army.mil/), and areas corresponding to low-lying areas in California, Missouri, and Michigan that are not vulnerable to coastal flooding were created using spatial buffers around a central point." + ] + }, + { + "cell_type": "markdown", + "id": "c0323ad0-afc1-43bf-9e5b-82e37e5455ce", + "metadata": {}, + "source": [ + "### CoastalDEM v1.1\n", + "1. Acquire the global 1 arc-second CoastalDEM dataset from Climate Central (https://go.climatecentral.org/coastaldem/).\n", + "2. Save all 1-degree GeoTIFF files in `sset.DIR_COASTALDEM`" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/1-create-coastline-segments.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/1-create-coastline-segments.ipynb new file mode 100644 index 0000000..57b7002 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/1-create-coastline-segments.ipynb @@ -0,0 +1,286 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0c63fafa-8600-47e7-b1b8-20e476a415a3", + "metadata": {}, + "source": [ + "# Create Coastline Segments" + ] + }, + { + "cell_type": "markdown", + "id": "27036a8b-f200-40d5-9308-77506829c0d3", + "metadata": {}, + "source": [ + "This notebook modifies the CoDEC points to generate a uniform set of coastline segment centroids." + ] + }, + { + "cell_type": "markdown", + "id": "2b15c558-112e-496a-9797-371c4dd15f7c", + "metadata": {}, + "source": [ + "**TODO**\n", + "\n", + "- [ ] add back in the last section (with filepaths appropriately in settings.py) when we figure out where `ne_coastline_polys_CIAM_exposure_matches.parquet` is generated" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebc3268f-bf70-421c-bd04-aa58b19d39f9", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8910b8e", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from shapely.geometry import Point\n", + "\n", + "from sliiders.settings import (\n", + " DIR_GTSM_STATIONS_TOTHIN,\n", + " PATH_SEG_CENTROIDS,\n", + " PATH_GTSM_SURGE,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f685e2db-d168-4ad5-8f42-7beba55370fe", + "metadata": {}, + "outputs": [], + "source": [ + "GTSMPTS_EUR = DIR_GTSM_STATIONS_TOTHIN / \"gtsm_stations_eur_tothin.shp\"" + ] + }, + { + "cell_type": "markdown", + "id": "d3cc347d", + "metadata": {}, + "source": [ + "### Import GTSM Station Points & Thin Europe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfa7e3c2", + "metadata": {}, + "outputs": [], + "source": [ + "# Import GTSM (CoDEC) stations present in ERA5 GTSM data from Muis et al. 2020\n", + "gtsm0 = (\n", + " xr.open_dataset(PATH_GTSM_SURGE)\n", + " .rename(station_y_coordinate=\"lat\", station_x_coordinate=\"lon\")\n", + " .station_id.drop(\"station_name\")\n", + " .reset_coords()\n", + ")\n", + "gtsm0[\"station_id\"] = gtsm0.station_id.astype(str)\n", + "gtsm0 = gtsm0.to_dataframe()\n", + "\n", + "# Import Europe stations to be thinned (came in 5x higher res than rest of world)\n", + "# Stations to be thinned were manually ID'ed in GIS\n", + "gtsm_e0 = gpd.read_file(GTSMPTS_EUR)\n", + "gtsm_e0[\"serial_id\"] = [gtsm_e0.station_id[i][-5:] for i in range(len(gtsm_e0))]\n", + "gtsm_e0 = gtsm_e0.sort_values(\"serial_id\")\n", + "\n", + "# Filter 80% of Europe stations\n", + "gtsm_e1 = gtsm_e0.iloc[np.arange(0, len(gtsm_e0), 5)]\n", + "\n", + "# Update full GTSM layer\n", + "gtsm1 = gtsm0[\n", + " ~gtsm0.station_id.isin(gtsm_e0.station_id)\n", + "] # all stations not in the to-be-thinned orig Europe set\n", + "gtsm1 = pd.concat([gtsm1, gtsm_e1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76754f22", + "metadata": {}, + "outputs": [], + "source": [ + "# Add back in Gibraltar and Monaco\n", + "gib_id = \"id_coast_glob_eur_03452\"\n", + "mon_id = \"id_coast_glob_eur_03236\"\n", + "gtsm1 = pd.concat([gtsm1, gtsm0[gtsm0.station_id.isin([gib_id, mon_id])]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "730731f6", + "metadata": {}, + "outputs": [], + "source": [ + "# Add new manual points for 15 small country coastlines\n", + "lats = [\n", + " 18.20427252, # Anguilla\n", + " 42.92257646, # Bosnia & Herzegovina\n", + " 17.92105954, # St Barthelemy\n", + " -54.45126484, # Bouvet Island\n", + " -12.1888075, # Cocos (Keeling) Islands\n", + " 10.28952433, # Clipperton Island\n", + " 29.51144515, # Jordan\n", + " 16.69068301, # Montserrat\n", + " -29.01453206, # Norfolk Island\n", + " -0.54073669, # Nauru\n", + " -24.38660564, # Pitcairn Islands\n", + " 10.73177001, # Spratly Islands\n", + " -9.3415246, # Tokelau\n", + " 19.28118539, # US Minor Outlying Island (Wake Island)\n", + " 18.03885916,\n", + "] # Sint Maarten\n", + "\n", + "lons = [\n", + " -63.05668448,\n", + " 17.61671166,\n", + " -62.82955182,\n", + " 3.35020284,\n", + " 96.83802356,\n", + " -109.21026241,\n", + " 34.97905326,\n", + " -62.18841426,\n", + " 167.97463688,\n", + " 166.91406099,\n", + " -128.32974227,\n", + " 115.8022823,\n", + " -171.19264163,\n", + " 166.64951319,\n", + " -63.01482338,\n", + "]\n", + "\n", + "add_pts = {\n", + " \"station_id\": [\"id_coast_glob_990\" + str(i + 1).zfill(2) for i in range(len(lats))],\n", + " \"lat\": lats,\n", + " \"lon\": lons,\n", + " \"geometry\": [Point(lons[i], lats[i]) for i in range(len(lats))],\n", + "}\n", + "\n", + "add_pts = gpd.GeoDataFrame(add_pts, crs=\"EPSG:4326\")\n", + "\n", + "gtsm1 = pd.concat([gtsm1, add_pts])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abcb4fc8", + "metadata": {}, + "outputs": [], + "source": [ + "# Manual deletions of certain points that don't fall nearer to coastlines than other points\n", + "del_ids = [\n", + " \"eur_01019\",\n", + " \"eur_01812\",\n", + " \"eur_00979\",\n", + " \"13536\",\n", + " \"14447\",\n", + " \"15646\",\n", + " \"18265\",\n", + " \"18656\",\n", + " \"18720\",\n", + " \"18724\",\n", + "]\n", + "del_ids = [\"id_coast_glob_\" + del_ids[i] for i in range(len(del_ids))]\n", + "gtsm1 = gtsm1[~gtsm1.station_id.isin(del_ids)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88c6ce74", + "metadata": {}, + "outputs": [], + "source": [ + "# Remove buoy and obs points\n", + "gtsm1 = gtsm1[~gtsm1.station_id.str.contains(\"buoy\")]\n", + "gtsm1 = gtsm1[~gtsm1.station_id.str.contains(\"obs\")]\n", + "\n", + "# Remove duplicates\n", + "idx_unique = pd.DataFrame(gtsm1.geometry).drop_duplicates().index\n", + "gtsm1 = gtsm1[gtsm1.index.isin(idx_unique)]\n", + "\n", + "# Remove unwanted columns\n", + "gtsm1 = gtsm1.drop(columns=[\"fid\", \"field_1\", \"serial_id\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c04a694e", + "metadata": {}, + "outputs": [], + "source": [ + "# Export resulting layers\n", + "gtsm1.to_file(PATH_SEG_CENTROIDS) # final set of majority GTSM points for CIAM segs" + ] + }, + { + "cell_type": "markdown", + "id": "b6cb46e3", + "metadata": {}, + "source": [ + "### [ASIDE] Identify which NaturalEarth land masses have exposure (pop or capital)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d03b678", + "metadata": {}, + "outputs": [], + "source": [ + "# land = gpd.read_parquet(TMPDIR + \"ne_coastline_polys_CIAM_exposure_matches.parquet\")\n", + "# land_exp = land[land.contains_exposure == True]\n", + "# land_exp.to_file(TMPDIR + \"ne_coastline_polys_CIAM_wexp.shp\")\n", + "\n", + "# land_noexp = land[land.contains_exposure == False]\n", + "# land_noexp.to_file(TMPDIR + \"ne_coastline_polys_CIAM_noexp.shp\")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/10-combine_exposure_tiles.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/10-combine_exposure_tiles.ipynb new file mode 100644 index 0000000..55f4076 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/10-combine_exposure_tiles.ipynb @@ -0,0 +1,1379 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# Combine exposure tiles to construct with-elevation, without-elevation, and area-by-elevation exposure parquets\n", + "Take all the 1-degree by 1-degree binned exposure tiles and combine them to form three global datasets:\n", + "1. \"With-elevation\" binned exposure: Includes all areas with elevations up to `sset.HIGHEST_WITHELEV_EXPOSURE_METERS`\n", + "2. \"Without-elevation\" binned exposure: Includes all global exposure\n", + "3. Area-by-seg-adm1: For each segment and adm1 region, the total area, in square kilometers, that is closer to that segment than to any other segment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "\n", + "import dask.dataframe as ddf\n", + "import dask.distributed as dd\n", + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "import rhg_compute_tools.kubernetes as rhgk\n", + "import rhg_compute_tools.utils as rhgu\n", + "\n", + "from sliiders import settings as sset\n", + "from sliiders import spatial\n", + "\n", + "spatial.filter_spatial_warnings()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dir_batches = sset.DIR_EXPOSURE_BINNED_TMP / \"batches\"\n", + "dir_batches.mkdir(exist_ok=False)\n", + "\n", + "dir_seg_batches = sset.DIR_EXPOSURE_BINNED_TMP / \"segment_area_batches\"\n", + "dir_seg_batches.mkdir(exist_ok=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define batching function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@rhgu.block_globals\n", + "def run_batch(batch_num, batch_size, in_paths, dir_batches, include_tile_name=False):\n", + " exp = []\n", + " batch_paths = in_paths[\n", + " batch_num * batch_size : min((batch_num + 1) * batch_size, len(in_paths))\n", + " ]\n", + "\n", + " for filename in batch_paths:\n", + " try:\n", + " df = pd.read_csv(filename, index_col=None, header=0)\n", + " if include_tile_name:\n", + " df[\"filename\"] = filename.stem\n", + " exp.append(df)\n", + " except pd.errors.EmptyDataError:\n", + " # these are the placeholder CSVs\n", + " pass\n", + "\n", + " exp = pd.concat(exp, axis=0, ignore_index=True)\n", + " if \"wetland_flag\" in exp.columns:\n", + " exp[\"wetland_flag\"] = exp[\"wetland_flag\"].astype(bool)\n", + "\n", + " exp.to_parquet(dir_batches / f\"batch_{batch_num}.parquet\")\n", + "\n", + " return 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start workers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nworkers = 32" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client, cluster = rhgk.get_micro_cluster()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cluster.scale(nworkers)\n", + "\n", + "cluster" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combine 1-degree tile CSVs into batches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tile_paths = list(sset.DIR_EXPOSURE_BINNED_TMP_TILES.glob(\"*.csv\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = int(len(tile_paths) / (nworkers * 2)) + 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# shuffling the paths helps assure each worker gets CSV batches of about the same total size\n", + "random.seed(1)\n", + "random.shuffle(tile_paths)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "batch_futures = [\n", + " client.submit(run_batch, i, batch_size, tile_paths, dir_batches)\n", + " for i in range(nworkers * 2)\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(batch_futures)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combine 1-degree segment-area tile CSVs into batches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "seg_tile_paths = list(sset.DIR_EXPOSURE_BINNED_TMP_TILES_SEGMENT_AREA.glob(\"*.csv\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = int(len(seg_tile_paths) / (nworkers * 2)) + 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# shuffling the paths helps assure each worker gets CSV batches of about the same total size\n", + "random.seed(1)\n", + "random.shuffle(seg_tile_paths)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "batch_futures = [\n", + " client.submit(run_batch, i, batch_size, seg_tile_paths, dir_seg_batches)\n", + " for i in range(nworkers * 2)\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(batch_futures)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Merge tile batches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_ddf = ddf.read_parquet(str(dir_batches / f\"batch_*.parquet\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_ddf = exp_ddf.rename(columns={\"value\": \"asset_value\"})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_ddf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "column_dtypes = {\n", + " \"z_ix\": np.int32,\n", + " \"seg_adm\": str,\n", + " \"protection_zone\": np.int16,\n", + " \"area_km\": np.float32,\n", + " \"asset_value\": np.float32,\n", + " \"pop_landscan\": np.float32,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_ddf = exp_ddf.astype(column_dtypes).persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_ddf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Merge segment-area tile batches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "seg_area_ddf = ddf.read_parquet(str(dir_seg_batches / f\"batch_*.parquet\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area_by_elev = seg_area_ddf.groupby(\n", + " [\"z_ix\", \"seg_adm\", \"protection_zone\", \"wetland_flag\"]\n", + ")[\"area_km\"].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area_by_elev = area_by_elev.persist()\n", + "dd.progress(area_by_elev)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area_by_elev = area_by_elev.reset_index(drop=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "highest_z_ix = (\n", + " int(sset.HIGHEST_WITHELEV_EXPOSURE_METERS / sset.EXPOSURE_BIN_WIDTH_H) - 1\n", + ")\n", + "area_by_elev = area_by_elev[area_by_elev[\"z_ix\"] <= highest_z_ix]\n", + "\n", + "area_by_elev" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam = (\n", + " area_by_elev.groupby([\"z_ix\", \"seg_adm\", \"protection_zone\", \"wetland_flag\"])[\n", + " \"area_km\"\n", + " ]\n", + " .sum()\n", + " .reset_index(drop=False)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area_by_elev_dtypes = {\n", + " \"z_ix\": np.int16,\n", + " \"seg_adm\": \"category\",\n", + " \"protection_zone\": \"category\",\n", + " \"wetland_flag\": bool,\n", + " \"area_km\": np.float32,\n", + " \"land_area_km\": np.float32,\n", + " \"wetland_area_km\": np.float32,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam = ciam.astype({k: v for k, v in area_by_elev_dtypes.items() if k in ciam.columns})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam = ciam.persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_local = ciam.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def divide_area_by_elev_into_wetland_and_non_wetland(area_by_elev_local):\n", + " group_cols = [\n", + " c for c in area_by_elev_local.columns if c not in [\"wetland_flag\", \"area_km\"]\n", + " ]\n", + "\n", + " with_wetland = area_by_elev_local.loc[area_by_elev_local[\"wetland_flag\"]]\n", + " without_wetland = area_by_elev_local.loc[~area_by_elev_local[\"wetland_flag\"]]\n", + " area_by_elev_local = pd.merge(\n", + " without_wetland,\n", + " with_wetland,\n", + " left_on=group_cols,\n", + " right_on=group_cols,\n", + " suffixes=(\"_no_wetland\", \"_wetland\"),\n", + " how=\"outer\",\n", + " ).reset_index(drop=True)\n", + "\n", + " area_by_elev_local = area_by_elev_local.drop(\n", + " columns=[\"wetland_flag_no_wetland\", \"wetland_flag_wetland\"]\n", + " )\n", + "\n", + " area_by_elev_local = area_by_elev_local.rename(\n", + " columns={\n", + " \"area_km_no_wetland\": \"land_area_km\",\n", + " \"area_km_wetland\": \"wetland_area_km\",\n", + " }\n", + " )\n", + "\n", + " area_by_elev_local[\"land_area_km\"] = area_by_elev_local[\"land_area_km\"].fillna(0)\n", + " area_by_elev_local[\"wetland_area_km\"] = area_by_elev_local[\n", + " \"wetland_area_km\"\n", + " ].fillna(0)\n", + "\n", + " area_by_elev_local = area_by_elev_local.astype(\n", + " {\n", + " k: v\n", + " for k, v in area_by_elev_dtypes.items()\n", + " if k in area_by_elev_local.columns\n", + " }\n", + " )\n", + "\n", + " return area_by_elev_local.reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_local = divide_area_by_elev_into_wetland_and_non_wetland(ciam_local)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Remove any old versions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION.parent.mkdir(exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Save parquet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_local.to_parquet(sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION, index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client.cancel(area_by_elev)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create without-elevation dataframe from with-elevation tiles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_ddf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_ddf = exp_ddf.groupby(\n", + " [\"seg_adm\"],\n", + ")[[\"asset_value\", \"pop_landscan\", \"area_km\"]].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_ddf = withoutelev_ddf.reset_index(drop=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_ddf = withoutelev_ddf.persist()\n", + "dd.progress(withoutelev_ddf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_ddf = withoutelev_ddf.astype(\n", + " {k: v for k, v in column_dtypes.items() if k in withoutelev_ddf.columns}\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_ddf = withoutelev_ddf.persist()\n", + "dd.progress(withoutelev_ddf)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Remove any old versions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHOUTELEV.exists()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Save parquet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_pq_out = withoutelev_ddf.to_parquet(\n", + " sset.PATH_EXPOSURE_BINNED_WITHOUTELEV,\n", + " engine=\"pyarrow\",\n", + " write_index=False,\n", + " compute=False,\n", + ").persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(withoutelev_ddf)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create with-elevation parquet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_ddf = exp_ddf[exp_ddf[\"z_ix\"] <= highest_z_ix]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_ddf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_ddf = withelev_ddf.groupby([\"z_ix\", \"seg_adm\", \"protection_zone\"])[\n", + " [\"area_km\", \"asset_value\", \"pop_landscan\"]\n", + "].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_ddf = withelev_ddf.reset_index(drop=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_ddf = withelev_ddf.persist()\n", + "dd.progress(withelev_ddf)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Remove any old versions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHELEV" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHELEV.exists()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Save parquet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_pq_out = withelev_ddf.to_parquet(\n", + " sset.PATH_EXPOSURE_BINNED_WITHELEV,\n", + " engine=\"pyarrow\",\n", + " write_index=False,\n", + " compute=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_pq_out = withelev_pq_out.persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(withelev_pq_out)" + ] + }, + { + "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": [ + "## Make some final adjustments and checks" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev = pd.read_parquet(sset.PATH_EXPOSURE_BINNED_WITHELEV)\n", + "\n", + "withoutelev = pd.read_parquet(sset.PATH_EXPOSURE_BINNED_WITHOUTELEV)\n", + "\n", + "area_ciam = pd.read_parquet(sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exp_dtypes = {\n", + " \"z_ix\": np.int32,\n", + " \"seg_adm\": \"category\",\n", + " \"protection_zone\": np.int16,\n", + " \"area_km\": np.float32,\n", + " \"asset_value\": np.float32,\n", + " \"pop_landscan\": np.float32,\n", + "}\n", + "\n", + "# Step through fields one-by-one to prevent memory explosion copying the whole dataframe\n", + "for field, field_type in exp_dtypes.items():\n", + " withelev[field] = withelev[field].astype(field_type)\n", + "\n", + "for field, field_type in exp_dtypes.items():\n", + " if field in withoutelev.columns:\n", + " withoutelev[field] = withoutelev[field].astype(field_type)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev = withelev[\n", + " (withelev[\"asset_value\"] > 0) | (withelev[\"pop_landscan\"] > 0)\n", + "].reset_index(drop=True)\n", + "\n", + "withoutelev = withoutelev[\n", + " (withoutelev[\"asset_value\"] > 0) | (withoutelev[\"pop_landscan\"] > 0)\n", + "].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_adm1(df):\n", + " df[\"adm1\"] = df[\"seg_adm\"].str[15:]\n", + " df[\"ISO\"] = df[\"adm1\"].str[:3]\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area_ciam = parse_adm1(area_ciam)\n", + "withelev = parse_adm1(withelev)\n", + "withoutelev = parse_adm1(withoutelev)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Check against PWT 10.0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ktable_full = pd.read_parquet(sset.PATH_COUNTRY_LEVEL_EXPOSURE)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ktable_full = ktable_full.reset_index(drop=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ktable_full = ktable_full[ktable_full[\"year\"] == 2019].set_index(\"ccode\")[\n", + " [\"cn_19\", \"pop\"]\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ktable = ktable_full[\"cn_19\"] * 1e6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pop = ktable_full[\"pop\"] * 1e6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "replacements = {\"XAD\": \"GBR\", \"XKO\": \"KO-\", \"XNC\": \"CYP\", \"XPI\": \"CHN\"}\n", + "\n", + "area_ciam[\"ISO\"] = area_ciam[\"ISO\"].apply(\n", + " lambda c: replacements[c] if c in replacements else c\n", + ")\n", + "\n", + "withelev[\"ISO\"] = withelev[\"ISO\"].apply(\n", + " lambda c: replacements[c] if c in replacements else c\n", + ")\n", + "\n", + "withoutelev[\"ISO\"] = withoutelev[\"ISO\"].apply(\n", + " lambda c: replacements[c] if c in replacements else c\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "set(ktable.index) - set(withoutelev[\"ISO\"].unique())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "set(withoutelev[\"ISO\"].unique()) - set(ktable.index)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "assert len(set(withoutelev[\"ISO\"].unique()) - set(ktable.index)) == 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rescale asset value if needed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "country_totals = withoutelev.groupby(\"ISO\")[\"asset_value\"].sum()\n", + "country_totals.name = \"country_asset_value\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "check = pd.DataFrame(ktable).join(country_totals, on=\"ccode\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "check[\"diff\"] = check[\"cn_19\"] / check[\"country_asset_value\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If rescaling:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaling = check[[\"diff\"]]\n", + "\n", + "scaling[\"diff\"].max(), scaling[\"diff\"].min()\n", + "\n", + "withoutelev = withoutelev.join(scaling, on=\"ISO\")\n", + "withelev = withelev.join(scaling, on=\"ISO\")\n", + "\n", + "withoutelev[\"asset_value\"] = withoutelev[\"asset_value\"] * withoutelev[\"diff\"]\n", + "withelev[\"asset_value\"] = withelev[\"asset_value\"] * withelev[\"diff\"]\n", + "\n", + "withoutelev = withoutelev.drop(columns=[\"diff\"])\n", + "withelev = withelev.drop(columns=[\"diff\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rescale population if needed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "country_totals_landscan = withoutelev.groupby(\"ISO\")[\"pop_landscan\"].sum()\n", + "country_totals_landscan.name = \"country_population_landscan\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "check = pd.DataFrame(pop).join(country_totals_landscan, on=\"ccode\")\n", + "check[\"diff_landscan\"] = check[\"pop\"] / check[\"country_population_landscan\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If rescaling:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaling = check[[\"diff_landscan\"]]\n", + "\n", + "scaling[\"diff_landscan\"].max(), scaling[\"diff_landscan\"].min()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev = withoutelev.join(scaling, on=\"ISO\")\n", + "withelev = withelev.join(scaling, on=\"ISO\")\n", + "\n", + "withoutelev[\"pop_landscan\"] = withoutelev[\"pop_landscan\"] * withoutelev[\"diff_landscan\"]\n", + "withelev[\"pop_landscan\"] = withelev[\"pop_landscan\"] * withelev[\"diff_landscan\"]\n", + "\n", + "withoutelev = withoutelev.drop(columns=[\"diff_landscan\"])\n", + "withelev = withelev.drop(columns=[\"diff_landscan\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev[\"asset_value\"].sum() / 1e12" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev[\"asset_value\"].sum() / 1e12" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev[\"pop_landscan\"].sum() / 1e9" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev[\"pop_landscan\"].sum() / 1e9" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev[\"ISO\"] = withoutelev[\"ISO\"].astype(\"category\")\n", + "withelev[\"ISO\"] = withelev[\"ISO\"].astype(\"category\")\n", + "\n", + "withoutelev[\"asset_value\"] = withoutelev[\"asset_value\"].astype(np.float32)\n", + "withelev[\"asset_value\"] = withelev[\"asset_value\"].astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHELEV.exists()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Delete" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHELEV" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev.to_parquet(sset.PATH_EXPOSURE_BINNED_WITHELEV, index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHOUTELEV.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BINNED_WITHOUTELEV" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev.to_parquet(sset.PATH_EXPOSURE_BINNED_WITHOUTELEV, index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area_ciam.to_parquet(sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION, index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add `lowelev` field to CIAM-Adm1 intersections file to indicate inclusion in elevation processing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_adm1 = gpd.read_parquet(sset.PATH_CIAM_ADM1_VORONOI_INTERSECTIONS)\n", + "ciam_adm1[\"lowelev\"] = ciam_adm1[\"seg_adm\"].isin(withelev[\"seg_adm\"].unique())\n", + "ciam_adm1[\"ISO\"] = ciam_adm1[\"ISO\"].apply(\n", + " lambda c: replacements[c] if c in replacements else c\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_adm1.to_parquet(\n", + " sset.PATH_CIAM_ADM1_VORONOI_INTERSECTIONS, index=False, row_group_size=500\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check that it looks good" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### withelev" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_out = pd.read_parquet(sset.PATH_EXPOSURE_BINNED_WITHELEV)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_out.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_out[\"asset_value\"].sum() / 1e12" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### withoutelev" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_out = pd.read_parquet(sset.PATH_EXPOSURE_BINNED_WITHOUTELEV)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_out.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_out[\"asset_value\"].sum() / 1e12" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### CIAM area-by-elevation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area = pd.read_parquet(sset.PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "area.head()" + ] + } + ], + "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.8.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/2-create-segment-regions.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/2-create-segment-regions.ipynb new file mode 100644 index 0000000..b6210aa --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/2-create-segment-regions.ipynb @@ -0,0 +1,1033 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "735b7444-8a68-4f6e-987c-c045a53b64c6", + "metadata": { + "tags": [] + }, + "source": [ + "# Generate set of administrative regions to use in exposure grid\n", + "- The idea here is to get a globally comprehensive set of administrative boundaries at the `adm1` level or higher if the `adm1` level is not available\n", + "- Use `adm1` if available and `adm0` if not" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6e027b29-8979-440c-affa-b55d30ddd87a", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f26ced68", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/srv/conda/envs/notebook/lib/python3.9/site-packages/dask_gateway/client.py:21: FutureWarning: format_bytes is deprecated and will be removed in a future release. Please use dask.utils.format_bytes instead.\n", + " from distributed.utils import LoopRunner, format_bytes\n" + ] + } + ], + "source": [ + "import warnings\n", + "\n", + "import geopandas as gpd\n", + "import pandas as pd\n", + "from shapely.errors import ShapelyDeprecationWarning\n", + "\n", + "from sliiders import settings as sset\n", + "from sliiders import spatial" + ] + }, + { + "cell_type": "markdown", + "id": "5ad804d0-523e-4086-a147-926e4a74147a", + "metadata": {}, + "source": [ + "#### Read full `adm0` and `adm1` sets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "10b69ed5-7c8f-4d87-9151-036c300d673f", + "metadata": {}, + "outputs": [], + "source": [ + "adm0 = (\n", + " gpd.read_file(sset.PATH_GADM, layer=\"level0\")[[\"GID_0\", \"geometry\"]]\n", + " .set_crs(epsg=4326)\n", + " .set_index(\"GID_0\")\n", + " .geometry\n", + ")\n", + "adm1 = (\n", + " gpd.read_file(sset.PATH_GADM, layer=\"level1\")[[\"GID_0\", \"GID_1\", \"geometry\"]]\n", + " .set_crs(epsg=4326)\n", + " .set_index(\"GID_1\")\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8aa26393-836c-47fd-9b0d-a91ae0ffc839", + "metadata": { + "tags": [] + }, + "source": [ + "#### Exclude non-territory ISOs\n", + "- `ATA`: Antarctica\n", + "- `XCA`: Caspian Sea" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ebcc3561-631d-4648-b0c5-eaf6cc583b02", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ATA', 'XCA']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sset.EXCLUDED_ISOS" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4840ab34-0646-4a2b-95fe-738df65e980f", + "metadata": {}, + "outputs": [], + "source": [ + "# Filter out excluded ISOs\n", + "adm0 = adm0[~adm0.index.isin(sset.EXCLUDED_ISOS)]\n", + "adm1 = adm1[~adm1[\"GID_0\"].isin(sset.EXCLUDED_ISOS)]" + ] + }, + { + "cell_type": "markdown", + "id": "b0354db1-e44f-4619-8fd9-648aa20dc0da", + "metadata": {}, + "source": [ + "#### Select only countries in `adm0` that do not appear in the `adm1` set, to be included as intermediate `adm1` regions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "43c4eb7a-d569-4096-bda2-915b147a5c04", + "metadata": {}, + "outputs": [], + "source": [ + "adm0_as_adm1 = adm0.drop(adm1.GID_0.unique())" + ] + }, + { + "cell_type": "markdown", + "id": "36e4a88b-ec4c-43d7-bd77-294b7008c816", + "metadata": {}, + "source": [ + "#### Concatenate all `adm1` regions" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d5a6c1a0-404f-4d9b-90a6-fa472953b040", + "metadata": {}, + "outputs": [], + "source": [ + "full = pd.concat([adm0_as_adm1.to_frame(), adm1]).geometry.to_frame()\n", + "full[\"ISO\"] = full.index.str.split(\".\").str[0]\n", + "full.index.name = \"adm1\"\n", + "assert full.index.is_unique\n", + "seg_centroids = gpd.read_file(sset.PATH_SEG_CENTROIDS).set_index(\"station_id\").geometry\n", + "coastlines = gpd.read_file(sset.PATH_CIAM_COASTLINES).set_index(\"line_id\").geometry\n", + "overlay_name = \"seg_adm\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f603158c-54e5-4e2d-82c6-0676ba8b7064", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating global Voronoi shapes for regions...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5e4e49d791be4a22b480fdc8199eef6f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/362 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "with warnings.catch_warnings():\n", + " warnings.filterwarnings(\"ignore\", category=ShapelyDeprecationWarning)\n", + " all_overlays = spatial.create_overlay_voronois(\n", + " full, seg_centroids, coastlines, overlay_name, plot=True\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31b77d44-3a31-42a6-a67b-4d869765c73f", + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_CIAM_ADM1_VORONOI_INTERSECTIONS.parent.mkdir(exist_ok=False)\n", + "\n", + "all_overlays.to_parquet(sset.PATH_CIAM_ADM1_VORONOI_INTERSECTIONS, index=False)\n", + "all_overlays.to_file(sset.PATH_CIAM_ADM1_VORONOI_INTERSECTIONS_SHP)" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0374c1d8757d4e1dacdcabb664a8308d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_24e5d8edc2844796b805ad8a2bd156c0", + "max": 362, + "style": "IPY_MODEL_2705843ad2a042c680fa4ac2b8c08962", + "value": 362 + } + }, + "060b8277577e40bc932193c864698485": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_2aed0f1150db476ea1159d2d6e9adb00", + "max": 1812, + "style": "IPY_MODEL_2100273581d54e53bb0558e2a16d9187", + "value": 1812 + } + }, + "0b84dd267f3442c78853a030af4efeca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_63afc70313664099a7d62babce51c3b8", + "style": "IPY_MODEL_986f01097a00441095f9becd2c64915a", + "value": " 47/47 [00:11<00:00, 4.04it/s]" + } + }, + "13ecd51aefab4c6a83b847a43186ff2d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "170a0a1f73dc4158b0597431ec52f6ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "1923e2932e9d41e1a0ea2e87fad2d60b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_80b44682c9664773afa0a088caecab71", + "max": 47, + "style": "IPY_MODEL_addfd0c51a094222a934127dac51a548", + "value": 47 + } + }, + "1e8c99c057bc48b894bc9fe8c221ee54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_750c24a46eba489f88c427e6f8c4f54a", + "style": "IPY_MODEL_ded88cc42c4b47f3b20f8b2f92800535", + "value": "100%" + } + }, + "2100273581d54e53bb0558e2a16d9187": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "24e5d8edc2844796b805ad8a2bd156c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "25d3c4c6296f4a7aa6618dfaab857296": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "2705843ad2a042c680fa4ac2b8c08962": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "29505693297245fb8a3bfd9ff64b6113": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "2aed0f1150db476ea1159d2d6e9adb00": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "30b6380bb88e4e07b086258c4d66a45b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "31116ceeae4d4f8b97ca45f9add694f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3e64137074c94d538e1e5ccbde13d512": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "45bd4de33c474a67b78138228c65f495": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_30b6380bb88e4e07b086258c4d66a45b", + "style": "IPY_MODEL_86f26d2b1f9440039fb4eca10a3dc988", + "value": " 1812/1812 [03:10<00:00, 30.80it/s]" + } + }, + "483ed794768f4856878163626d3db887": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "4942699b42c6475a905a906a747f5b03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_29505693297245fb8a3bfd9ff64b6113", + "max": 8, + "style": "IPY_MODEL_25d3c4c6296f4a7aa6618dfaab857296", + "value": 8 + } + }, + "4d13eb5be5d7436b8faa3918aa989534": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "528a3c212bc6409ca12174f650eee29b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "535c72cf644444bc9d586f0325495ef2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "54034804419b48919e49c872fc873b9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "55f58f53c1f248c78726021622b278d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3e64137074c94d538e1e5ccbde13d512", + "style": "IPY_MODEL_54034804419b48919e49c872fc873b9a", + "value": "100%" + } + }, + "56e1f6044a60443282447e58f1f30c4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "572046801e274f4c89e72c333a6d7504": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_528a3c212bc6409ca12174f650eee29b", + "max": 1812, + "style": "IPY_MODEL_59123326de9d4776a2991704c9aa124a", + "value": 1812 + } + }, + "59123326de9d4776a2991704c9aa124a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "5bc8b2140f4e4b5a8cd05f57fed7c058": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_4d13eb5be5d7436b8faa3918aa989534", + "style": "IPY_MODEL_95f71e0c12de4035a797f05d0571e897", + "value": " 1812/1812 [01:08<00:00, 28.06it/s]" + } + }, + "5c96125f4bee41f58a1dc8be8fdaae8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_c1f4000e74804820a48a354d387aaa43", + "style": "IPY_MODEL_b048b225856047669208041317fda313", + "value": "100%" + } + }, + "5e4e49d791be4a22b480fdc8199eef6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_55f58f53c1f248c78726021622b278d5", + "IPY_MODEL_0374c1d8757d4e1dacdcabb664a8308d", + "IPY_MODEL_cc3f8ee8b9304c19b593b8f85c218fb3" + ], + "layout": "IPY_MODEL_d67e6c0d449845ab9a35bf98d1f1c13b" + } + }, + "63afc70313664099a7d62babce51c3b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "6586b8e007d243c6a45013e81639424a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a420f54348b4484ba7c366b388948141", + "style": "IPY_MODEL_ac061fc1c1a848d68230326fd7948aa7", + "value": "100%" + } + }, + "67f50135b37543eb89f0e41789839a5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_5c96125f4bee41f58a1dc8be8fdaae8d", + "IPY_MODEL_1923e2932e9d41e1a0ea2e87fad2d60b", + "IPY_MODEL_0b84dd267f3442c78853a030af4efeca" + ], + "layout": "IPY_MODEL_aa77f38bd867410facfc2a506958c73b" + } + }, + "72c7eecd602b4f9fa6f8e1533db44406": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "750c24a46eba489f88c427e6f8c4f54a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "756013cd23e743d1bf8903131753def2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_1e8c99c057bc48b894bc9fe8c221ee54", + "IPY_MODEL_9a415ca6e85542dbb61774521f366791", + "IPY_MODEL_f970e8fac44b443dbb4535c99431dc96" + ], + "layout": "IPY_MODEL_839e18a9937d4eafb84b19bf8e2b4232" + } + }, + "773ea45822c94a62b21715ae834d5b50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "7fbbc5f4442d4b2b89e6d9a252b5941b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ceec393c4b3a47b386988a158c562f62", + "style": "IPY_MODEL_31116ceeae4d4f8b97ca45f9add694f9", + "value": " 207/207 [00:45<00:00, 3.55it/s]" + } + }, + "80b44682c9664773afa0a088caecab71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "815c2326bea24297a25883220adc62e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_6586b8e007d243c6a45013e81639424a", + "IPY_MODEL_b4b03c9a719344e780f579be1c7fdea2", + "IPY_MODEL_7fbbc5f4442d4b2b89e6d9a252b5941b" + ], + "layout": "IPY_MODEL_f0eb3584d41940dd848236cf38a8a8ce" + } + }, + "839e18a9937d4eafb84b19bf8e2b4232": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "86f26d2b1f9440039fb4eca10a3dc988": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "887da7bf7c90494eb0b24ac872ccb78e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "89f91f9f7db641c9a9e4d07ad54a556d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_92d2a9ccd789408f947f0f8072e46f0e", + "style": "IPY_MODEL_56e1f6044a60443282447e58f1f30c4a", + "value": "100%" + } + }, + "8a0d809dbb234822b6a916b65b2371a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_bdcb06328d9a429d9efa1460d745710d", + "style": "IPY_MODEL_95f5b61e62644d4aae27129d4e51beca", + "value": " 8/8 [00:01<00:00, 5.79it/s]" + } + }, + "8e2d37e64f4b4d0284e1c24b6c0cfff8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "92d2a9ccd789408f947f0f8072e46f0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "94491b9204e44c48a9eec0cd69fe7098": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "94d26121e07e402fabe03ebe890b8be5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "95f5b61e62644d4aae27129d4e51beca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "95f71e0c12de4035a797f05d0571e897": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "96a2d9cadcd942a0ac8777b6708a6a8e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "986f01097a00441095f9becd2c64915a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "999039649c5b43acba264830aa5de738": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "9a415ca6e85542dbb61774521f366791": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_13ecd51aefab4c6a83b847a43186ff2d", + "max": 8, + "style": "IPY_MODEL_daaec40b64c649cfbd8c33b122fc8231", + "value": 8 + } + }, + "a1eb2a953b8148c3ac6b7c0f18210f26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_89f91f9f7db641c9a9e4d07ad54a556d", + "IPY_MODEL_060b8277577e40bc932193c864698485", + "IPY_MODEL_45bd4de33c474a67b78138228c65f495" + ], + "layout": "IPY_MODEL_999039649c5b43acba264830aa5de738" + } + }, + "a420f54348b4484ba7c366b388948141": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "aa77f38bd867410facfc2a506958c73b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "ac061fc1c1a848d68230326fd7948aa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "addfd0c51a094222a934127dac51a548": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "b048b225856047669208041317fda313": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "b3d2f95d407b4421be0cd760165c5425": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_170a0a1f73dc4158b0597431ec52f6ec", + "style": "IPY_MODEL_df446b59f3784f5598ee8861d2e6b838", + "value": "100%" + } + }, + "b4b03c9a719344e780f579be1c7fdea2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_8e2d37e64f4b4d0284e1c24b6c0cfff8", + "max": 207, + "style": "IPY_MODEL_72c7eecd602b4f9fa6f8e1533db44406", + "value": 207 + } + }, + "bc6e3e2ffcbb41789cd304dda1239fe6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "bdcb06328d9a429d9efa1460d745710d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "c1f4000e74804820a48a354d387aaa43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "cc3f8ee8b9304c19b593b8f85c218fb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_535c72cf644444bc9d586f0325495ef2", + "style": "IPY_MODEL_887da7bf7c90494eb0b24ac872ccb78e", + "value": " 362/362 [08:20<00:00, 1.10it/s]" + } + }, + "cec434b2a0ce459fb1bd21e00c4a46e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_94d26121e07e402fabe03ebe890b8be5", + "style": "IPY_MODEL_773ea45822c94a62b21715ae834d5b50", + "value": "100%" + } + }, + "ceec393c4b3a47b386988a158c562f62": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "d3f1d09c1a7a467e9c8b2830b89f6271": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_b3d2f95d407b4421be0cd760165c5425", + "IPY_MODEL_572046801e274f4c89e72c333a6d7504", + "IPY_MODEL_5bc8b2140f4e4b5a8cd05f57fed7c058" + ], + "layout": "IPY_MODEL_96a2d9cadcd942a0ac8777b6708a6a8e" + } + }, + "d67e6c0d449845ab9a35bf98d1f1c13b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "daaec40b64c649cfbd8c33b122fc8231": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "ded88cc42c4b47f3b20f8b2f92800535": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "df446b59f3784f5598ee8861d2e6b838": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "f0eb3584d41940dd848236cf38a8a8ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "f5266bebb0eb49c9990e2af602fadb2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_cec434b2a0ce459fb1bd21e00c4a46e1", + "IPY_MODEL_4942699b42c6475a905a906a747f5b03", + "IPY_MODEL_8a0d809dbb234822b6a916b65b2371a9" + ], + "layout": "IPY_MODEL_483ed794768f4856878163626d3db887" + } + }, + "f970e8fac44b443dbb4535c99431dc96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_94491b9204e44c48a9eec0cd69fe7098", + "style": "IPY_MODEL_bc6e3e2ffcbb41789cd304dda1239fe6", + "value": " 8/8 [00:08<00:00, 1.22s/it]" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/3-fill_missing_litpop_with_geg.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/3-fill_missing_litpop_with_geg.ipynb new file mode 100644 index 0000000..5da4595 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/3-fill_missing_litpop_with_geg.ipynb @@ -0,0 +1,765 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Augment Missing Data in LitPop with Geg-15" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are some missing countries in LitPop. This notebook fills in those areas with Geg-15 and saves the grid as a single parquet file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import zipfile\n", + "from pathlib import Path\n", + "\n", + "import dask.dataframe as ddf\n", + "import geopandas as gpd\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import numpy_groupies as npg\n", + "import pandas as pd\n", + "import regionmask\n", + "import xarray as xr\n", + "import xesmf as xe\n", + "from cartopy import crs as ccrs\n", + "from cartopy import feature as cfeature\n", + "\n", + "import rhg_compute_tools.kubernetes as rhgk\n", + "from sliiders import __file__\n", + "from sliiders import settings as sset\n", + "from sliiders.spatial import get_iso_geometry, grid_ix_to_val, grid_val_to_ix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client, cluster = rhgk.get_micro_cluster()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nworkers = 16\n", + "cluster.scale(nworkers)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sliiders_dir = Path(__file__).parent\n", + "zipf = zipfile.ZipFile(\"sliiders.zip\", \"w\", zipfile.ZIP_DEFLATED)\n", + "for root, dirs, files in os.walk(sliiders_dir):\n", + " for file in files:\n", + " zipf.write(\n", + " os.path.join(root, file),\n", + " os.path.relpath(os.path.join(root, file), os.path.join(sliiders_dir, \"..\")),\n", + " )\n", + "zipf.close()\n", + "client.upload_file(\"sliiders.zip\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "litpop = (\n", + " ddf.read_csv(\n", + " str(sset.PATH_LITPOP_RAW),\n", + " dtype={\"value\": \"float32\", \"lat\": \"float32\", \"lon\": \"float32\"},\n", + " )\n", + " .rename(columns={\"latitude\": \"lat\", \"longitude\": \"lon\"})\n", + " .repartition(npartitions=nworkers)\n", + " .persist()\n", + ")\n", + "litpop_meta = pd.read_csv(sset.DIR_LITPOP_RAW / \"_metadata_countries_v1_2.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create Geodataframe for Countries with Missing LitPop Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "missing_countries = litpop_meta[litpop_meta[\"included\"] == 0].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "missing_countries = gpd.GeoDataFrame(\n", + " missing_countries,\n", + " geometry=get_iso_geometry(missing_countries[\"iso3\"].to_numpy()),\n", + ")\n", + "\n", + "missing_countries[\"iso3\"].unique()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "region_id_to_iso = litpop_meta.set_index(\"region_id\")[[\"iso3\"]]\n", + "\n", + "litpop = litpop.join(region_id_to_iso, on=\"region_id\").persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "geg15 = pd.read_parquet(sset.PATH_GEG15_INT, columns=[\"lon\", \"lat\", \"iso3\", \"tot_val\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "geg15[\"tot_val\"] = geg15[\"tot_val\"] * 1e6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lp_iso3 = litpop[\"iso3\"].unique().compute()\n", + "geg_iso3 = geg15[\"iso3\"].unique()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Helper Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# retrieve geg data to regrid\n", + "def subset_relevant_geg_data(poly, geg15, buffer=1 / 48):\n", + " # subset geg for buffered country poly bounds\n", + " geg15_sub = (\n", + " geg15[\n", + " (geg15.lon >= poly.bounds[0] - buffer)\n", + " & (geg15.lon <= poly.bounds[2] + buffer)\n", + " & (geg15.lat >= poly.bounds[1] - buffer)\n", + " & (geg15.lat <= poly.bounds[3] + buffer)\n", + " ][[\"lon\", \"lat\", \"tot_val\"]].reset_index(drop=True)\n", + " # .compute()\n", + " )\n", + "\n", + " if geg15_sub.shape[0] == 0:\n", + " return None\n", + "\n", + " subset = geg15_sub.set_index([\"lat\", \"lon\"]).to_xarray()\n", + "\n", + " subset[\"mask\"] = poly_mask(poly, subset)\n", + "\n", + " if subset.tot_val.where(subset.mask == 1).sum() <= 0:\n", + " return None\n", + "\n", + " return subset\n", + "\n", + "\n", + "def create_grid(subset, resolution, add_cell_corners=False):\n", + "\n", + " masked_lon = subset.lon.where((subset.mask > 0) & (subset.tot_val.notnull()))\n", + " masked_lat = subset.lat.where((subset.mask > 0) & (subset.tot_val.notnull()))\n", + "\n", + " # construct destination grid with mask holder variable\n", + " x1, y1 = np.floor((masked_lon.lon.min().item(), masked_lat.lat.min().item()))\n", + " x2, y2 = np.ceil((masked_lon.lon.max().item(), masked_lat.lat.max().item()))\n", + "\n", + " lat = np.arange(y1 + resolution / 2, y2, resolution)\n", + " lon = np.arange(x1 + resolution / 2, x2, resolution)\n", + "\n", + " ds_out = xr.Dataset(\n", + " coords={\n", + " \"lat\": lat,\n", + " \"lon\": lon,\n", + " }\n", + " )\n", + "\n", + " if add_cell_corners:\n", + " ds_out.coords[\"lat_b\"] = (ds_out.lat.min().item() - resolution / 2) + np.arange(\n", + " len(ds_out.lat) + 1\n", + " ) * resolution\n", + " ds_out.coords[\"lon_b\"] = (ds_out.lon.min().item() - resolution / 2) + np.arange(\n", + " len(ds_out.lon) + 1\n", + " ) * resolution\n", + "\n", + " return ds_out\n", + "\n", + "\n", + "def poly_mask(poly, grid):\n", + " mask_grid = grid.copy()\n", + " mask_grid[\"mask\"] = (\n", + " [\"lat\", \"lon\"],\n", + " np.full((len(mask_grid.lat), len(mask_grid.lon)), 1, np.int32),\n", + " )\n", + "\n", + " mask_grid = mask_grid.rio.set_spatial_dims(x_dim=\"lon\", y_dim=\"lat\", inplace=True)\n", + " mask_grid = mask_grid.rio.write_crs(\"epsg:4326\", inplace=True)\n", + "\n", + " clipped = mask_grid.rio.clip([poly], drop=False, all_touched=True)\n", + " clipped = (clipped == 1).astype(np.int32)\n", + "\n", + " return clipped.mask.dims, clipped.mask.values\n", + "\n", + "\n", + "def make_land_weights(subset, poly, out_resolution, in_resolution):\n", + "\n", + " print(\"Creating grids...\")\n", + " # create grid at out_resolution with grid cell edges at a whole lat and lon values\n", + " out_grid = create_grid(subset, resolution=out_resolution, add_cell_corners=True)\n", + "\n", + " # create grid at in_resolution with grid cell edges at a whole lat and lon values\n", + " in_grid = create_grid(subset, resolution=in_resolution, add_cell_corners=True)\n", + "\n", + " # create grid cell id for in_grid\n", + " in_grid[\"id5x\"] = (\n", + " [\"lat\", \"lon\"],\n", + " np.arange(in_grid.lat.shape[0] * in_grid.lon.shape[0]).reshape(\n", + " (in_grid.lat.shape[0], in_grid.lon.shape[0])\n", + " ),\n", + " )\n", + "\n", + " # apply in_grid grid cell id to out_grid cells\n", + " out_grid[\"idx5\"] = in_grid.reindex_like(\n", + " out_grid, method=\"nearest\", tolerance=in_resolution / 2\n", + " ).id5x\n", + "\n", + " print(\"Creating land mask...\")\n", + " out_grid[\"mask\"] = (\n", + " regionmask.Regions([poly], numbers=[1])\n", + " .mask(out_grid.lon.values, out_grid.lat.values)\n", + " .fillna(0)\n", + " )\n", + "\n", + " print(\"Constructing land weights...\")\n", + " in_grid[\"land_weights\"] = (\n", + " [\"lat\", \"lon\"],\n", + " npg.aggregate(\n", + " group_idx=out_grid.idx5.values.flatten(),\n", + " a=out_grid.mask.values.flatten(),\n", + " fill_value=0,\n", + " func=\"sum\",\n", + " ).reshape(in_grid.id5x.shape)\n", + " / ((in_resolution / out_resolution) ** 2),\n", + " )\n", + "\n", + " return in_grid\n", + "\n", + "\n", + "def prep_geg_for_regrid(\n", + " poly, geg15, geg_res=sset.GEG_GRID_WIDTH, litpop_res=sset.LITPOP_GRID_WIDTH\n", + "):\n", + "\n", + " # get relevant geg data given poly of interest\n", + " subset = subset_relevant_geg_data(poly, geg15, geg_res / 2)\n", + " if subset is None:\n", + " return None\n", + "\n", + " # construct land weights\n", + " weights = make_land_weights(subset, poly, litpop_res, geg_res)\n", + "\n", + " # add corners for conservative regrid\n", + " subset.coords[\"lat_b\"] = (subset.lat.min().item() - geg_res / 2) + np.arange(\n", + " len(subset.lat) + 1\n", + " ) * geg_res\n", + " subset.coords[\"lon_b\"] = (subset.lon.min().item() - geg_res / 2) + np.arange(\n", + " len(subset.lon) + 1\n", + " ) * geg_res\n", + "\n", + " # regrid landweights onto geg grid\n", + " regridder = xe.Regridder(weights, subset, \"conservative\")\n", + " land_weights_regrid = regridder(weights)\n", + "\n", + " # normalize using amount of land per cell\n", + " weights = geg_res**2\n", + " subset[\"tot_val_norm\"] = (\n", + " subset.tot_val.where(land_weights_regrid.land_weights > 0) / weights\n", + " )\n", + "\n", + " # drop out if all null data --> no asset value on relevant land\n", + " if (\n", + " subset.tot_val_norm.where((subset.mask > 0) & subset.tot_val_norm.notnull())\n", + " .notnull()\n", + " .sum()\n", + " == 0\n", + " ):\n", + " return None\n", + "\n", + " return subset\n", + "\n", + "\n", + "def regrid_geg(\n", + " poly, geg15, geg_res=sset.GEG_GRID_WIDTH, litpop_res=sset.LITPOP_GRID_WIDTH\n", + "):\n", + "\n", + " geg_sub = prep_geg_for_regrid(poly, geg15, geg_res, litpop_res)\n", + "\n", + " if geg_sub is None:\n", + " return None\n", + "\n", + " out_grid = create_grid(geg_sub, resolution=litpop_res)\n", + "\n", + " regridder = xe.Regridder(geg_sub, out_grid, \"nearest_s2d\")\n", + "\n", + " geg_regridded = regridder(geg_sub)\n", + "\n", + " mask_dims, mask = poly_mask(poly, geg_regridded[[\"lat\", \"lon\"]])\n", + " geg_regridded[\"tot_val\"] = (geg_regridded.tot_val_norm * (litpop_res**2)).where(\n", + " mask == 1\n", + " )\n", + "\n", + " return geg_regridded" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Regrid GEG for Missing Countries in LitPop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out_dict = {}\n", + "for territory in sset.ISOS_IN_GEG_NOT_LITPOP:\n", + " print(territory)\n", + " territory_shape = (\n", + " missing_countries[missing_countries[\"iso3\"] == territory].iloc[0].geometry\n", + " )\n", + " out_dict[territory] = regrid_geg(territory_shape, geg15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Check Regridding Looks Good" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_exposure(ax, title, data, poly, vmin=None, vmax=None):\n", + " ax.set_extent(\n", + " [poly.bounds[0] - 1, poly.bounds[2] + 1, poly.bounds[1] - 1, poly.bounds[3] + 1]\n", + " )\n", + " ax.coastlines(\"10m\", linewidth=0.5, edgecolor=\"tab:orange\")\n", + "\n", + " adm0 = cfeature.NaturalEarthFeature(\n", + " category=\"cultural\",\n", + " name=\"admin_0_boundary_lines_land\",\n", + " scale=\"10m\",\n", + " facecolor=\"none\",\n", + " )\n", + "\n", + " ax.add_feature(adm0, edgecolor=\"tab:orange\", linewidth=0.1)\n", + "\n", + " data.where(data > 0.0000001).plot(\n", + " cmap=\"YlGnBu\",\n", + " norm=matplotlib.colors.LogNorm(vmin=vmin, vmax=vmax),\n", + " ax=ax,\n", + " cbar_kwargs={\"shrink\": 0.5, \"label\": \"\"},\n", + " )\n", + "\n", + " ax.add_geometries(\n", + " [poly], ccrs.PlateCarree(), facecolor=\"none\", edgecolor=\"r\", linewidth=0.3\n", + " )\n", + " ax.set_title(title)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# How does the regridding look?\n", + "%matplotlib inline\n", + "\n", + "plot_dict = out_dict\n", + "\n", + "pc_transform = ccrs.PlateCarree()\n", + "fig, axs = plt.subplots(\n", + " figsize=((3 * 3), (3 * 4)),\n", + " dpi=500,\n", + " ncols=3,\n", + " nrows=3,\n", + " subplot_kw={\"projection\": pc_transform},\n", + ")\n", + "\n", + "axs = axs.flatten()\n", + "for ax, tup in zip(axs, plot_dict.items()):\n", + " iso = tup[0]\n", + " out = tup[1]\n", + " row = missing_countries[missing_countries.iso3 == iso].iloc[0]\n", + " poly = row.geometry\n", + " plot_exposure(ax, iso, out[\"tot_val\"], poly)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Add Regridded Data into LitPop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# swap from value to integer indexing\n", + "litpop[\"lat\"] = litpop.lat.map_partitions(\n", + " grid_val_to_ix, cell_size=sset.LITPOP_GRID_WIDTH\n", + ")\n", + "litpop[\"lon\"] = litpop.lon.map_partitions(\n", + " grid_val_to_ix, cell_size=sset.LITPOP_GRID_WIDTH\n", + ")\n", + "litpop = litpop.persist()\n", + "\n", + "litpop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# add geg data into litpop dask dataframe\n", + "for iso, _add in out_dict.items():\n", + " print(iso)\n", + " add = _add.copy()\n", + " add.coords[\"lat\"] = grid_val_to_ix(add.lat.values, sset.LITPOP_GRID_WIDTH)\n", + " add.coords[\"lon\"] = grid_val_to_ix(add.lon.values, sset.LITPOP_GRID_WIDTH)\n", + "\n", + " litpop_sub = litpop[\n", + " (litpop.lon >= add.lon.min().item())\n", + " & (litpop.lon <= add.lon.max().item())\n", + " & (litpop.lat >= add.lat.min().item())\n", + " & (litpop.lat <= add.lat.max().item())\n", + " ].compute()\n", + "\n", + " # Mask out all MAR values below the MAR-ESH border (this border is defined by its latitude)\n", + " if iso == \"ESH\":\n", + " litpop_sub = litpop_sub.loc[\n", + " ~(litpop_sub[\"iso3\"] == \"MAR\")\n", + " | ~(litpop_sub[\"lat\"] <= get_iso_geometry(\"ESH\").bounds[3])\n", + " ].copy()\n", + "\n", + " litpop_sub = litpop_sub.set_index([\"lat\", \"lon\"]).to_xarray()\n", + "\n", + " add = add.rename({\"tot_val\": \"value\"})\n", + "\n", + " add[\"iso3\"] = ([\"lat\", \"lon\"], np.where((~np.isnan(add[\"value\"])), iso, None))\n", + "\n", + " litpop_sub[\"new_iso3\"] = add[\"iso3\"]\n", + " litpop_sub[\"iso3\"] = xr.where(\n", + " litpop_sub[\"new_iso3\"].isnull(), litpop_sub[\"iso3\"], litpop_sub[\"new_iso3\"]\n", + " )\n", + " litpop_sub[\"new_value\"] = add[\"value\"]\n", + " litpop_sub[\"value\"] = xr.where(\n", + " litpop_sub[\"new_value\"].isnull(), litpop_sub[\"value\"], litpop_sub[\"new_value\"]\n", + " )\n", + "\n", + " mmed = xr.merge([litpop_sub[[\"value\", \"iso3\"]], add[[\"value\", \"iso3\"]]])\n", + "\n", + " litpop_m_sub = litpop[\n", + " ~(\n", + " (litpop.lon >= add.lon.min().item())\n", + " & (litpop.lon <= add.lon.max().item())\n", + " & (litpop.lat >= add.lat.min().item())\n", + " & (litpop.lat <= add.lat.max().item())\n", + " )\n", + " ]\n", + "\n", + " to_append = mmed[[\"value\", \"iso3\"]].to_dataframe().dropna().reset_index()\n", + "\n", + " # TODO figure out what's going on here--sometimes index isn't automatically named by `to_dataframe()`\n", + " to_append = to_append.rename(columns={\"level_0\": \"lat\", \"level_1\": \"lon\"})\n", + " litpop = litpop_m_sub.append(to_append).persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# prep vars for saving\n", + "litpop[\"y_ix\"] = litpop[\"lat\"].astype(np.int16)\n", + "litpop[\"x_ix\"] = litpop[\"lon\"].astype(np.int16)\n", + "litpop[\"value\"] = litpop[\"value\"].astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "litpop = litpop.persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out_iso3 = litpop[\"iso3\"].unique().compute()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "litpop = litpop[[\"y_ix\", \"x_ix\", \"value\"]]\n", + "litpop = litpop[litpop[\"value\"] > 0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_litpop = litpop.compute()\n", + "\n", + "df_litpop = df_litpop.reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_litpop[\"value\"] = df_litpop[\"value\"].astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_litpop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_EXPOSURE_BLENDED.parent.mkdir(exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_litpop.to_parquet(\n", + " sset.PATH_EXPOSURE_BLENDED,\n", + " index=False,\n", + " compression=None,\n", + " engine=\"fastparquet\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cluster.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Check To Make Sure GEG Additions Look Good" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "litpop_int = pd.read_parquet(sset.PATH_EXPOSURE_BLENDED)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "litpop_int[\"lat\"] = grid_ix_to_val(litpop_int.y_ix, cell_size=sset.LITPOP_GRID_WIDTH)\n", + "litpop_int[\"lon\"] = grid_ix_to_val(litpop_int.x_ix, cell_size=sset.LITPOP_GRID_WIDTH)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# How does the regridding look?\n", + "%matplotlib inline\n", + "\n", + "plot_dict = out_dict\n", + "\n", + "pc_transform = ccrs.PlateCarree()\n", + "fig, axs = plt.subplots(\n", + " figsize=((3 * 3), (3 * 4)),\n", + " dpi=500,\n", + " ncols=3,\n", + " nrows=4,\n", + " subplot_kw={\"projection\": pc_transform},\n", + ")\n", + "\n", + "axs = axs.flatten()\n", + "for ax, tup in zip(axs, plot_dict.items()):\n", + " iso = tup[0]\n", + " add = tup[1]\n", + " row = missing_countries[missing_countries.iso3 == iso].iloc[0]\n", + " poly = row.geometry\n", + "\n", + " litpop_sub = (\n", + " litpop_int[\n", + " (litpop_int.lon >= add.lon.min().item() - 1)\n", + " & (litpop_int.lon <= add.lon.max().item() + 1)\n", + " & (litpop_int.lat >= add.lat.min().item() - 1)\n", + " & (litpop_int.lat <= add.lat.max().item() + 1)\n", + " ]\n", + " .set_index([\"lat\", \"lon\"])\n", + " .to_xarray()\n", + " )\n", + "\n", + " plot_exposure(ax, row.country_name, litpop_sub.value, poly)" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/4-vectorize-wetlands.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/4-vectorize-wetlands.ipynb new file mode 100644 index 0000000..671ca63 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/4-vectorize-wetlands.ipynb @@ -0,0 +1,440 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a5a2b329-7283-4e28-bafb-c60698866336", + "metadata": {}, + "source": [ + "# Combine wetlands from wetlands and mangroves datasets into single shapefile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f7fe3a3-32d9-4d8b-bef8-dd6a3d863622", + "metadata": {}, + "outputs": [], + "source": [ + "import subprocess\n", + "import warnings\n", + "\n", + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pygeos\n", + "import xarray as xr\n", + "from rhg_compute_tools import kubernetes as rhgk\n", + "\n", + "from sliiders import settings as sset\n", + "\n", + "warnings.filterwarnings(\"ignore\", message=\".*initial implementation of Parquet.*\")\n", + "\n", + "\n", + "PATH_GLOBCOVER_NC = sset.PATH_GLOBCOVER_2009.parent / (\n", + " sset.PATH_GLOBCOVER_2009.stem + \".nc\"\n", + ")\n", + "PATH_GLOBCOVER_SHP = sset.PATH_GLOBCOVER_2009.parent / (\n", + " sset.PATH_GLOBCOVER_2009.stem + \".shp\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0c5f49ce-57b8-4023-9654-553d34a3efde", + "metadata": {}, + "source": [ + "## 1. Get wetland cover from `GLOBCOVER` as `.nc`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c96a5fa-05a1-4fc2-998f-2b3ee3b4133d", + "metadata": {}, + "outputs": [], + "source": [ + "client, cluster = rhgk.get_micro_cluster()\n", + "\n", + "cluster.scale(8)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2375d146-3eda-4ffb-86a0-a5f2dad7638f", + "metadata": {}, + "outputs": [], + "source": [ + "da = xr.open_rasterio(sset.PATH_GLOBCOVER_2009, chunks={\"x\": 32400, \"y\": 27900})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b86684e-1b9f-4c95-92c7-73c97e31deb0", + "metadata": {}, + "outputs": [], + "source": [ + "da = da.persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59e98b1b-aa41-4cce-9848-a16fc5a86540", + "metadata": {}, + "outputs": [], + "source": [ + "da = da.squeeze(\"band\").drop(\"band\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "627b033f-6152-4c81-902b-1d6f6837689c", + "metadata": {}, + "outputs": [], + "source": [ + "da = da.isin([160, 170, 180]).persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be81f6f8-6f32-4130-a7ba-a639dac9e8cc", + "metadata": {}, + "outputs": [], + "source": [ + "da = da.to_dataset(name=\"wetlands\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ea6a0f3f-32ad-4312-8344-9f8cb72d8800", + "metadata": {}, + "outputs": [], + "source": [ + "da = da.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d95a75ac-2ac1-424d-b3c0-96e655d10d73", + "metadata": {}, + "outputs": [], + "source": [ + "da.to_netcdf(PATH_GLOBCOVER_NC)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "483792a6-1025-4027-98f5-0bf2ae9dfc6a", + "metadata": {}, + "outputs": [], + "source": [ + "client.close()\n", + "cluster.close()" + ] + }, + { + "cell_type": "markdown", + "id": "72278bb5-64ec-4db8-aea3-66a642c1e77a", + "metadata": {}, + "source": [ + "## 2. Vectorize\n", + "### Run `gdal_polygonize.py` in shell" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e3396e0-2046-464a-af5a-7b352b36e539", + "metadata": {}, + "outputs": [], + "source": [ + "cmd = f\"gdal_polygonize.py {str(PATH_GLOBCOVER_NC)} {str(PATH_GLOBCOVER_SHP)}\"\n", + "\n", + "sp = subprocess.Popen(cmd, shell=True)\n", + "rc = sp.wait()\n", + "\n", + "print(sp)" + ] + }, + { + "cell_type": "markdown", + "id": "0cb8dc3b-542b-4625-bdf7-d36b6cc03e6e", + "metadata": {}, + "source": [ + "## 3. Clean up shapefile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df08716c-21ad-4753-8ba9-7a2852b1009e", + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gpd.read_file(PATH_GLOBCOVER_SHP)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e398a721-99c6-43a5-960c-21ee3465dc1b", + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gdf[gdf[\"DN\"] == 1].drop(columns=[\"DN\"])\n", + "gdf = gdf.explode().reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c287dc36-b34d-488c-a54c-72fc447fd3c3", + "metadata": {}, + "outputs": [], + "source": [ + "gdf.to_file(PATH_GLOBCOVER_SHP)" + ] + }, + { + "cell_type": "markdown", + "id": "27ffb99e-5f35-4cc3-884b-41bee68b5ac7", + "metadata": {}, + "source": [ + "## 4. Combine with mangroves" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "328f8af0-f3e7-4030-80b1-a905544fb7ec", + "metadata": {}, + "outputs": [], + "source": [ + "globcover_mask = gpd.read_file(PATH_GLOBCOVER_SHP)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29339179-1b73-41ec-ac91-2c7bc0162d58", + "metadata": {}, + "outputs": [], + "source": [ + "mangroves = gpd.read_file(sset.PATH_GLOBAL_MANGROVES)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "778e9038-725b-4a10-8612-eca89f4c7a09", + "metadata": {}, + "outputs": [], + "source": [ + "globcover_mask[\"geometry\"] = pygeos.to_shapely(\n", + " pygeos.make_valid(pygeos.from_shapely(globcover_mask[\"geometry\"]))\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb1862d9-55c8-4d54-a3d9-2920856698ea", + "metadata": {}, + "outputs": [], + "source": [ + "combined = gpd.sjoin(globcover_mask, mangroves, how=\"left\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "97d71975-6308-4c10-883c-a4df8128a2e8", + "metadata": {}, + "outputs": [], + "source": [ + "mangroves = mangroves.reset_index(drop=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad696a47-aa48-4057-ab74-4375f6753438", + "metadata": {}, + "outputs": [], + "source": [ + "mangroves[\"in_combined\"] = mangroves[\"index\"].isin(combined[\"index_right\"].unique())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8a8e7d5-e4a9-48fe-a60a-f2953f336d28", + "metadata": {}, + "outputs": [], + "source": [ + "globcover_only = combined[combined[\"index_right\"].isnull()].copy()\n", + "combined = combined[combined[\"index_right\"].notnull()].copy()\n", + "\n", + "combined = combined.reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf8e39a3-2ea5-4c43-85db-89dcd0429a65", + "metadata": {}, + "outputs": [], + "source": [ + "combined[\"index_right\"] = combined[\"index_right\"].astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de6cad78-4671-4ecd-a9e8-a631d04c5ae8", + "metadata": {}, + "outputs": [], + "source": [ + "combined[\"geometry_right\"] = gpd.GeoSeries(\n", + " np.take(mangroves[\"geometry\"].to_numpy(), combined[\"index_right\"].to_numpy())\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19010a01-c54d-42bc-8410-2e8d1202a682", + "metadata": {}, + "outputs": [], + "source": [ + "combined = combined.set_geometry(\"geometry_right\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6640f34-4beb-49e9-b5e0-3b25651ddf6a", + "metadata": {}, + "outputs": [], + "source": [ + "combined = combined.dissolve(\"FID\").reset_index(drop=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f37b290-5556-4e19-928c-2093ffd5e0fd", + "metadata": {}, + "outputs": [], + "source": [ + "combined[\"geometry\"] = combined[\"geometry\"].difference(combined[\"geometry_right\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3eb10b51-e7a0-4bb2-9e1a-ee242ed4d1a4", + "metadata": {}, + "outputs": [], + "source": [ + "combined = combined.set_geometry(\"geometry\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ea52f0d-8d05-4733-aff6-a6df428e3a92", + "metadata": {}, + "outputs": [], + "source": [ + "combined = pd.concat([combined, mangroves, globcover_only], ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61e24048-b516-4721-b04a-e07737e6c8bc", + "metadata": {}, + "outputs": [], + "source": [ + "combined = combined[[\"geometry\"]].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24f52be2-46d1-4850-b666-a0e14f2e76c8", + "metadata": {}, + "outputs": [], + "source": [ + "combined.iloc[:20].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0520bb8b-c229-46ce-abe2-30f5920656ec", + "metadata": {}, + "outputs": [], + "source": [ + "combined = combined.explode().reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f949b9e-a537-4126-b740-ebcc0213ca37", + "metadata": {}, + "outputs": [], + "source": [ + "combined = combined[combined.geometry.area > 0].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66bc8acb-32e5-4624-a053-95243a33680d", + "metadata": {}, + "outputs": [], + "source": [ + "combined.to_file(sset.PATH_WETLANDS_INT)" + ] + } + ], + "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.8.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/5-get_positive_elev_tiles.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/5-get_positive_elev_tiles.ipynb new file mode 100644 index 0000000..2f09ec1 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/5-get_positive_elev_tiles.ipynb @@ -0,0 +1,369 @@ +{ + "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 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/6-generate_datum_conversion_grid.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/6-generate_datum_conversion_grid.ipynb new file mode 100644 index 0000000..c3653c9 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/6-generate_datum_conversion_grid.ipynb @@ -0,0 +1,320 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3bfe2898-b80a-4d0c-911a-a90c9fdb1f9c", + "metadata": {}, + "source": [ + "## Generate Datum Conversion Grid\n", + "\n", + "This notebook cleans and aggregates the downloaded XGM2019e and EGM geoid data, which is split up into quarters of the full grid. It also interpolates (or converts) the mean dynamic topography (MDT) data into grid structure used in XGM2019e and EGM data. Finally, geoid heights and MDT information are combined into one dataset (in `xarray.Dataset` format) and the final dataset is exported as a `.zarr` storage.\n", + "\n", + "See `notebooks/create-SLIIDERS/download-sliiders-econ-input-data.ipynb` for more details related to downloading the raw data used in this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e04fc3fb-7cb0-40a2-97cc-9166263da7aa", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff84c62b-d1c6-41ca-91ef-ed5d6691f633", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from cartopy import crs as ccrs\n", + "from sliiders import settings as sset\n", + "from sliiders import gcs\n", + "from pyinterp.backends.xarray import Grid2D\n", + "from pyinterp.fill import gauss_seidel\n", + "from pathlib import Path\n", + "\n", + "from sliiders.io import read_gdf\n", + "from sliiders.spatial import interpolate_da_like" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "49656d02-f289-4682-8ea4-4d40a353d013", + "metadata": {}, + "outputs": [], + "source": [ + "def read_gdf_grids(in_dir):\n", + " \"\"\"Combining all `.gdf` files in the directory `in_dir` to form an\n", + " `xarray.DataArray` over a single grid structure; also, for longitude systems where\n", + " values run from 0 to 360 (instead of -180 to 180), cleans so that longitudes run\n", + " from -180 to 180.\n", + "\n", + " Parameters\n", + " ----------\n", + " in_dir : pathlib.Path-like or str\n", + " path that contains all the relevant `.gdf` files that, together, form one grid\n", + "\n", + " Returns\n", + " -------\n", + " xarray.DataArray\n", + " containing data on `z` (as specified by the helper function `read_gdf`) over\n", + " all the grid points\n", + "\n", + " \"\"\"\n", + " grid = [read_gdf(d) for d in in_dir.glob(\"*\")]\n", + "\n", + " # hack b/c as of xarray 0.18.0, combine_by_coords seems to be throwing weird error\n", + " lats = np.sort(np.unique([g.lat for g in grid]))\n", + " lons = np.sort(np.unique([g.lon for g in grid]))\n", + " out = xr.DataArray(coords={\"lat\": lats, \"lon\": lons}, dims=[\"lat\", \"lon\"], name=\"z\")\n", + " for g in grid:\n", + " out = out.fillna(g)\n", + "\n", + " assert np.allclose(out.sel(lon=0), out.sel(lon=360))\n", + " out = out.drop_sel(lon=360)\n", + " out[\"lon\"] = out.lon.where(out.lon <= 180, out.lon - 360)\n", + "\n", + " return out.sortby([\"lon\", \"lat\"])" + ] + }, + { + "cell_type": "markdown", + "id": "1816bc2f-01c7-4d21-8f45-1d1369d423f3", + "metadata": {}, + "source": [ + "## Load XGM2019e data and EGM96 data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a4178f9-b88d-4a86-bd92-469a23ca8eaf", + "metadata": {}, + "outputs": [], + "source": [ + "xgm_wgs = read_gdf_grids(sset.DIR_GEOG_DATUMS_XGM2019e_WGS84)\n", + "egm_wgs = read_gdf_grids(sset.DIR_GEOG_DATUMS_EGM96_WGS84)" + ] + }, + { + "cell_type": "markdown", + "id": "03d31c49-1bf0-4905-a6cc-bd387a96fd04", + "metadata": {}, + "source": [ + "## Load and interpolate mean dynamic topography (MDT) data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59514b9c-efd8-4099-a627-aae45b8d7553", + "metadata": {}, + "outputs": [], + "source": [ + "# loading raw MDT\n", + "mdt = xr.open_dataset(sset.PATH_GEOG_MDT_RAW).mdt.isel(time=0, drop=True).load()\n", + "\n", + "# cleaning the longitudes above 180 degrees; then sort, rename longitude and latitude\n", + "mdt[\"longitude\"] = mdt.longitude.where(mdt.longitude < 180, mdt.longitude - 360)\n", + "mdt = mdt.sortby([\"latitude\", \"longitude\"]).rename(longitude=\"lon\", latitude=\"lat\")\n", + "\n", + "# fill the nans by Gauss-Seidel method; make sure it is converged\n", + "converged, filled = gauss_seidel(Grid2D(mdt))\n", + "assert converged\n", + "mdt_filled = mdt.copy()\n", + "mdt_filled[:] = filled.T\n", + "\n", + "# interpolate\n", + "mdt_filled = interpolate_da_like(mdt_filled, xgm_wgs)\n", + "mdt = interpolate_da_like(mdt, xgm_wgs)" + ] + }, + { + "cell_type": "markdown", + "id": "f68b7ccd-af77-4c7f-b510-252a601263bb", + "metadata": {}, + "source": [ + "## Put all conversions together" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "480da8d3-fff3-4854-976e-7f844c51641d", + "metadata": {}, + "outputs": [], + "source": [ + "out = xr.Dataset(\n", + " {\n", + " \"mdt\": mdt_filled,\n", + " \"egm96_xgm2019e\": egm_wgs - xgm_wgs,\n", + " \"egm96_wgs84\": egm_wgs,\n", + " \"xgm2019e_wgs84\": xgm_wgs,\n", + " \"mdt_interpolated\": mdt.isnull(),\n", + " }\n", + ")\n", + "out = out.dropna(\"lat\", how=\"any\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32e5d306-7670-4eda-a96d-e4f02704c49c", + "metadata": {}, + "outputs": [], + "source": [ + "# variable attrs\n", + "out.mdt.attrs.update(\n", + " {\n", + " \"long_name\": \"MDT 1993-2019\",\n", + " \"description\": (\n", + " \"Mean dynamic ocean topography over the period 1993-2019, as calculated by \"\n", + " \"AVISO altimetry (see \"\n", + " \"https://www.aviso.altimetry.fr/en/data/products/auxiliary-products/mdt.html\"\n", + " \"). This data is extrapolated over land using a Gauss-Seidel algorithm, \"\n", + " \"implemented by pyinterp. It's then interpolated to a consistent grid. The \"\n", + " \"MDT value should be thought of as relative to a theoretical geoid, rather \"\n", + " \"than any one particular geoid model (using a particular geoid model other \"\n", + " \"than the native GOCO05s results in non-physical oscillations in MDT).\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "out.egm96_xgm2019e.attrs.update(\n", + " {\n", + " \"long_name\": \"EGM96, rel. XGM2019e_2159\",\n", + " \"description\": (\n", + " \"Height of EGM96 geoid relative to XGM2019e_2159 geoid. Useful for \"\n", + " \"converting topography data between the two datums.\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "out.egm96_wgs84.attrs.update(\n", + " {\n", + " \"long_name\": \"EGM96, rel. WGS84\",\n", + " \"description\": (\n", + " \"Geoid heights of EGM96 geoid model, relative to WGS84 ellipsoid.\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "out.xgm2019e_wgs84.attrs.update(\n", + " {\n", + " \"long_name\": \"XGM2019e_2159, rel. WGS84\",\n", + " \"description\": (\n", + " \"Geoid heights of XGM2019e_2159 geoid model, relative to WGS84 ellipsoid.\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "out.mdt_interpolated.attrs.update(\n", + " {\n", + " \"long_name\": \"Interpolation mask for MDT values\",\n", + " \"description\": (\n", + " \"Indicates where bicubically interpolated MDT values required at least one \"\n", + " \"source value to be estimated through Gauss-Seidel relaxation (implemented \"\n", + " \"by pyinterp), rather than taken directly from the AVISO MDT dataset.\"\n", + " ),\n", + " }\n", + ")\n", + "\n", + "# dataset attrs\n", + "out.attrs.update(\n", + " {\n", + " \"author\": \"Ian Bolliger\",\n", + " \"contact\": \"ian.bolliger@blackrock.com\",\n", + " \"updated\": pd.Timestamp.now(tz=\"US/Pacific\").strftime(\"%c %z\"),\n", + " \"method\": \"See individual variable attrs for specific methods.\",\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9c3b0628-234d-4323-920c-80ebeeb9caac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# graphical check\n", + "this_vars = [v for v in out.variables if v not in [\"lat\", \"lon\"]]\n", + "fig, axs = plt.subplots(\n", + " len(this_vars),\n", + " 1,\n", + " subplot_kw={\"projection\": ccrs.PlateCarree()},\n", + " figsize=(10, 5 * len(this_vars)),\n", + ")\n", + "for vx, v in enumerate(this_vars):\n", + " if v not in [\"lat\", \"lon\"]:\n", + " out[v].isel(lat=slice(0, None, 10), lon=slice(0, None, 10)).plot(\n", + " x=\"lon\", y=\"lat\", ax=axs[vx]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1355dac-2adb-440c-bc23-a63ad9949a53", + "metadata": {}, + "outputs": [], + "source": [ + "# Exporting\n", + "os.makedirs(\n", + " os.path.dirname(gcs.gcsmap_to_fuse(sset.PATH_GEOG_DATUMS_GRID)), exist_ok=True\n", + ")\n", + "out.to_zarr(sset.PATH_GEOG_DATUMS_GRID, consolidated=True, mode=\"w\")" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/7-create_dem_mss.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/7-create_dem_mss.ipynb new file mode 100644 index 0000000..f1af9e3 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/7-create_dem_mss.ipynb @@ -0,0 +1,410 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7e932cf8-3f20-4e6b-b12a-633a162da8c6", + "metadata": {}, + "source": [ + "# Create MSS coastal DEM" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7c00785-c628-446b-bf33-c3fede918bef", + "metadata": {}, + "outputs": [], + "source": [ + "import subprocess\n", + "\n", + "import dask.distributed as dd\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pyinterp.backends.xarray as pbx\n", + "import rhg_compute_tools.gcs as rhgcs\n", + "import rhg_compute_tools.kubernetes as rhgk\n", + "import rhg_compute_tools.utils as rhgu\n", + "import xarray as xr\n", + "from shapely.geometry import box\n", + "\n", + "from sliiders import settings as sset" + ] + }, + { + "cell_type": "markdown", + "id": "ce069aa2-f411-42b6-8010-99478f80c520", + "metadata": {}, + "source": [ + "Define elevation-processing functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6b67c13-2806-41ec-8273-10a957806602", + "metadata": {}, + "outputs": [], + "source": [ + "@rhgu.block_globals\n", + "def get_grid_at_tile(da, grid):\n", + " \"\"\"\n", + " Get interpolated datum tile in the same shape as `da` using `pbx.Grid2D`\n", + " \"\"\"\n", + " buffer = 0.2\n", + "\n", + " # Ensure tiles along the 180 meridian have coordinates defined contiguously\n", + " if da.x[-1].item() > 179:\n", + " new_lons = grid.lon.values\n", + " new_lons[new_lons < -179] = new_lons[new_lons < -179] + 360\n", + " grid = grid.assign_coords({\"lon\": new_lons})\n", + " elif da.x[0].item() < -179:\n", + " new_lons = grid.lon.values\n", + " new_lons[new_lons > 179] = new_lons[new_lons > 179] - 360\n", + " grid = grid.assign_coords({\"lon\": new_lons})\n", + "\n", + " grid = grid.isel(\n", + " lon=(grid.lon >= da.x[0] - buffer) & (grid.lon <= da.x[-1] + buffer),\n", + " lat=(grid.lat >= da.y[-1] - buffer) & (grid.lat <= da.y[0] + buffer),\n", + " ).load()\n", + "\n", + " grid = grid.sortby(\"lon\")\n", + "\n", + " grid.lon.attrs[\"units\"] = \"degrees_east\"\n", + " grid.lat.attrs[\"units\"] = \"degrees_north\"\n", + "\n", + " interpolator = pbx.Grid2D(grid, geodetic=True)\n", + "\n", + " mx, my = np.meshgrid(da.x.values, da.y.values, indexing=\"ij\")\n", + "\n", + " out = interpolator.bicubic(dict(lon=mx.flatten(), lat=my.flatten()))\n", + "\n", + " out = out.reshape(mx.shape)\n", + " out = xr.DataArray(out).rename({\"dim_0\": \"x\", \"dim_1\": \"y\"})\n", + " out[\"x\"] = da.x.values\n", + " out[\"y\"] = da.y.values\n", + "\n", + " return out\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_bbox(tile_name):\n", + " \"\"\"\n", + " Return bounding box from tile name in the string format \"VXXHYYY\" representing the southwestern corner of a 1-degree tile,\n", + " where \"V\" is \"N\" (north) or \"S\" (south), \"H\" is \"E\" (east) or \"W\" (west), \"XX\" is a two-digit zero-padded number indicating\n", + " the number of degrees north or south from 0,0, and \"YYY\" is a three-digit zero-padded number indicating the number of degrees\n", + " east or west from 0,0.\n", + " \"\"\"\n", + " lat_term, lon_term = tile_name[:3], tile_name[3:]\n", + "\n", + " lat_direction, lat_value = lat_term[0], int(lat_term[1:])\n", + " lon_direction, lon_value = lon_term[0], int(lon_term[1:])\n", + "\n", + " lat_sign = 1 if lat_direction == \"N\" else -1\n", + " lon_sign = 1 if lon_direction == \"E\" else -1\n", + "\n", + " llat = lat_sign * lat_value\n", + " llon = lon_sign * lon_value\n", + "\n", + " ulat = llat + 1\n", + " ulon = llon + 1\n", + "\n", + " return box(llon, llat, ulon, ulat)\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_tile_path(tile):\n", + " \"\"\"Get raw CoastalDEM tile path\"\"\"\n", + " return sset.DIR_COASTALDEM / f\"{tile}.tif\"\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_elev_tile(\n", + " tile_name, bbox, use_coastal_dem=True, egm96_xgm2019e=None, mdt=None, cap=None\n", + "):\n", + " \"\"\"\n", + " Get 1-arcsec elevation tile relative to MSS.\n", + " Use CoastalDEM where available, replacing null areas with SRTM15+.\n", + " Get elevations relative to MSS datum using EGM96 -> XGM2019e and Mean Dynamic Topography (MDT) datum transformations\n", + " (both provided by Aviso).\n", + " \"\"\"\n", + " llon, llat, ulon, ulat = bbox.bounds\n", + " if use_coastal_dem:\n", + " # load tile\n", + " tile_path = get_tile_path(tile_name)\n", + " elev_tile = xr.open_rasterio(tile_path).sel(band=1).drop(\"band\")\n", + " elev_tile.load()\n", + "\n", + " # handle tiles with inaccurately bottom-left .1-degree metadata\n", + " if elev_tile[\"y\"].values.max() - elev_tile[\"y\"].values.min() < 0.9:\n", + " elev_tile[\"y\"] = (\n", + " elev_tile[\"y\"].values.min()\n", + " + (elev_tile[\"y\"].values - elev_tile[\"y\"].values.min()) * 10\n", + " )\n", + " elev_tile[\"x\"] = (\n", + " elev_tile[\"x\"].values.min()\n", + " + (elev_tile[\"x\"].values - elev_tile[\"x\"].values.min()) * 10\n", + " )\n", + "\n", + " # open our \"main DEM\" (to fill in missing pixels in CoastalDEM)\n", + " with xr.open_dataarray(sset.PATH_SRTM15_PLUS) as srtm:\n", + "\n", + " srtm_buffer = 0.01\n", + "\n", + " # Ensure tiles along the 180 meridian have coordinates defined contiguously\n", + " if llon == 179:\n", + " new_lons = srtm.lon.values\n", + " new_lons[new_lons < -179] = new_lons[new_lons < -179] + 360\n", + " srtm = srtm.assign_coords({\"lon\": new_lons})\n", + " elif ulon == -179:\n", + " new_lons = srtm.lon.values\n", + " new_lons[new_lons > 179] = new_lons[new_lons > 179] - 360\n", + " srtm = srtm.assign_coords({\"lon\": new_lons})\n", + "\n", + " # fill NaNs with SRTM\n", + " this_srtm = srtm.isel(\n", + " lon=(srtm.lon >= llon - srtm_buffer) & (srtm.lon <= ulon + srtm_buffer),\n", + " lat=(srtm.lat >= llat - srtm_buffer) & (srtm.lat <= ulat + srtm_buffer),\n", + " )\n", + "\n", + " this_srtm = this_srtm.sortby(\"lon\")\n", + " this_srtm.load()\n", + "\n", + " if use_coastal_dem:\n", + " srtm_interp = this_srtm.rename({\"lon\": \"x\", \"lat\": \"y\"}).interp_like(\n", + " elev_tile, method=\"linear\", assume_sorted=True\n", + " )\n", + " # -32767 means SRTM input to coastalDEM was missing (we have previously filled this in\n", + " # our master DEM)\n", + " # -9999 means outside of a particular spatial domain for coastalDEM\n", + " elev_tile = elev_tile.where(~elev_tile.isin([-32767, -9999])).fillna(\n", + " srtm_interp\n", + " )\n", + " # 0 is where coastalDEM is \"underwater\"\n", + " elev_tile = elev_tile.where(elev_tile != 0, np.nan)\n", + " else:\n", + " grid_width = 3600\n", + " size = 1 / grid_width\n", + "\n", + " lons_small = np.arange(llon + (size / 2), ulon, size)\n", + " lats_small = np.flip(np.arange(llat + (size / 2), ulat, size))\n", + "\n", + " srtm_interp = this_srtm.rename({\"lon\": \"x\", \"lat\": \"y\"}).interp(\n", + " {\"x\": lons_small, \"y\": lats_small}, method=\"linear\", assume_sorted=True\n", + " )\n", + " elev_tile = srtm_interp\n", + "\n", + " # Datum transformations\n", + " if (egm96_xgm2019e is None) or (mdt is None):\n", + " with xr.open_zarr(sset.PATH_GEOG_DATUMS_GRID, consolidated=True) as datum_grid:\n", + " mdt = datum_grid.mdt\n", + " egm96_xgm2019e = datum_grid.egm96_xgm2019e\n", + "\n", + " egm96_xgm2019e_interp = get_grid_at_tile(elev_tile, egm96_xgm2019e)\n", + " mdt_interp = get_grid_at_tile(elev_tile, mdt)\n", + " elev_tile = elev_tile + egm96_xgm2019e_interp\n", + " elev_tile = elev_tile - mdt_interp\n", + "\n", + " # Bundle higher-than-coastal elevation values into one to simplify later data processing\n", + " if cap is not None:\n", + " elev_tile = xr.where(elev_tile > cap, cap, elev_tile)\n", + "\n", + " return elev_tile\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def process_tile(\n", + " tile_name,\n", + " egm96_xgm2019e=None,\n", + " mdt=None,\n", + "):\n", + " bbox = get_bbox(tile_name)\n", + "\n", + " # get coastalDEM tile, filled with SRTM, relative to MSS\n", + " tile_path = get_tile_path(tile_name)\n", + " elev_tile = get_elev_tile(\n", + " tile_name,\n", + " bbox,\n", + " use_coastal_dem=tile_path.exists(),\n", + " egm96_xgm2019e=egm96_xgm2019e,\n", + " mdt=mdt,\n", + " )\n", + "\n", + " elev_tile = elev_tile.astype(np.float32)\n", + "\n", + " path_out_tmp = sset.DIR_MSS / f\"{tile_name}_tmp.tif\"\n", + " path_out = sset.DIR_MSS / f\"{tile_name}.tif\"\n", + " elev_tile.rio.to_raster(path_out_tmp)\n", + "\n", + " cmd_cp = f\"gdal_translate {str(path_out_tmp)} {str(path_out)} -co COMPRESS=DEFLATE -co PREDICTOR=3\"\n", + " cmd_rm = f\"rm {str(path_out_tmp)}\"\n", + "\n", + " subprocess.run(cmd_cp.split(\" \"), capture_output=True)\n", + " subprocess.run(cmd_rm.split(\" \"), capture_output=True)" + ] + }, + { + "cell_type": "markdown", + "id": "a0506823-b42c-430c-beb4-9b5b6df7a7ef", + "metadata": {}, + "source": [ + "Get list of tiles to process" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bd1bd70-e2ad-4c2e-a62d-e18c855f6c76", + "metadata": {}, + "outputs": [], + "source": [ + "tile_meta = pd.read_parquet(sset.PATH_EXPOSURE_TILE_LIST)\n", + "coastal_tiles = tile_meta.loc[\n", + " tile_meta[\"PROCESSING_SET\"].isin([\"CIAM\", \"WITHELEV\"]), \"tile_name\"\n", + "].to_numpy()\n", + "\n", + "sset.DIR_MSS.mkdir(exist_ok=True)\n", + "finished_tiles = [t[:-4] for t in rhgcs.ls(sset.DIR_MSS)]\n", + "\n", + "coastal_tiles = [t for t in coastal_tiles if t not in finished_tiles]\n", + "\n", + "len(coastal_tiles)" + ] + }, + { + "cell_type": "markdown", + "id": "f02629e4-78dc-4651-91ac-3d540bfd508b", + "metadata": {}, + "source": [ + "Start up cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8192c8a-b98f-4b10-956d-80a656c6fb22", + "metadata": {}, + "outputs": [], + "source": [ + "client, cluster = rhgk.get_micro_cluster()\n", + "cluster.scale(24)\n", + "\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81e1b9a2-717d-4436-b37e-f1d179198168", + "metadata": {}, + "outputs": [], + "source": [ + "import zipfile\n", + "from sliiders import __file__\n", + "from pathlib import Path\n", + "import os\n", + "\n", + "sliiders_dir = Path(__file__).parent\n", + "zipf = zipfile.ZipFile(\"sliiders.zip\", \"w\", zipfile.ZIP_DEFLATED)\n", + "for root, dirs, files in os.walk(sliiders_dir):\n", + " for file in files:\n", + " zipf.write(\n", + " os.path.join(root, file),\n", + " os.path.relpath(os.path.join(root, file), os.path.join(sliiders_dir, \"..\")),\n", + " )\n", + "zipf.close()\n", + "client.upload_file(\"sliiders.zip\")" + ] + }, + { + "cell_type": "markdown", + "id": "afa91dcb-75ef-4f96-814c-5b4e5a97631b", + "metadata": {}, + "source": [ + "Load datum grids onto workers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2890474c-4ce3-4f87-8053-b7a2bacd2880", + "metadata": {}, + "outputs": [], + "source": [ + "with xr.open_zarr(sset.PATH_GEOG_DATUMS_GRID, consolidated=True) as datum_grid:\n", + " egm96_xgm2019e = datum_grid.egm96_xgm2019e.load()\n", + " mdt = datum_grid.mdt.load()\n", + "\n", + "egm96_xgm2019e_fut = client.scatter(egm96_xgm2019e, broadcast=True)\n", + "mdt_fut = client.scatter(mdt, broadcast=True)" + ] + }, + { + "cell_type": "markdown", + "id": "93fa0f69-a699-4713-9e87-779e6ca8cf64", + "metadata": {}, + "source": [ + "Run tiles on workers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9308220-6dcd-471c-9bdb-434852d35d8a", + "metadata": {}, + "outputs": [], + "source": [ + "fut = client.map(\n", + " process_tile, coastal_tiles, egm96_xgm2019e=egm96_xgm2019e_fut, mdt=mdt_fut\n", + ")\n", + "dd.progress(fut)" + ] + }, + { + "cell_type": "markdown", + "id": "1d71a720-c12d-4bbf-b0ed-456d6e927b24", + "metadata": {}, + "source": [ + "Close cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c433787-6e1c-45b7-9e49-9f0517d3ec3c", + "metadata": {}, + "outputs": [], + "source": [ + "cluster.close()\n", + "client.close()" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/8-generate_protected_areas.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/8-generate_protected_areas.ipynb new file mode 100644 index 0000000..ddbb462 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/8-generate_protected_areas.ipynb @@ -0,0 +1,779 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5a16ad8e-333e-46b3-9e7f-b6698457add7", + "metadata": {}, + "source": [ + "# Generate protected areas from various levee and hydrological data sources" + ] + }, + { + "cell_type": "markdown", + "id": "55a6f3c0-78d6-404e-9c20-d482e54b9afc", + "metadata": {}, + "source": [ + "### Gather basins from HydroBASINS to find endorheic basins to include in \"protected areas\" dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1642f3da-283c-4bd1-a6c0-454e44e64e8a", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "import contextily as ctx\n", + "import geopandas as gpd\n", + "import pandas as pd\n", + "from shapely.geometry import Polygon, box\n", + "from tqdm.notebook import tqdm\n", + "\n", + "from sliiders import settings as sset\n", + "from sliiders import spatial\n", + "\n", + "spatial.filter_spatial_warnings()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "795c2764-e952-4ff0-89a2-7dfc641efcf0", + "metadata": {}, + "outputs": [], + "source": [ + "all_basin_shapefiles = set((sset.DIR_HYDROBASINS_RAW.glob(\"hybas_*_lev00_v1c.shp\")))\n", + "eu_basin_shapefile = sset.DIR_HYDROBASINS_RAW / \"hybas_eu_lev00_v1c.shp\"\n", + "\n", + "all_basin_shapefiles.remove(eu_basin_shapefile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21010e1f-884c-4f0d-81fb-dac94730f22c", + "metadata": {}, + "outputs": [], + "source": [ + "all_other_basins = pd.concat(\n", + " [gpd.read_file(basin_shapefile) for basin_shapefile in tqdm(all_basin_shapefiles)],\n", + " ignore_index=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8aef1e20-c8fe-4b8a-8bf6-23405757d948", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_and_caspian = gpd.read_file(sset.PATH_NATURALEARTH_OCEAN)\n", + "\n", + "ocean_and_caspian = ocean_and_caspian.explode(index_parts=False)\n", + "\n", + "ocean_and_caspian[\"area\"] = ocean_and_caspian.area\n", + "\n", + "# Sort so that ocean is first, Caspian is second\n", + "ocean_and_caspian = ocean_and_caspian.sort_values(\"area\", ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5cd75f3-1a99-4da6-8fe4-ec9965c5a344", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_shape = ocean_and_caspian.geometry.values[0]\n", + "caspian_shape = ocean_and_caspian.geometry.values[1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45106d7b-4d62-4a9d-b122-fc772e86186e", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c14925b8-e41c-493a-86d5-ff9fa4b146f0", + "metadata": {}, + "outputs": [], + "source": [ + "caspian_shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b078059-ace1-41c7-937d-0cbe89548c3a", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_buffer = ocean_shape.buffer(sset.ENDORHEIC_BASIN_OCEAN_BUFFER).simplify(\n", + " tolerance=0.1\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b661588d-de5e-4229-907b-82a85fe1a3a6", + "metadata": {}, + "source": [ + "### Handle Caspian Sea as a special case since it is considered \"ocean\" by HydroBASINS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40c70a80-1abd-496a-9fe5-39baad6ded1a", + "metadata": {}, + "outputs": [], + "source": [ + "eu_basins = gpd.read_file(eu_basin_shapefile)\n", + "\n", + "eu_basins[\"touches_caspian\"] = eu_basins[\"geometry\"].intersects(\n", + " box(*caspian_shape.bounds).buffer(0.5)\n", + ")\n", + "\n", + "eu_basins[\"feeds_into_caspian\"] = eu_basins[\"touches_caspian\"].copy()\n", + "\n", + "prev_basin_count = 0\n", + "while True:\n", + "\n", + " feeds_into_caspian = set(eu_basins.loc[eu_basins[\"feeds_into_caspian\"], \"HYBAS_ID\"])\n", + "\n", + " eu_basins[\"feeds_into_caspian\"] = (\n", + " (eu_basins[\"feeds_into_caspian\"])\n", + " | (eu_basins[\"NEXT_DOWN\"].isin(feeds_into_caspian))\n", + " | (eu_basins[\"NEXT_SINK\"].isin(feeds_into_caspian))\n", + " | (eu_basins[\"MAIN_BAS\"].isin(feeds_into_caspian))\n", + " )\n", + "\n", + " this_basin_count = eu_basins[\"feeds_into_caspian\"].sum()\n", + " if this_basin_count == prev_basin_count:\n", + " break\n", + "\n", + " prev_basin_count = this_basin_count" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8f82508-a003-4ded-9932-6dc7522434ca", + "metadata": {}, + "outputs": [], + "source": [ + "eu_basins[eu_basins[\"feeds_into_caspian\"]].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f38e19b-db3f-40ff-9493-58ac7e002e52", + "metadata": {}, + "outputs": [], + "source": [ + "eu_basins.loc[eu_basins[\"feeds_into_caspian\"], \"ENDO\"] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee1b2c99-8653-48c5-be1f-ca117d6637d8", + "metadata": {}, + "outputs": [], + "source": [ + "all_basins = pd.concat([all_other_basins, eu_basins], ignore_index=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e1d4f9a7-0b0e-49c7-9f3a-4332d0fc869f", + "metadata": {}, + "source": [ + "### Apply narrow definition of \"endorheic\" by assuming all \"virtual\" connections e.g. groundwater are real connections" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af868b08-7636-4ed4-8d18-67db98b633a7", + "metadata": {}, + "outputs": [], + "source": [ + "all_basins[\"not_endorheic\"] = all_basins[\"ENDO\"] == 0\n", + "\n", + "prev_non_endorheic_ct = -1\n", + "while True:\n", + " not_endorheic = set(all_basins.loc[all_basins[\"not_endorheic\"], \"HYBAS_ID\"])\n", + " all_basins[\"not_endorheic\"] = (\n", + " (all_basins[\"not_endorheic\"])\n", + " | (all_basins[\"NEXT_DOWN\"].isin(not_endorheic))\n", + " | (all_basins[\"NEXT_SINK\"].isin(not_endorheic))\n", + " | (all_basins[\"MAIN_BAS\"].isin(not_endorheic))\n", + " )\n", + " non_endorheic_ct = len(not_endorheic)\n", + "\n", + " if non_endorheic_ct == prev_non_endorheic_ct:\n", + " break\n", + " prev_non_endorheic_ct = non_endorheic_ct" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4483cc1b-64d6-4230-ab00-046453a32d02", + "metadata": {}, + "outputs": [], + "source": [ + "all_endorheic_basins = all_basins.loc[~all_basins[\"not_endorheic\"]].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "074029e5-6fae-40ed-8c3e-58708d32a26c", + "metadata": {}, + "outputs": [], + "source": [ + "ax = all_endorheic_basins.plot(figsize=(20, 20))\n", + "ctx.add_basemap(ax, crs=\"EPSG:4327\")" + ] + }, + { + "cell_type": "markdown", + "id": "d10faf31-11af-4c22-aaf2-2ac36eb2a3c4", + "metadata": {}, + "source": [ + "### Divide ocean shape into 1-degree tiles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f626fd9-e3e8-4569-aaab-f43fc9b4a052", + "metadata": {}, + "outputs": [], + "source": [ + "llats = range(-90, 91)\n", + "llons = range(-180, 181)\n", + "boxes = []\n", + "llats_list = []\n", + "llons_list = []\n", + "for llat in llats:\n", + " for llon in llons:\n", + " llats_list.append(llat)\n", + " llons_list.append(llon)\n", + " boxes.append(\n", + " box(\n", + " llon,\n", + " llat,\n", + " llon + 1,\n", + " llat + 1,\n", + " )\n", + " )\n", + "\n", + "ocean_boxes_gdf = gpd.GeoDataFrame(\n", + " {\"llat\": llats_list, \"llon\": llons_list}, geometry=boxes, crs=\"EPSG:4326\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad4784dc-b067-4b8f-8aaa-669bd025e075", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_boxes_gdf[\"ocean_box\"] = ocean_boxes_gdf[\"geometry\"].intersection(ocean_buffer)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21b9a884-41c6-4ba9-9fea-246ee9d6ee0c", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_boxes_gdf = ocean_boxes_gdf.drop(columns=\"geometry\").rename(\n", + " columns={\"ocean_box\": \"geometry\"}\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e08d48a-687c-4784-b35e-61dee6c55d26", + "metadata": {}, + "outputs": [], + "source": [ + "ocean_boxes_gdf = ocean_boxes_gdf[~ocean_boxes_gdf[\"geometry\"].is_empty]" + ] + }, + { + "cell_type": "markdown", + "id": "03a079b9-de30-4322-97e1-62cf99d31897", + "metadata": {}, + "source": [ + "### Find all endorheic basins that intersect with the ocean buffer, label them \"not_endorheic\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c0f96c7-0f87-489d-8ea9-052a0289b474", + "metadata": {}, + "outputs": [], + "source": [ + "intersections = gpd.sjoin(\n", + " all_endorheic_basins, ocean_boxes_gdf, how=\"left\", op=\"intersects\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71f67a6f-5621-47e4-8477-77fbce5da491", + "metadata": {}, + "outputs": [], + "source": [ + "no_ocean = set(\n", + " intersections[intersections[\"index_right\"].isnull()][\"HYBAS_ID\"].unique()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "952dfb67-fe0c-4441-b28d-eaff7434fa43", + "metadata": {}, + "outputs": [], + "source": [ + "all_endorheic_basins[\"not_endorheic\"] = ~all_endorheic_basins[\"HYBAS_ID\"].isin(no_ocean)" + ] + }, + { + "cell_type": "markdown", + "id": "50049da5-4bc6-4d7c-a4ae-6db63cc716c0", + "metadata": {}, + "source": [ + "### Once basins are labelled \"not_endorheic\" close to the ocean, we want basins flowing into those to be \"not_endorheic\" as well" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08c81528-1c09-4546-b937-6c2eda774aa7", + "metadata": {}, + "outputs": [], + "source": [ + "prev_non_endorheic_ct = -1\n", + "while True:\n", + " not_endorheic = set(\n", + " all_endorheic_basins.loc[all_endorheic_basins[\"not_endorheic\"], \"HYBAS_ID\"]\n", + " )\n", + " all_endorheic_basins[\"not_endorheic\"] = (\n", + " (all_endorheic_basins[\"not_endorheic\"])\n", + " | (all_endorheic_basins[\"NEXT_DOWN\"].isin(not_endorheic))\n", + " | (all_endorheic_basins[\"NEXT_SINK\"].isin(not_endorheic))\n", + " | (all_endorheic_basins[\"MAIN_BAS\"].isin(not_endorheic))\n", + " )\n", + " non_endorheic_ct = len(not_endorheic)\n", + "\n", + " if non_endorheic_ct == prev_non_endorheic_ct:\n", + " break\n", + " prev_non_endorheic_ct = non_endorheic_ct" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "631bd9ca-c6f9-48f1-b765-91d928a57f43", + "metadata": {}, + "outputs": [], + "source": [ + "all_endorheic_basins = all_endorheic_basins[~all_endorheic_basins[\"not_endorheic\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9754aea2-d8b3-4402-a56c-05b3fd36ed13", + "metadata": {}, + "outputs": [], + "source": [ + "ax = all_endorheic_basins.plot(figsize=(20, 20))\n", + "ctx.add_basemap(ax, crs=\"EPSG:4326\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e87a877-95e8-483e-b208-99fd0fafa824", + "metadata": {}, + "outputs": [], + "source": [ + "endorheic_basins_dissolved = all_endorheic_basins.unary_union.geoms" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc6d23fb-9df0-470f-8f82-a0c8c24db588", + "metadata": {}, + "outputs": [], + "source": [ + "combined_basins = gpd.GeoSeries(list(endorheic_basins_dissolved))\n", + "combined_basins = gpd.GeoDataFrame(geometry=combined_basins)\n", + "\n", + "combined_basins[\"area\"] = combined_basins.geometry.area\n", + "combined_basins = combined_basins.sort_values(\"area\", ascending=False)\n", + "combined_basins = combined_basins[\n", + " combined_basins[\"area\"] > sset.MIN_BASIN_TILE_DEGREE_AREA\n", + "].copy()" + ] + }, + { + "cell_type": "markdown", + "id": "8eac7436-1049-4185-97d3-0255042bfaef", + "metadata": {}, + "source": [ + "### Label basins manually (check each basin manually)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72c98d17-62f3-4a4e-8fe8-304fa7015e16", + "metadata": {}, + "outputs": [], + "source": [ + "ax = combined_basins.plot(figsize=(20, 20))\n", + "ctx.add_basemap(ax, crs=\"EPSG:4326\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a028ba1d-a263-461e-a855-21edbade243a", + "metadata": {}, + "outputs": [], + "source": [ + "combined_basins[\"label\"] = [\n", + " \"eurasia_caspian\",\n", + " \"sahara_sahel\",\n", + " \"central_australia\",\n", + " \"arabian_peninsula_dead_sea\",\n", + " \"altiplano_and_argentina\",\n", + " \"southern_africa\",\n", + " \"great_lakes_and_horn_of_africa\",\n", + " \"great_basin\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "ea440528-8082-4381-807f-390c1d319fcb", + "metadata": {}, + "source": [ + "### Fill Eurasian-Caspian basin with the Caspian itself" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fb0f5d6-d00d-4dc8-92c1-4c58e1c8c159", + "metadata": {}, + "outputs": [], + "source": [ + "surrounding_caspian = combined_basins.loc[\n", + " combined_basins[\"label\"] == \"eurasia_caspian\", \"geometry\"\n", + "].values[0]\n", + "combined_basins.loc[\n", + " combined_basins[\"label\"] == \"eurasia_caspian\", \"geometry\"\n", + "] = Polygon(surrounding_caspian.exterior)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6265240d-4067-443e-bd51-814331437de4", + "metadata": {}, + "outputs": [], + "source": [ + "combined_basins = combined_basins.reset_index(drop=True).drop(columns=\"area\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be77caf7-9e4a-4498-a5a7-5ee51b788f30", + "metadata": {}, + "outputs": [], + "source": [ + "combined_basins.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f918a16-bcb2-44a6-b517-82b2e2f4f907", + "metadata": {}, + "outputs": [], + "source": [ + "sset.PATH_MANUAL_PROTECTED_AREAS.parent.mkdir(exist_ok=True, parents=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5654be15-111c-4450-9e18-4a81d5394974", + "metadata": {}, + "outputs": [], + "source": [ + "combined_basins.to_parquet(sset.PATH_MANUAL_PROTECTED_AREAS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8fc7461-efe7-4958-9171-246117d83479", + "metadata": {}, + "outputs": [], + "source": [ + "combined_basins = gpd.read_parquet(sset.PATH_MANUAL_PROTECTED_AREAS)" + ] + }, + { + "cell_type": "markdown", + "id": "27ec19f6-fb7a-4366-8b19-87aa34abbe5b", + "metadata": {}, + "source": [ + "## Combine protected areas for global processing\n", + "- US National Levee Database (NLDB) and manual areas\n", + "- Large global endorheic basins\n", + "- Manual boxes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74e5ef7e-a64d-4c3f-ae6e-2172d448a06e", + "metadata": {}, + "outputs": [], + "source": [ + "nldb_and_manual_areas = gpd.read_parquet(sset.PATH_US_MANUAL_PROTECTED_AREAS)" + ] + }, + { + "cell_type": "markdown", + "id": "fda0cdf8-c491-4efd-a97c-0503f0956517", + "metadata": {}, + "source": [ + "Netherlands (assume all of the European Netherlands is protected)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "044b423d-9634-4fee-8639-a82bc0691055", + "metadata": {}, + "outputs": [], + "source": [ + "vor_shapes = gpd.read_parquet(sset.PATH_GADM_ADM0_VORONOI)\n", + "protected_areas_nld = vor_shapes[vor_shapes[\"ISO\"] == \"NLD\"][[\"geometry\"]]" + ] + }, + { + "cell_type": "markdown", + "id": "4d6035bf-c212-4dfe-a86b-f4992882c8f3", + "metadata": {}, + "source": [ + "Manual boxes (additional to those defined in `sset.PATH_US_MANUAL_PROTECTED_AREAS`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3011a0b-d436-4f15-bec3-15dc84c013f7", + "metadata": {}, + "outputs": [], + "source": [ + "manual_box_bounds = [\n", + " {\"label\": \"orinoco\", \"minx\": -70.0, \"miny\": 5.0, \"maxx\": -66.0, \"maxy\": 8.0},\n", + " {\"label\": \"heilongjiang\", \"minx\": 130.0, \"miny\": 45.0, \"maxx\": 136.0, \"maxy\": 48.0},\n", + " {\n", + " \"label\": \"southern_africa\",\n", + " \"minx\": 28.0,\n", + " \"miny\": -25.0,\n", + " \"maxx\": 33.0,\n", + " \"maxy\": -20.0,\n", + " },\n", + " {\n", + " \"label\": \"great_basin\",\n", + " \"minx\": -119.0,\n", + " \"miny\": 35.0,\n", + " \"maxx\": -115.0,\n", + " \"maxy\": 40.0,\n", + " },\n", + " {\n", + " \"label\": \"inner_australia\",\n", + " \"minx\": 135.0,\n", + " \"miny\": -32.0,\n", + " \"maxx\": 143.0,\n", + " \"maxy\": -25.0,\n", + " },\n", + " {\"label\": \"yakutsk\", \"minx\": 125.0, \"miny\": 62.0, \"maxx\": 130.0, \"maxy\": 67.0},\n", + " {\"label\": \"lake_baikal\", \"minx\": 102.0, \"miny\": 49.0, \"maxx\": 113.0, \"maxy\": 57.0},\n", + " {\"label\": \"great_lakes\", \"minx\": -95.0, \"miny\": 41.0, \"maxx\": -75.0, \"maxy\": 50.0},\n", + "]\n", + "\n", + "box_countries = {\n", + " \"orinoco\": \"Colombia, Venezuela\",\n", + " \"heilongjiang\": \"China\",\n", + " \"southern_africa\": \"Botswana, South Africa, Zimbabwe\",\n", + " \"great_basin\": \"USA\",\n", + " \"inner_australia\": \"Australia\",\n", + " \"yakutsk\": \"Russia\",\n", + " \"lake_baikal\": \"Russia\",\n", + " \"great_lakes\": \"Canada, USA\",\n", + "}\n", + "\n", + "manual_boxes = gpd.GeoDataFrame(manual_box_bounds)\n", + "\n", + "manual_boxes[\"geometry\"] = manual_boxes.apply(\n", + " lambda row: box(row[\"minx\"], row[\"miny\"], row[\"maxx\"], row[\"maxy\"]), axis=1\n", + ")\n", + "\n", + "manual_boxes = manual_boxes.drop(columns=[\"minx\", \"miny\", \"maxx\", \"maxy\"])\n", + "\n", + "manual_boxes.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a72ea14-a3d3-450d-954e-0e71586fffa6", + "metadata": {}, + "outputs": [], + "source": [ + "nldb_and_manual_areas[\"country\"] = \"USA\"\n", + "\n", + "protected_areas_nld[\"levee_segment_id\"] = -1\n", + "protected_areas_nld[\"protection_group\"] = \"Netherlands\"\n", + "protected_areas_nld[\"protection_type\"] = \"Netherlands\"\n", + "protected_areas_nld[\"country\"] = \"NLD\"\n", + "\n", + "combined_basins[\"levee_segment_id\"] = -1\n", + "combined_basins[\n", + " \"protection_group\"\n", + "] = \"largest endorheic basin areas, with buffer from ocean\"\n", + "combined_basins[\"protection_type\"] = \"endorheic basin\"\n", + "combined_basins[\"country\"] = \"multiple\"\n", + "\n", + "manual_boxes[\"levee_segment_id\"] = -1\n", + "manual_boxes[\"protection_group\"] = \"manual boxes\"\n", + "manual_boxes[\"protection_type\"] = \"non-coastal\"\n", + "manual_boxes[\"country\"] = manual_boxes[\"label\"].apply(lambda x: box_countries[x])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e12c4e5-11f0-439b-ab5c-3ff56b6c19d3", + "metadata": {}, + "outputs": [], + "source": [ + "protected_areas = (\n", + " pd.concat(\n", + " [\n", + " nldb_and_manual_areas,\n", + " protected_areas_nld,\n", + " combined_basins,\n", + " manual_boxes,\n", + " ],\n", + " ignore_index=True,\n", + " )\n", + " .reset_index(drop=False)\n", + " .rename(columns={\"index\": \"protection_zone_id\"})\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fcacf25c-ffd4-430d-b762-e56cf2f2f3a2", + "metadata": {}, + "outputs": [], + "source": [ + "protected_areas.sample(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b796e0e-614f-4ff1-b29f-0c825b50d443", + "metadata": {}, + "outputs": [], + "source": [ + "# plot-checking the protected areas\n", + "protected_areas.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "f51062a6-3991-4d02-b7c6-4d0d03f94331", + "metadata": {}, + "source": [ + "# Save combined areas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6b299af-af5a-40d0-a650-4fed516e095b", + "metadata": {}, + "outputs": [], + "source": [ + "protected_areas.to_parquet(sset.PATH_GLOBAL_PROTECTED_AREAS)" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/9-generate_exposure_tiles.ipynb b/notebooks/create-SLIIDERS-ECON/exposure/9-generate_exposure_tiles.ipynb new file mode 100644 index 0000000..2b4a7cc --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/9-generate_exposure_tiles.ipynb @@ -0,0 +1,737 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Combine data layers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Get elevation relative to sea level\n", + "2. Match to nearest country, impact region, protection zone (e.g. levees)\n", + "3. Uniformly distribute exposure over all surface area > 0 elevation within a 30\" pixel\n", + "4. Aggregate both surface area and exposure up to adm1 X coastal segment X protection zone X wetland flag X .1-meter elevation bin" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "from pathlib import Path\n", + "import dask.distributed as dd\n", + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "import regionmask\n", + "import rhg_compute_tools.gcs as rhgcs\n", + "import rhg_compute_tools.kubernetes as rhgk\n", + "import rhg_compute_tools.utils as rhgu\n", + "import xarray as xr\n", + "from shapely.geometry import box\n", + "\n", + "from sliiders import settings as sset\n", + "from sliiders import spatial as spatial\n", + "\n", + "spatial.filter_spatial_warnings()\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def load_exposure(bbox, sset):\n", + " \"\"\"Get asset value and population within the bounds defined by `bbox`\"\"\"\n", + " llon, llat, ulon, ulat = bbox.bounds\n", + "\n", + " # Get corners of `bbox` by their indices\n", + " lx_ix, ux_ix = spatial.grid_val_to_ix(\n", + " np.array([llon, ulon]),\n", + " sset.LITPOP_GRID_WIDTH,\n", + " )\n", + "\n", + " ly_ix, uy_ix = spatial.grid_val_to_ix(\n", + " np.array([llat, ulat]),\n", + " sset.LITPOP_GRID_WIDTH,\n", + " )\n", + "\n", + " # Define filters for reading parquet (saves computation and memory)\n", + " parquet_filters = [\n", + " [\n", + " (\"x_ix\", \">=\", lx_ix),\n", + " (\"x_ix\", \"<\", ux_ix),\n", + " (\"y_ix\", \">=\", ly_ix),\n", + " (\"y_ix\", \"<\", uy_ix),\n", + " ]\n", + " ]\n", + "\n", + " exp_filters = [parquet_filters[0] + [(\"value\", \">\", 0)]]\n", + " pop_filters = [parquet_filters[0] + [(\"population\", \">\", 0)]]\n", + "\n", + " # asset value\n", + " exp = pd.read_parquet(\n", + " sset.PATH_EXPOSURE_BLENDED,\n", + " columns=[\"value\", \"x_ix\", \"y_ix\"],\n", + " filters=exp_filters,\n", + " )\n", + "\n", + " pop_landscan = pd.read_parquet(\n", + " sset.PATH_LANDSCAN_INT,\n", + " columns=[\"population\", \"x_ix\", \"y_ix\"],\n", + " filters=pop_filters,\n", + " ).rename(columns={\"population\": \"pop_landscan\"})\n", + "\n", + " exp = pd.merge(\n", + " exp,\n", + " pop_landscan,\n", + " how=\"outer\",\n", + " left_on=[\"x_ix\", \"y_ix\"],\n", + " right_on=[\"x_ix\", \"y_ix\"],\n", + " )\n", + "\n", + " exp[\"value\"] = exp[\"value\"].fillna(0)\n", + " exp[\"pop_landscan\"] = exp[\"pop_landscan\"].fillna(0)\n", + "\n", + " return exp\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_protected_area_matches(elev_tile, bbox, sset):\n", + " \"\"\"\n", + " Get IDs of protected areas in `bbox`, returning a flattened array\n", + " corresponding to the flattened indices of `elev_tile`\n", + " \"\"\"\n", + " protected_areas = gpd.read_parquet(sset.PATH_GLOBAL_PROTECTED_AREAS)\n", + "\n", + " return spatial.get_partial_covering_matches(\n", + " elev_tile, bbox, protected_areas, id_name=\"protection_zone_id\"\n", + " )\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_wetland_matches(elev_tile, bbox, sset):\n", + " \"\"\"\n", + " Get flag indicating existence of wetlands in `bbox`, returning a flattened array\n", + " corresponding to the flattened indices of `elev_tile`\n", + " \"\"\"\n", + " wetlands = gpd.read_file(sset.PATH_WETLANDS_INT, bbox=(bbox.bounds))\n", + "\n", + " return spatial.get_partial_covering_matches(elev_tile, bbox, wetlands)\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_seg_adm(elev_tile, bbox, sset):\n", + " seg_adm = gpd.read_file(\n", + " sset.PATH_CIAM_ADM1_VORONOI_INTERSECTIONS_SHP,\n", + " bbox=box(*bbox.buffer(0.1).bounds),\n", + " )\n", + "\n", + " return spatial.get_vor_matches(elev_tile, bbox, seg_adm, \"seg_adm\", \"seg_adm\")\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def match_elev_pixels_to_shapes(elev_tile, bbox, sset):\n", + "\n", + " out_df = spatial.get_empty_exp_grid(elev_tile, sset.LITPOP_GRID_WIDTH)\n", + "\n", + " out_df[\"seg_adm\"] = get_seg_adm(elev_tile, bbox, sset)\n", + " out_df[\"seg_adm\"] = out_df[\"seg_adm\"].astype(\"category\")\n", + "\n", + " out_df[\"protection_zone\"] = get_protected_area_matches(elev_tile, bbox, sset)\n", + " out_df[\"protection_zone\"] = out_df[\"protection_zone\"].astype(\"category\")\n", + "\n", + " out_df[\"wetland_flag\"] = get_wetland_matches(elev_tile, bbox, sset)\n", + " out_df[\"wetland_flag\"] = out_df[\"wetland_flag\"].astype(bool)\n", + "\n", + " return out_df\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_valid_points_df(\n", + " elev_tile,\n", + " bbox,\n", + " all_points,\n", + " sset,\n", + "):\n", + " elev_array = elev_tile.values.flatten()\n", + "\n", + " all_points[\"z_ix\"] = spatial.grid_val_to_ix(\n", + " elev_array, sset.EXPOSURE_BIN_WIDTH_V, map_nans=0\n", + " )\n", + "\n", + " all_points[\"valid\"] = (~np.isnan(elev_array)) & (\n", + " (all_points[\"z_ix\"] >= 0) | (all_points[\"protection_zone\"] != -1)\n", + " )\n", + "\n", + " all_points[\"area_km\"] = spatial.get_cell_size_km(elev_tile, bbox)\n", + "\n", + " out_types = {\n", + " \"x_ix\": np.int16,\n", + " \"y_ix\": np.int16,\n", + " \"z_ix\": np.int32,\n", + " \"seg_adm\": \"category\",\n", + " \"protection_zone\": \"category\",\n", + " \"wetland_flag\": bool,\n", + " \"area_km\": np.float32,\n", + " }\n", + "\n", + " # compress\n", + " all_points = all_points.astype(\n", + " {k: v for k, v in out_types.items() if k in all_points.columns}\n", + " )\n", + "\n", + " poselev_pts = (\n", + " all_points[all_points[\"valid\"]].drop(columns=[\"valid\"]).reset_index(drop=True)\n", + " )\n", + "\n", + " negelev_pts = (\n", + " all_points[(~all_points[\"valid\"]) & (all_points[\"wetland_flag\"])]\n", + " .drop(columns=[\"valid\"])\n", + " .reset_index(drop=True)\n", + " )\n", + "\n", + " return poselev_pts, negelev_pts\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_agg_fields():\n", + " \"\"\"Get fields to aggregate over\"\"\"\n", + " return [\n", + " \"z_ix\",\n", + " \"seg_adm\",\n", + " \"protection_zone\",\n", + " ]\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def write_empty_csv(out_path):\n", + " # write CSV placeholder to indicate this tile has been processed, but doesn't have exposure\n", + " pd.DataFrame().to_csv(out_path, index=False)\n", + " return out_path\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_tile_out_path(tile_name, sset):\n", + " \"\"\"Get output path from the coastalDEM input path\"\"\"\n", + " return sset.DIR_EXPOSURE_BINNED_TMP_TILES / f\"{tile_name}.csv\"\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_exp_noland_out_path(tile_name, sset):\n", + " \"\"\"Get output path for exposure that couldn't be matched to land within its 1-degree elevation tile\"\"\"\n", + " return sset.DIR_EXPOSURE_BINNED_TMP_TILES_NOLAND / f\"{tile_name}.csv\"\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def get_seg_area_out_path(tile_name, sset):\n", + " \"\"\"Get output path for segment areas\"\"\"\n", + " return sset.DIR_EXPOSURE_BINNED_TMP_TILES_SEGMENT_AREA / f\"{tile_name}.csv\"\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def merge_exposure_to_highres_grid(this_exp, out, sset):\n", + " agg_fields = get_agg_fields()\n", + "\n", + " ix_merge = pd.merge(\n", + " this_exp[[\"x_ix\", \"y_ix\"]],\n", + " out[[\"x_ix\", \"y_ix\", \"seg_adm\"]].drop_duplicates(),\n", + " left_on=[\"x_ix\", \"y_ix\"],\n", + " right_on=[\"x_ix\", \"y_ix\"],\n", + " how=\"left\",\n", + " )\n", + "\n", + " missing_exp_tiles = ix_merge[ix_merge[\"seg_adm\"].isnull()].drop(columns=[\"seg_adm\"])\n", + " valid_exp_tiles = ix_merge[ix_merge[\"seg_adm\"].notnull()].drop(columns=[\"seg_adm\"])\n", + "\n", + " if valid_exp_tiles.shape[0] == 0:\n", + " valid_exp_tiles = out[[\"x_ix\", \"y_ix\"]].drop_duplicates()\n", + "\n", + " missing_exp_tiles[\"lon\"] = spatial.grid_ix_to_val(\n", + " missing_exp_tiles[\"x_ix\"], sset.LITPOP_GRID_WIDTH\n", + " )\n", + " missing_exp_tiles[\"lat\"] = spatial.grid_ix_to_val(\n", + " missing_exp_tiles[\"y_ix\"], sset.LITPOP_GRID_WIDTH\n", + " )\n", + "\n", + " valid_exp_tiles[\"lon\"] = spatial.grid_ix_to_val(\n", + " valid_exp_tiles[\"x_ix\"], sset.LITPOP_GRID_WIDTH\n", + " )\n", + " valid_exp_tiles[\"lat\"] = spatial.grid_ix_to_val(\n", + " valid_exp_tiles[\"y_ix\"], sset.LITPOP_GRID_WIDTH\n", + " )\n", + "\n", + " exp_ix_mappings = (\n", + " spatial.get_closest_valid_exp_tiles(missing_exp_tiles, valid_exp_tiles)\n", + " if missing_exp_tiles.shape[0] > 0\n", + " else None\n", + " )\n", + "\n", + " if exp_ix_mappings is not None:\n", + " this_exp = pd.merge(\n", + " this_exp,\n", + " exp_ix_mappings,\n", + " left_on=[\"x_ix\", \"y_ix\"],\n", + " right_on=[\"x_ix\", \"y_ix\"],\n", + " how=\"left\",\n", + " )\n", + "\n", + " this_exp[\"x_ix\"] = this_exp[\"valid_x_ix\"].fillna(this_exp[\"x_ix\"]).astype(int)\n", + " this_exp[\"y_ix\"] = this_exp[\"valid_y_ix\"].fillna(this_exp[\"y_ix\"]).astype(int)\n", + "\n", + " this_exp = (\n", + " this_exp.groupby([\"x_ix\", \"y_ix\"])[[\"value\", \"pop_landscan\"]]\n", + " .sum()\n", + " .reset_index(drop=False)\n", + " )\n", + "\n", + " exp_tile_areas = (\n", + " out.groupby([\"x_ix\", \"y_ix\"])[[\"area_km\"]]\n", + " .sum()\n", + " .rename(columns={\"area_km\": \"tile_area_km\"})\n", + " )\n", + "\n", + " out = out.join(exp_tile_areas, on=[\"x_ix\", \"y_ix\"])\n", + "\n", + " out = pd.merge(\n", + " out,\n", + " this_exp,\n", + " how=\"left\",\n", + " left_on=[\"x_ix\", \"y_ix\"],\n", + " right_on=[\"x_ix\", \"y_ix\"],\n", + " ).reset_index(drop=True)\n", + "\n", + " out = out.drop(columns=[\"x_ix\", \"y_ix\"])\n", + "\n", + " out[\"value\"] = out[\"value\"] * out[\"area_km\"] / out[\"tile_area_km\"]\n", + " out[\"pop_landscan\"] = out[\"pop_landscan\"] * out[\"area_km\"] / out[\"tile_area_km\"]\n", + "\n", + " out = out.drop(columns=[\"tile_area_km\"])\n", + "\n", + " out[\"value\"] = out[\"value\"].fillna(0)\n", + " out[\"pop_landscan\"] = out[\"pop_landscan\"].fillna(0)\n", + "\n", + " assert out.notnull().all().all()\n", + "\n", + " out = out.drop(columns=[\"lon\", \"lat\"])\n", + "\n", + " out = out.groupby(agg_fields, observed=True).sum().reset_index()\n", + "\n", + " # make sure no exposure was dropped or added from the original exposure within tile (within some margin of float error)\n", + " # include very low sums for 0 / 0 division (areas where there is no exposure, but we calculate anyway for diva areas)\n", + " assert (\n", + " this_exp[\"value\"].sum() < 0.00001\n", + " or np.abs(this_exp[\"value\"].sum() / out[\"value\"].sum() - 1) < 0.00001\n", + " )\n", + "\n", + " return out\n", + "\n", + "\n", + "@rhgu.block_globals\n", + "def process_tile(\n", + " tile_name,\n", + " sset,\n", + " calc_elev=True,\n", + " calc_exp=True,\n", + "):\n", + " warnings.filterwarnings(\"ignore\", message=\"Geometry is in a geographic CRS\")\n", + " warnings.filterwarnings(\"ignore\", message=\"CRS mismatch between the CRS\")\n", + " warnings.filterwarnings(\n", + " \"ignore\", message=\"Sequential read of iterator was interrupted\"\n", + " )\n", + "\n", + " out_path = get_tile_out_path(tile_name, sset)\n", + " bbox = spatial.get_bbox(tile_name)\n", + "\n", + " this_exp = load_exposure(bbox, sset) if calc_exp else None\n", + "\n", + " if calc_elev:\n", + " elev_tile = (\n", + " xr.open_rasterio(sset.DIR_MSS / f\"{tile_name}.tif\")\n", + " .squeeze(\"band\")\n", + " .drop(\"band\")\n", + " )\n", + " # Bundle higher-than-coastal elevation values into one to simplify later data processing\n", + " elev_tile = xr.where(elev_tile > sset.ELEV_CAP, sset.ELEV_CAP, elev_tile)\n", + " else:\n", + " elev_tile = spatial.get_granular_grid(bbox)\n", + "\n", + " # match tile points with countries, impact regions, protection zones\n", + " out = match_elev_pixels_to_shapes(elev_tile, bbox, sset)\n", + "\n", + " # get points on land, assign impact regions and countries at exposure grid level\n", + " out, negelev_pts = get_valid_points_df(elev_tile, bbox, out, sset)\n", + "\n", + " # if calc_elev:\n", + " seg_areas = out.groupby(\n", + " [\"seg_adm\", \"protection_zone\", \"wetland_flag\", \"z_ix\"],\n", + " as_index=False,\n", + " observed=True,\n", + " )[\"area_km\"].sum()\n", + "\n", + " negelev_areas = negelev_pts.groupby(\n", + " [\"seg_adm\", \"protection_zone\", \"wetland_flag\"],\n", + " as_index=False,\n", + " observed=True,\n", + " )[\"area_km\"].sum()\n", + " negelev_areas[\"z_ix\"] = -1\n", + "\n", + " seg_areas = pd.concat([seg_areas, negelev_areas], ignore_index=True)\n", + "\n", + " seg_areas = seg_areas[\n", + " (seg_areas[\"z_ix\"] <= 200) & (seg_areas[\"protection_zone\"] == -1)\n", + " ]\n", + "\n", + " seg_out_path = get_seg_area_out_path(tile_name, sset)\n", + " seg_areas.to_csv(seg_out_path, index=False)\n", + " if not calc_exp:\n", + " return seg_out_path\n", + "\n", + " if out.shape[0] == 0:\n", + " if calc_exp:\n", + " this_exp.to_csv(get_exp_noland_out_path(tile_name, sset), index=False)\n", + " return write_empty_csv(out_path)\n", + "\n", + " out = (\n", + " out[~out[\"wetland_flag\"]].drop(columns=[\"wetland_flag\"]).reset_index(drop=True)\n", + " )\n", + "\n", + " out = merge_exposure_to_highres_grid(this_exp, out, sset)\n", + "\n", + " out.to_csv(out_path, index=False)\n", + "\n", + " return out_path" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Copy CIAM seg shapefiles if they haven't been updated for this version of the exposure grid" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_maj_min(vers_name):\n", + " major, minor = vers_name.split(\".\")\n", + " return int(major), int(minor)\n", + "\n", + "\n", + "exp_vers_maj, exp_vers_min = get_maj_min(sset.EXPOSURE_BINNED_VERS[1:])\n", + "\n", + "dir_shp = sset.DIR_CIAM_VORONOI.parent\n", + "\n", + "existing_vers = [get_maj_min(p.name[1:]) for p in list(dir_shp.glob(\"v*.*\"))]\n", + "\n", + "existing_vers.sort(key=lambda s: s[1])\n", + "existing_vers.sort(key=lambda f: f[0])\n", + "\n", + "latest_vers_maj, latest_vers_min = existing_vers[-1]\n", + "\n", + "if (exp_vers_maj, exp_vers_min) not in existing_vers:\n", + "\n", + " src_dir = dir_shp / (\"v\" + str(latest_vers_maj) + \".\" + str(latest_vers_min))\n", + " dst_dir = dir_shp / (\"v\" + str(exp_vers_maj) + \".\" + str(exp_vers_min))\n", + "\n", + " rhgcs.cp(src_dir, dst_dir, flags=[\"r\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Prepare output directories" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sset.DIR_EXPOSURE_BINNED.mkdir(exist_ok=True)\n", + "\n", + "sset.DIR_EXPOSURE_BINNED_TMP.mkdir(exist_ok=True)\n", + "\n", + "sset.DIR_EXPOSURE_BINNED_TMP_TILES.mkdir(exist_ok=True)\n", + "sset.DIR_EXPOSURE_BINNED_TMP_TILES_NOLAND.mkdir(exist_ok=True)\n", + "sset.DIR_EXPOSURE_BINNED_TMP_TILES_SEGMENT_AREA.mkdir(exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Get list of tiles to process" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tile_meta_path = sset.PATH_EXPOSURE_TILE_LIST\n", + "\n", + "tile_meta = pd.read_parquet(tile_meta_path)\n", + "\n", + "tile_groups = tile_meta.groupby(\"PROCESSING_SET\")[\"tile_name\"].unique().to_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tiles = np.concatenate(list(tile_groups.values()))\n", + "\n", + "finished_tiles = [t[:-4][:7] for t in rhgcs.ls(sset.DIR_EXPOSURE_BINNED_TMP_TILES)]\n", + "finished_segs = [\n", + " t[:-4][:7] for t in rhgcs.ls(sset.DIR_EXPOSURE_BINNED_TMP_TILES_SEGMENT_AREA)\n", + "]\n", + "\n", + "remaining_tiles = [\n", + " t for t in all_tiles if (t not in finished_tiles and t not in finished_segs)\n", + "]\n", + "\n", + "print(len(remaining_tiles))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client, cluster = rhgk.get_standard_cluster()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nworkers = 200\n", + "cluster.scale(nworkers)\n", + "cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import zipfile\n", + "from pathlib import Path\n", + "\n", + "from sliiders import __file__\n", + "\n", + "sliiders_dir = Path(__file__).parent\n", + "zipf = zipfile.ZipFile(\"sliiders.zip\", \"w\", zipfile.ZIP_DEFLATED)\n", + "for root, dirs, files in os.walk(sliiders_dir):\n", + " for file in files:\n", + " zipf.write(\n", + " os.path.join(root, file),\n", + " os.path.relpath(os.path.join(root, file), os.path.join(sliiders_dir, \"..\")),\n", + " )\n", + "zipf.close()\n", + "client.upload_file(\"sliiders.zip\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# Without elevation\n", + "\n", + "Note: when running the below three cells, one occasionally may run into the Dask cluster being stuck on making a progress. We find that this occurrence is not tile-specific. In such cases, we advise the user to follow these steps:\n", + "\n", + "\n", + "1. Close the current Dask cluster and client by running `client.restart(); cluster.scale(0); client.close(); cluster.close()`\n", + "2. Once the Dask cluster and client have successfully closed, restart the notebook kernel.\n", + "3. Run all of the codes up to this section, and the cell directly below. Make sure that the Dask cluster is successfully running.\n", + "4. Since we only need to remaining tiles that has not been processed, run (in via `client.map`) `process_tile` on these remaining ones. This can be done by running the below cells again, since the already-processed tiles would not be included in `remaining_tiles` anymore." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_tiles = np.array(\n", + " [t for t in tile_groups[\"WITHOUTELEV\"] if t in remaining_tiles]\n", + ")\n", + "\n", + "withoutelev_tiles.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withoutelev_futures = client.map(\n", + " process_tile, withoutelev_tiles, sset=sset, calc_elev=False\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(withoutelev_futures)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# With elevation\n", + "\n", + "Note: similar to the without elevation cases, there could be cases in which Dask becomes stuck on making a progress. In such cases, we advise the user to follow similar steps to those explained above (but without having to re-run the steps involving without elevation workflow (i.e., after restarting the notebook, run all except the three cells under **Without elevation**, and work on the remaining tiles)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### With Exposure" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_tiles = np.array([t for t in tile_groups[\"WITHELEV\"] if t in remaining_tiles])\n", + "\n", + "withelev_tiles.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "withelev_futures = client.map(\n", + " process_tile,\n", + " withelev_tiles,\n", + " sset=sset,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(withelev_futures)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### No exposure (CIAM)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_tiles = np.array([t for t in tile_groups[\"CIAM\"] if t in remaining_tiles])\n", + "ciam_tiles.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ciam_futures = client.map(\n", + " process_tile,\n", + " ciam_tiles,\n", + " sset=sset,\n", + " calc_exp=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.progress(ciam_futures)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Shutdown workers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client.close()\n", + "cluster.close()" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-ECON/exposure/README.md b/notebooks/create-SLIIDERS-ECON/exposure/README.md new file mode 100644 index 0000000..73561b5 --- /dev/null +++ b/notebooks/create-SLIIDERS-ECON/exposure/README.md @@ -0,0 +1,15 @@ +Run the notebooks in this directory in order: + +1. `create-coastline-segments`: Create segments from CoDEC points. +2. `create-segment-regions`: Divide the world up into Voronoi polygons for each segmentXregion. +3. `fill_missing_litpop_with_geg`: Fill missing regions in LitPop with data from GEG-15. +4. `vectorize-wetlands`: Transform wetlands rasters (GLOBCOVER and Global Mangrove Watch) into single shapefile. +5. `get_positive_elev_tiles`: Assign global 1-degree tiles to groups for tile processing notebook +6. `generate_datum_conversion_grid`: converts (interpolates) MDT data to match with geoid grid and combines geoid and MDT datasets +7. `create_dem_mss`: Create elevation grid relative to MSS +8. `generate_protected_areas`: Create areas that are "protected" from sea level rise. +9. `generate_exposure_tiles`: Assign population, asset value, elevation, segments, protected regions, and administrative regions to global 1-degree tiles. +10. `combine_exposure_tiles`: Combine 1-degree tiles into the following datasets: + * Exposure with elevation (coastal exposure) + * Exposure without elevation (all exposure) + * Areas by elevation diff --git a/notebooks/create-SLIIDERS-SLR/README.md b/notebooks/create-SLIIDERS-SLR/README.md new file mode 100644 index 0000000..bc08df4 --- /dev/null +++ b/notebooks/create-SLIIDERS-SLR/README.md @@ -0,0 +1,10 @@ +This directory contains notebooks to generate SLIIDERS-SLR; a dataset of gridded local sea-level Monte Carlo samples based on the LocalizeSL framework. + +The final output is a Zarr store containing 10,000 Monte Carlo draws for each of the RCP scenarios and years (decadal), at each site ID (defined by LocalizeSL), for each corefile. + +The steps to produce this output are as follows: +1. `download-ifile-to-gcs.ipynb`: define the corefiles (IFILES) that you'd like to use and download them on GCS +2. `convert-mat-version.ipynb`: Convert the downloaded corefiles (IFILES) to the Octave-readable MATLAB v5 format. +3. `generate-projected-lsl.ipynb`: Dask workers running Octave. For any corefile, call the LocalizeSL `LocalizeStoredProjections` function, followed by `WriteTableMC`, to get outputs as TSVs. +4. `retrieve-num-gcms.ipynb`: Calculate number of GCMs for each site-year-scenario, for later use in clipping some sites due to data quality issues. +5. `process-localizesl-output.ipynb`: combine all TSVs into a single Zarr store. Clip some sites based on data quality criteria. \ No newline at end of file diff --git a/notebooks/create-SLIIDERS-SLR/convert-mat-version.ipynb b/notebooks/create-SLIIDERS-SLR/convert-mat-version.ipynb new file mode 100644 index 0000000..294dd2d --- /dev/null +++ b/notebooks/create-SLIIDERS-SLR/convert-mat-version.ipynb @@ -0,0 +1,195 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convert MATLAB v7.3 corefiles to MATLAB v5\n", + "- Octave doesn't support v7.3 as of 2020-05-19\n", + "- We use the Mat I/O C library to convert v7.3 to v5 (Mat I/O doesn't support v7)\n", + "- Note that what is called \"v5\" in Mat I/O is the same as \"v6\" in Octave" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Wrote MAT file: \"/gcs/rhg-data/impactlab-rhg/coastal/sliiders/int/slr/ifiles/SLRProjections170113GRIDDEDcore_v5.mat\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing MAT variable: OceanDynMean... succeeded.\n", + "Writing MAT variable: OceanDynN... succeeded.\n", + "Writing MAT variable: OceanDynRegions... succeeded.\n", + "Writing MAT variable: OceanDynStd... succeeded.\n", + "Writing MAT variable: OceanDynTECorr... succeeded.\n", + "Writing MAT variable: OceanDynYears... succeeded.\n", + "Writing MAT variable: ThermExpMean... succeeded.\n", + "Writing MAT variable: ThermExpN... succeeded.\n", + "Writing MAT variable: ThermExpStd... succeeded.\n", + "Writing MAT variable: ThermExpYears... succeeded.\n", + "Writing MAT variable: colAIS... succeeded.\n", + "Writing MAT variable: colGIC... succeeded.\n", + "Writing MAT variable: colGIS... succeeded.\n", + "Writing MAT variable: colLS... succeeded.\n", + "Writing MAT variable: colTE... succeeded.\n", + "Writing MAT variable: fpsite... succeeded.\n", + "Writing MAT variable: mergeZOSZOSTOGA... succeeded.\n", + "Writing MAT variable: nearestTG... succeeded.\n", + "Writing MAT variable: quantlevs... succeeded.\n", + "Writing MAT variable: rateprojs... succeeded.\n", + "Writing MAT variable: rateprojssd... succeeded.\n", + "Writing MAT variable: samps... succeeded.\n", + "Writing MAT variable: scens... succeeded.\n", + "Writing MAT variable: seeds... succeeded.\n", + "Writing MAT variable: targregionnames... succeeded.\n", + "Writing MAT variable: targregions... succeeded.\n", + "Writing MAT variable: targsitecoords... succeeded.\n", + "Writing MAT variable: targyears... succeeded.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Wrote MAT file: \"/gcs/rhg-data/impactlab-rhg/coastal/sliiders/int/slr/ifiles/SLRProjections190726core_SEJ_full_v5.mat\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing MAT variable: corefileH... succeeded.\n", + "Writing MAT variable: corefileL... succeeded.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Wrote MAT file: \"/gcs/rhg-data/impactlab-rhg/coastal/sliiders/int/slr/ifiles/SLRProjections200204GRIDDEDcore_D20_v5.mat\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing MAT variable: OceanDynMean... succeeded.\n", + "Writing MAT variable: OceanDynN... succeeded.\n", + "Writing MAT variable: OceanDynRegions... succeeded.\n", + "Writing MAT variable: OceanDynStd... succeeded.\n", + "Writing MAT variable: OceanDynTECorr... succeeded.\n", + "Writing MAT variable: OceanDynYears... succeeded.\n", + "Writing MAT variable: ThermExpMean... succeeded.\n", + "Writing MAT variable: ThermExpN... succeeded.\n", + "Writing MAT variable: ThermExpStd... succeeded.\n", + "Writing MAT variable: ThermExpYears... succeeded.\n", + "Writing MAT variable: colAIS... succeeded.\n", + "Writing MAT variable: colGIC... succeeded.\n", + "Writing MAT variable: colGIS... succeeded.\n", + "Writing MAT variable: colLS... succeeded.\n", + "Writing MAT variable: colTE... succeeded.\n", + "Writing MAT variable: fpsite... succeeded.\n", + "Writing MAT variable: mergeZOSZOSTOGA... succeeded.\n", + "Writing MAT variable: nearestTG... succeeded.\n", + "Writing MAT variable: quantlevs... succeeded.\n", + "Writing MAT variable: rateprojs... succeeded.\n", + "Writing MAT variable: rateprojssd... succeeded.\n", + "Writing MAT variable: samps... succeeded.\n", + "Writing MAT variable: scens... succeeded.\n", + "Writing MAT variable: seeds... succeeded.\n", + "Writing MAT variable: targregionnames... succeeded.\n", + "Writing MAT variable: targregions... succeeded.\n", + "Writing MAT variable: targsitecoords... succeeded.\n", + "Writing MAT variable: targyears... succeeded.\n", + "Writing MAT variable: OceanDynMean... succeeded.\n", + "Writing MAT variable: OceanDynN... succeeded.\n", + "Writing MAT variable: OceanDynRegions... succeeded.\n", + "Writing MAT variable: OceanDynStd... succeeded.\n", + "Writing MAT variable: OceanDynTECorr... succeeded.\n", + "Writing MAT variable: OceanDynYears... succeeded.\n", + "Writing MAT variable: ThermExpMean... succeeded.\n", + "Writing MAT variable: ThermExpN... succeeded.\n", + "Writing MAT variable: ThermExpStd... succeeded.\n", + "Writing MAT variable: ThermExpYears... succeeded.\n", + "Writing MAT variable: colAIS... succeeded.\n", + "Writing MAT variable: colGIC... succeeded.\n", + "Writing MAT variable: colGIS... succeeded.\n", + "Writing MAT variable: colLS... succeeded.\n", + "Writing MAT variable: colTE... succeeded.\n", + "Writing MAT variable: fpsite... succeeded.\n", + "Writing MAT variable: mergeZOSZOSTOGA... succeeded.\n", + "Writing MAT variable: nearestTG... succeeded.\n", + "Writing MAT variable: quantlevs... succeeded.\n", + "Writing MAT variable: rateprojs... succeeded.\n", + "Writing MAT variable: rateprojssd... succeeded.\n", + "Writing MAT variable: samps... succeeded.\n", + "Writing MAT variable: scens... succeeded.\n", + "Writing MAT variable: seeds... succeeded.\n", + "Writing MAT variable: targregionnames... succeeded.\n", + "Writing MAT variable: targregions... succeeded.\n", + "Writing MAT variable: targsitecoords... succeeded.\n", + "Writing MAT variable: targyears... succeeded.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Wrote MAT file: \"/gcs/rhg-data/impactlab-rhg/coastal/sliiders/int/slr/ifiles/SLRProjections210628GRIDDEDcore_SROCC_v5.mat\"\n" + ] + } + ], + "source": [ + "import shlex\n", + "from subprocess import run\n", + "\n", + "from sliiders.settings import DIR_IFILES_INT, DIR_IFILES_RAW\n", + "\n", + "DIR_IFILES_INT.mkdir(parents=True, exist_ok=True)\n", + "\n", + "for mfile_in in DIR_IFILES_RAW.glob(\"*.mat\"):\n", + " mfile_out = DIR_IFILES_INT / (mfile_in.stem + \"_v5\" + mfile_in.suffix)\n", + "\n", + " cmd = f\"matio_73to5 {mfile_in} {mfile_out}\"\n", + " run(shlex.split(cmd))" + ] + } + ], + "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.8.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-SLR/download-ifile-to-gcs.ipynb b/notebooks/create-SLIIDERS-SLR/download-ifile-to-gcs.ipynb new file mode 100644 index 0000000..7c8198f --- /dev/null +++ b/notebooks/create-SLIIDERS-SLR/download-ifile-to-gcs.ipynb @@ -0,0 +1,82 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prepare LocalizeSL corefiles for Octave processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Choose corefiles from LocalizeSL/IFILES to use (see readme immediately in that directory for more details on the different corefiles)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import requests\n", + "\n", + "from sliiders.settings import DIR_IFILES_RAW, LOCALIZESL_COREFILES, LOCALIZESL_REV\n", + "\n", + "DIR_IFILES_RAW.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for corefile_name in LOCALIZESL_COREFILES:\n", + " url = (\n", + " f\"https://github.com/bobkopp/LocalizeSL/raw/{LOCALIZESL_REV}/IFILES/\"\n", + " f\"{corefile_name}.mat\"\n", + " )\n", + "\n", + " filename = Path(url).name\n", + " path_out = DIR_IFILES_RAW / filename\n", + "\n", + " pathstr = str(path_out)\n", + "\n", + " r = requests.get(url)\n", + " path_out.write_bytes(r.content)" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-SLR/generate-projected-lsl.ipynb b/notebooks/create-SLIIDERS-SLR/generate-projected-lsl.ipynb new file mode 100644 index 0000000..faab24a --- /dev/null +++ b/notebooks/create-SLIIDERS-SLR/generate-projected-lsl.ipynb @@ -0,0 +1,1426 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# Generate Monte Carlo outputs for each gridded site in a corefile" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import dask.distributed as dd\n", + "import numpy as np\n", + "import parameterize_jobs as pj\n", + "from dask_gateway import Gateway\n", + "from gcsfs import GCSFileSystem\n", + "from IPython.display import display\n", + "from scipy.io import loadmat\n", + "\n", + "import rhg_compute_tools.gcs as rhgcs\n", + "from sliiders.settings import DIR_IFILES_INT, DIR_SLR_INT, LOCALIZESL_COREFILES\n", + "from sliiders.utils import upload_pkg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "FS = GCSFileSystem(token=\"/opt/gcsfuse_tokens/rhg-data.json\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "TMP_DIR = DIR_SLR_INT / \"tmp\"\n", + "\n", + "BATCH_SIZE = 32\n", + "\n", + "DIR_MFILES_SRC = Path(\"../../LocalizeSL/MFILES\")\n", + "TMP_MFILES_DIR = TMP_DIR / \"MFILES\"\n", + "TMP_MFILES_DIR.mkdir(exist_ok=True, parents=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Copy MFILES to location accessible by workers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cp_output = FS.put(\n", + " str(DIR_MFILES_SRC), TMP_MFILES_DIR.relative_to(\"/gcs\"), recursive=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gateway = Gateway()\n", + "cluster = gateway.new_cluster(\n", + " idle_timeout=3600,\n", + " profile=\"micro\",\n", + ")\n", + "client = cluster.get_client()\n", + "cluster.scale(64)\n", + "\n", + "upload_pkg(client, \"../../sliiders\")\n", + "cluster" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Octave function used to run LocalizeSL" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "get_lslr_func = f\"\"\"\n", + "function this_ids = get_lslr(ix_start, ix_end, corefile_name, subcorefile_choice, dir_out)\n", + " ifilesdir='{DIR_IFILES_INT}';\n", + " mfilesdir='{TMP_MFILES_DIR}'\n", + "\n", + " addpath(ifilesdir);\n", + " addpath(mfilesdir);\n", + " \n", + " pkg load statistics\n", + "\n", + " f = [corefile_name '_v5.mat'];\n", + "\n", + " corefilewrapper=load(fullfile(ifilesdir, f));\n", + "\n", + " mkdir(dir_out);\n", + "\n", + " ccclab = \"SROCC\";\n", + " if strcmp(corefile_name, 'SLRProjections170113GRIDDEDcore')\n", + " ccclab = \"170113\";\n", + " end\n", + " if strcmp(corefile_name, 'SLRProjections190726core_SEJ_full')\n", + " disp(\"Make sure to run twice. Once for corefileL and once for corefileH\");\n", + " ccclab = \"SEJ\";\n", + " if strcmp(subcorefile_choice, \"H\")\n", + " corefile = corefilewrapper.corefileH;\n", + " else\n", + " corefile = corefilewrapper.corefileL;\n", + " end\n", + " else\n", + " corefile = corefilewrapper;\n", + " end\n", + " disp([\"Corefile: \" corefile_name]);\n", + " disp([\"Corefile label: \" ccclab]);\n", + " disp([\"Corefile subgroup: \" subcorefile_choice]);\n", + " \n", + " rateproj_corefile = load(fullfile(ifilesdir, 'SLRProjections190726core_SEJ_full_v5.mat')).corefileL;\n", + "\n", + " % Take corefile.targregionnames\n", + " % Get index of each name in rateproj_corefile.targregionnames\n", + " % Take those indices from rateprojs and rateprojssd\n", + " [_, idx_this_corefile, idx_rateproj_corefile] = intersect(corefile.targregionnames, rateproj_corefile.targregionnames);\n", + " corefile.rateprojs(idx_this_corefile) = rateproj_corefile.rateprojs(idx_rateproj_corefile);\n", + " corefile.rateprojssd(idx_this_corefile) = rateproj_corefile.rateprojssd(idx_rateproj_corefile);\n", + "\n", + " rand(\"seed\", 0);\n", + " corefile.seeds = [];\n", + " for rrr=1:size(corefile.samps, 2)\n", + " seeds=linspace(0,1,size(corefile.samps, 1) + 2);\n", + " seeds=seeds(2:end-1);\n", + " seeds=norminv(seeds(randperm(length(seeds))));\n", + "\n", + " corefile.seeds = [corefile.seeds; seeds];\n", + " end\n", + "\n", + " siteids = int64(corefile.targregions);\n", + "\n", + " % Subset `siteids` to the really high-numbered ones (the gridded ones, rather than those indexed by PSMSL stations)\n", + " gridids = siteids(siteids > 100000000);\n", + "\n", + " disp([\"Number of sites: \" mat2str(length(gridids))]);\n", + " \n", + " if (ix_start == 0 && ix_end == 0)\n", + " this_ids = [0];\n", + " else\n", + " this_ids = gridids(ix_start:ix_end);\n", + " end\n", + "\n", + " n_ids = size(this_ids)(1);\n", + " for i=1:n_ids\n", + " [sampslocrise,sampsloccomponents,siteids,sitenames,targyears,scens,cols] = LocalizeStoredProjections(this_ids(i),corefile); \n", + " if this_ids(i) == 0\n", + " sl_str = \"GSL\";\n", + " else\n", + " sl_str = \"LSL\";\n", + " WriteTableMC(sampsloccomponents,24,siteids,sitenames,targyears,scens,[dir_out sl_str 'proj_MC_' ccclab '_baseline_']);\n", + " end\n", + " WriteTableMC(sampsloccomponents,[],siteids,sitenames,targyears,scens,[dir_out sl_str 'proj_MC_' ccclab '_']);\n", + " end\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Python wrappers needed for running Octave function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def run_batch(start, end, corefile, sub_corefile, dir_out):\n", + " from oct2py import octave\n", + "\n", + " octave.eval(get_lslr_func)\n", + " return octave.get_lslr(start, end, corefile, sub_corefile, str(dir_out) + \"/\")\n", + "\n", + "\n", + "def get_num_sites(corefile, sub_corefile=None):\n", + " path_corefile = DIR_IFILES_INT / (corefile + \"_v5.mat\")\n", + "\n", + " cf = loadmat(path_corefile, squeeze_me=True)\n", + "\n", + " if sub_corefile is None:\n", + " targ_regions = cf[\"targregions\"]\n", + " else:\n", + " targ_regions = cf[\"corefile\" + sub_corefile][\"targregions\"].item()\n", + "\n", + " return (targ_regions > 100000000).sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Run jobs on workers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "futures = dict()\n", + "\n", + "n_corefiles = len(sum(LOCALIZESL_COREFILES.values(), []))\n", + "for corefile, sub_corefiles in LOCALIZESL_COREFILES.items():\n", + " futures[corefile] = dict()\n", + " for sub_corefile in sub_corefiles:\n", + "\n", + " num_sites = get_num_sites(corefile, sub_corefile)\n", + "\n", + " # get beginning and ending index for each batch\n", + " starts = np.arange(1, num_sites, BATCH_SIZE)\n", + " ends = np.arange(BATCH_SIZE, num_sites + BATCH_SIZE, BATCH_SIZE)\n", + " ends[-1] = num_sites\n", + "\n", + " # add gsl\n", + " starts = np.hstack(([0], starts))\n", + " ends = np.hstack(([0], ends))\n", + "\n", + " # get out dir\n", + " dir_out = TMP_DIR / corefile / \"mc_tsv\"\n", + " dir_out.mkdir(parents=True, exist_ok=True)\n", + "\n", + " # get jobs\n", + " jobs = pj.Constant(\n", + " corefile=corefile, sub_corefile=sub_corefile, dir_out=dir_out\n", + " ) * pj.ParallelComponentSet(start=starts, end=ends)\n", + "\n", + " # map jobs\n", + " futures[corefile][sub_corefile] = client.map(pj.expand_kwargs(run_batch), jobs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clean up temporary MFILES and close cluster" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dd.wait(futures)\n", + "cluster.close()\n", + "client.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "FS.rm(str(TMP_MFILES_DIR.relative_to(\"/gcs\")), recursive=True)" + ] + } + ], + "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.10" + }, + "nbdime-conflicts": { + "local_diff": [ + { + "key": "widgets", + "op": "add", + "value": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + } + ], + "remote_diff": [ + { + "key": "widgets", + "op": "add", + "value": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01751e9f631f4ad29269930e933bb9a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_9087d1288cc74b25b96bc36457cf9c86", + "IPY_MODEL_3e4f7718cfda4cd0a3f828c077674a29" + ], + "layout": "IPY_MODEL_a287cc2020e941dbb4ec8862559d8d03" + } + }, + "025b107359e8494985fcefba1c2e43ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "026c0c222181416ab109ca7372d2c9bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "IntTextModel", + "state": { + "description": "Minimum", + "layout": "IPY_MODEL_4e51cd8a9cc8443b9106b6d0eabc234c", + "step": 1, + "style": "IPY_MODEL_3f647d95b04142309b44ae885f866b92" + } + }, + "0755c45d2beb436a9e625c55adb7a929": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "09a5e0b9bf1648eab18faf2e9cf58146": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d87c4689c4c44600a3c6e321c19c16f3", + "style": "IPY_MODEL_0755c45d2beb436a9e625c55adb7a929", + "value": "
67 / 67
" + } + }, + "0a7542ae1e874ca489b5cbfced51b642": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "0cc92f85655f40d8a3e3ce8d85051489": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "10ef31469b124f85bde701a7a52315bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "1a6b7b3270494781b97a90279c2261b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fd53353613644e2f87ace812c76885a5", + "style": "IPY_MODEL_eb249e5749ec4388abe3b2825fa0f3a5", + "value": "
Finished: 1hr 11min 7.0s
" + } + }, + "1b9cdd9c6fab4c37ab2c7b23a1595312": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "2104895dcf34414cbcc739b509bdeca2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "22e8ec715f0043ee88310eb409224faa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "24d74565e58a4ff7b9f8cc257726d629": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "26e469238501404f96542480e40a64e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "2819b95095a4402da59fb723ff853010": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_33c5b71c428049ccbeb6c740b30b7ea2", + "style": "IPY_MODEL_3f62acfa3c064961910b134f92ed7ab6", + "value": "
run_batch
" + } + }, + "28f4cce95baf40bfa512dbb8936e142c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a20af9530e4e47fe81d1c3c30e8bd436", + "style": "IPY_MODEL_834f4cc42c1546538f18bbffcde38398", + "value": "
Finished: 46min 59.5s
" + } + }, + "29932152f2d640179a8ae7580e96df08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_93c4637d3469462b99192a248cbafd87", + "IPY_MODEL_a9ac73548240496eb11975dfcdb9c044", + "IPY_MODEL_897ffbbe561c4738b954fa0221797db7" + ], + "layout": "IPY_MODEL_67bc2a1fdda64e77b60cc2ae138d4f14" + } + }, + "33c5b71c428049ccbeb6c740b30b7ea2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "36e094751a9c4711b4b6c55f54c41fa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "37c9c23980704317835e235be6179486": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "38bc474a0d06487180f71a71ae69c5f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "3e4f7718cfda4cd0a3f828c077674a29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_567f1375d858498d921e55182b8fdb5c" + ], + "layout": "IPY_MODEL_e32474e03e8f4559802b6144cd6a9aa4" + } + }, + "3f62acfa3c064961910b134f92ed7ab6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3f647d95b04142309b44ae885f866b92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "43a78cbc080d4d94841c8f8af8b50eb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "44c9f1e0775e4318a830fd4565de82c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_4597fb498328415cb6321cdd865ea3a9", + "IPY_MODEL_6dca74c3da00424e837b4fd8fd660fd8", + "IPY_MODEL_2819b95095a4402da59fb723ff853010" + ], + "layout": "IPY_MODEL_a97a55314fee44b58172aecc6ab52ac4" + } + }, + "4597fb498328415cb6321cdd865ea3a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_2104895dcf34414cbcc739b509bdeca2", + "style": "IPY_MODEL_928181208ce2443f8278c26744d66926", + "value": "
67 / 67
" + } + }, + "4db704dc7d05472c8b2f00743ef0a6ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "4e51cd8a9cc8443b9106b6d0eabc234c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "150px" + } + }, + "4f2b0dd904ce464e8eabc3de04a6dca5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_5bdc0c82d0034781bf5d3c84129405db", + "IPY_MODEL_5861d125a6b84e2fb4df27ea013529a3" + ], + "layout": "IPY_MODEL_ef551c4113954c5aab97b743838180b4" + } + }, + "52822a8c109c4f47ad1e27b36dad4498": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "55278627ad9f4195a3401edc7f0ce7eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_a891144765dc45e484b20ea4aa7a0906", + "IPY_MODEL_89fb4b6b807e420484a057e02a089834", + "IPY_MODEL_f6930f6fc7ee4d80b0adf733e2eced6c", + "IPY_MODEL_f953bcfe9daf4ac8ba8e4127453b36fd" + ], + "layout": "IPY_MODEL_1b9cdd9c6fab4c37ab2c7b23a1595312" + } + }, + "567f1375d858498d921e55182b8fdb5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_68bc2ee7a74f4c2cbe40b167f4d34a22", + "IPY_MODEL_d9457500ca8945f788df02c372ef5fcd", + "IPY_MODEL_b932d9780cf9482ca4bc3eb88183c5c8" + ], + "layout": "IPY_MODEL_0a7542ae1e874ca489b5cbfced51b642" + } + }, + "56bc83bb6b5b43a587f918caa2ca64f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "5861d125a6b84e2fb4df27ea013529a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "description": "Scale", + "layout": "IPY_MODEL_4e51cd8a9cc8443b9106b6d0eabc234c", + "style": "IPY_MODEL_69fc7ae4f5b4470faa449b8840a88e07" + } + }, + "58a5f49ba22c4157ab3c8bedfda73b52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_95b0281a6dea40d9ba011de14bdbfc7e", + "style": "IPY_MODEL_36e094751a9c4711b4b6c55f54c41fa8", + "value": "
run_batch
" + } + }, + "5b2edaa051054124b317aa95de3b0a6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e62ab9c3134340ca832b788beeb30e12", + "style": "IPY_MODEL_9675c2267a35465ab2a9c2fe5da02f9a", + "value": "
run_batch
" + } + }, + "5bdc0c82d0034781bf5d3c84129405db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "IntTextModel", + "state": { + "description": "Workers", + "layout": "IPY_MODEL_4e51cd8a9cc8443b9106b6d0eabc234c", + "step": 1, + "style": "IPY_MODEL_fabcf155c317400e92f810e06f4b44d0" + } + }, + "5c40b198f23b49d8b531ca1ad7a79e10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "60170fc9b8f7436bb8d8ef63385553d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "6749914566c840f6bf5c62eee6c8e740": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "67bc2a1fdda64e77b60cc2ae138d4f14": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "67c59408d5184f3a860eb11ecb43510e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "68bc2ee7a74f4c2cbe40b167f4d34a22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_840292dcfa7f4a4d897dca4c2a18fa63", + "style": "IPY_MODEL_60170fc9b8f7436bb8d8ef63385553d5", + "value": "
67 / 67
" + } + }, + "69fc7ae4f5b4470faa449b8840a88e07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "6dca74c3da00424e837b4fd8fd660fd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_aaa9b3dcff9a4761bf416075ee9c5371", + "max": 1, + "style": "IPY_MODEL_75e5184b73204e698bc55dd201b4245f", + "value": 1 + } + }, + "720cccf78c934a4b84f6f45f1d8a0af5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "72569d836c9e40f0909f8828cd2cdd4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "737eb9c5b9bf4fc48d92e9bbffa1c77a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_29932152f2d640179a8ae7580e96df08" + ], + "layout": "IPY_MODEL_f29d6daccdab494ca9c05f43bd131207" + } + }, + "73c5d03be3fc4385af68f3c2ddc40e6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "74097c600949435b84433cfca93f9dab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "74bab6fe2d904d8fa2abe91c57f49c0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "75e5184b73204e698bc55dd201b4245f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "78a6359adf57408090e190c8280787a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "7913eda5863241f295001fd9a823f6a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_28f4cce95baf40bfa512dbb8936e142c", + "IPY_MODEL_737eb9c5b9bf4fc48d92e9bbffa1c77a" + ], + "layout": "IPY_MODEL_67c59408d5184f3a860eb11ecb43510e" + } + }, + "7a4dad3cf68b4e48b62e4fb446171ce3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "7b98d59f26354a6db4c6296ed34899c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_09a5e0b9bf1648eab18faf2e9cf58146", + "IPY_MODEL_8873037bb2724e93b5d5b7a672cbf5e8", + "IPY_MODEL_5b2edaa051054124b317aa95de3b0a6a" + ], + "layout": "IPY_MODEL_38bc474a0d06487180f71a71ae69c5f6" + } + }, + "7fadbe16d1094cb38147abb7cb2f4925": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "IntTextModel", + "state": { + "description": "Maximum", + "layout": "IPY_MODEL_4e51cd8a9cc8443b9106b6d0eabc234c", + "step": 1, + "style": "IPY_MODEL_d8c67fb04dba41dc858e0da764b0e6d5" + } + }, + "81a92892f3b54601827100fdfd3bf219": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "834f4cc42c1546538f18bbffcde38398": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "840292dcfa7f4a4d897dca4c2a18fa63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "8439432eab1b465a9f1196349dc4c136": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_88bf4ff86b27405d835dffb337d5b9d8", + "style": "IPY_MODEL_37c9c23980704317835e235be6179486", + "value": "
Finished: 1hr 17min 56.4s
" + } + }, + "8873037bb2724e93b5d5b7a672cbf5e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_9b96383ec86a44a4b2093ea405248a60", + "max": 1, + "style": "IPY_MODEL_6749914566c840f6bf5c62eee6c8e740", + "value": 1 + } + }, + "88bf4ff86b27405d835dffb337d5b9d8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "897ffbbe561c4738b954fa0221797db7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_74097c600949435b84433cfca93f9dab", + "style": "IPY_MODEL_9e581f60ab2f440cbb20185130d99954", + "value": "
run_batch
" + } + }, + "89fb4b6b807e420484a057e02a089834": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_fa800f253f394091b4db6bd335b3f4b8", + "IPY_MODEL_d6f815cd55c448a1a88e992d9912326c" + ], + "layout": "IPY_MODEL_52822a8c109c4f47ad1e27b36dad4498" + } + }, + "8b31180c33f44b6e8933e9cc0ec97903": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "8d0fbf56bfc140659768ed3f41c45d90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "9087d1288cc74b25b96bc36457cf9c86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_c9e534d150a14788a78ab42359f3dfab", + "style": "IPY_MODEL_73c5d03be3fc4385af68f3c2ddc40e6c", + "value": "
Finished: 9min 13.3s
" + } + }, + "90ee381c05984631b0607e0c4e5c834c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "description": "Adapt", + "layout": "IPY_MODEL_4e51cd8a9cc8443b9106b6d0eabc234c", + "style": "IPY_MODEL_26e469238501404f96542480e40a64e5" + } + }, + "928181208ce2443f8278c26744d66926": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "928228174ba64e6fa7e3400e55e237f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "93c4637d3469462b99192a248cbafd87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_025b107359e8494985fcefba1c2e43ee", + "style": "IPY_MODEL_22e8ec715f0043ee88310eb409224faa", + "value": "
67 / 67
" + } + }, + "95b0281a6dea40d9ba011de14bdbfc7e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "9675c2267a35465ab2a9c2fe5da02f9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "96ec83ef01fa4b6e8159cc3bb051509c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_a69276475e614fb6b89a163b5735ed36" + ], + "layout": "IPY_MODEL_7a4dad3cf68b4e48b62e4fb446171ce3" + } + }, + "9b96383ec86a44a4b2093ea405248a60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "9cb81102a0cd4a5181d3417d1236d930": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_10ef31469b124f85bde701a7a52315bf", + "max": 1, + "style": "IPY_MODEL_78a6359adf57408090e190c8280787a7", + "value": 1 + } + }, + "9e581f60ab2f440cbb20185130d99954": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "a20af9530e4e47fe81d1c3c30e8bd436": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "a287cc2020e941dbb4ec8862559d8d03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "a69276475e614fb6b89a163b5735ed36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_fa9e12916ada4a3c8f18016054293783", + "IPY_MODEL_9cb81102a0cd4a5181d3417d1236d930", + "IPY_MODEL_58a5f49ba22c4157ab3c8bedfda73b52" + ], + "layout": "IPY_MODEL_56bc83bb6b5b43a587f918caa2ca64f4" + } + }, + "a7faa49336aa4d049956a262bf2e5d84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "a891144765dc45e484b20ea4aa7a0906": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a7faa49336aa4d049956a262bf2e5d84", + "style": "IPY_MODEL_928228174ba64e6fa7e3400e55e237f7", + "value": "

GatewayCluster

" + } + }, + "a97a55314fee44b58172aecc6ab52ac4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "a9ac73548240496eb11975dfcdb9c044": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_8b31180c33f44b6e8933e9cc0ec97903", + "max": 1, + "style": "IPY_MODEL_74bab6fe2d904d8fa2abe91c57f49c0c", + "value": 1 + } + }, + "aaa9b3dcff9a4761bf416075ee9c5371": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "aaf076c445f243f7a57f16607cc200e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_8439432eab1b465a9f1196349dc4c136", + "IPY_MODEL_96ec83ef01fa4b6e8159cc3bb051509c" + ], + "layout": "IPY_MODEL_72569d836c9e40f0909f8828cd2cdd4d" + } + }, + "ab4d0e904841425abf43a4b763e2d3e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "ab5931b37c66495380648b6fc1c41fdd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "ac00b4f535dc4fa28df607d36261ba02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "b745ecb0604442f4934d64d3de414140": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_026c0c222181416ab109ca7372d2c9bf", + "IPY_MODEL_7fadbe16d1094cb38147abb7cb2f4925", + "IPY_MODEL_90ee381c05984631b0607e0c4e5c834c" + ], + "layout": "IPY_MODEL_d71072ec97d24e24b1112ffe62a51af5" + } + }, + "b932d9780cf9482ca4bc3eb88183c5c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5c40b198f23b49d8b531ca1ad7a79e10", + "style": "IPY_MODEL_0cc92f85655f40d8a3e3ce8d85051489", + "value": "
run_batch
" + } + }, + "bb592927448241b9ac4329b772f7bf86": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "be2d98ad206a47ed944cf4d42fb9d328": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "be7f5d3fadb44292873ce4da0d68b1b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "c9e534d150a14788a78ab42359f3dfab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "cdb9b031355c4441b8b31d5c95be1dc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "min_width": "150px" + } + }, + "ce7059379a394fb2bbe0b05add67b2f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "d1aa2ba6533b433686f4c03d30ec42bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_e47746b5a42348688e2f045605dee7d1", + "IPY_MODEL_e4341f78b68f435ba6e6d2e9cb0de7d4" + ], + "layout": "IPY_MODEL_be7f5d3fadb44292873ce4da0d68b1b4" + } + }, + "d6f815cd55c448a1a88e992d9912326c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "AccordionModel", + "state": { + "_titles": { + "0": "Manual Scaling", + "1": "Adaptive Scaling" + }, + "children": [ + "IPY_MODEL_4f2b0dd904ce464e8eabc3de04a6dca5", + "IPY_MODEL_b745ecb0604442f4934d64d3de414140" + ], + "layout": "IPY_MODEL_f91409ee90c14b29af8e8a956990badd", + "selected_index": null + } + }, + "d70653312b8c4d49a3c44a62c7cf694c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_1a6b7b3270494781b97a90279c2261b4", + "IPY_MODEL_efe768b143594a3a94aaaa4e67ae67aa" + ], + "layout": "IPY_MODEL_ce7059379a394fb2bbe0b05add67b2f7" + } + }, + "d71072ec97d24e24b1112ffe62a51af5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "d87c4689c4c44600a3c6e321c19c16f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "d8c67fb04dba41dc858e0da764b0e6d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "d9457500ca8945f788df02c372ef5fcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_bb592927448241b9ac4329b772f7bf86", + "max": 1, + "style": "IPY_MODEL_8d0fbf56bfc140659768ed3f41c45d90", + "value": 1 + } + }, + "dfb2dc339a494ea891ca3a03a38a839f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "e2c6461db44d4fcfba77abd869b822eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "e32474e03e8f4559802b6144cd6a9aa4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "e4341f78b68f435ba6e6d2e9cb0de7d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_7b98d59f26354a6db4c6296ed34899c7" + ], + "layout": "IPY_MODEL_ab5931b37c66495380648b6fc1c41fdd" + } + }, + "e47746b5a42348688e2f045605dee7d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_43a78cbc080d4d94841c8f8af8b50eb4", + "style": "IPY_MODEL_dfb2dc339a494ea891ca3a03a38a839f", + "value": "
Finished: 1hr 16min 39.9s
" + } + }, + "e62ab9c3134340ca832b788beeb30e12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "eb249e5749ec4388abe3b2825fa0f3a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "ef551c4113954c5aab97b743838180b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "efe768b143594a3a94aaaa4e67ae67aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_44c9f1e0775e4318a830fd4565de82c8" + ], + "layout": "IPY_MODEL_24d74565e58a4ff7b9f8cc257726d629" + } + }, + "f29d6daccdab494ca9c05f43bd131207": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "f6930f6fc7ee4d80b0adf733e2eced6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_e2c6461db44d4fcfba77abd869b822eb", + "style": "IPY_MODEL_720cccf78c934a4b84f6f45f1d8a0af5", + "value": "

Name: daskhub-dev.7b42fe169b8647ed92c39ec0acec6d82

" + } + }, + "f91409ee90c14b29af8e8a956990badd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "min_width": "500px" + } + }, + "f953bcfe9daf4ac8ba8e4127453b36fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ab4d0e904841425abf43a4b763e2d3e2", + "style": "IPY_MODEL_ac00b4f535dc4fa28df607d36261ba02", + "value": "

Dashboard: /services/dask-gateway/clusters/daskhub-dev.7b42fe169b8647ed92c39ec0acec6d82/status

\n" + } + }, + "fa800f253f394091b4db6bd335b3f4b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_cdb9b031355c4441b8b31d5c95be1dc5", + "style": "IPY_MODEL_4db704dc7d05472c8b2f00743ef0a6ed", + "value": "\n
\n\n\n \n \n \n
Workers 64
Cores 64
Memory 416.00 GiB
\n
\n" + } + }, + "fa9e12916ada4a3c8f18016054293783": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_81a92892f3b54601827100fdfd3bf219", + "style": "IPY_MODEL_be2d98ad206a47ed944cf4d42fb9d328", + "value": "
67 / 67
" + } + }, + "fabcf155c317400e92f810e06f4b44d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "fd53353613644e2f87ace812c76885a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + } + ] + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-SLR/process-localizesl-output.ipynb b/notebooks/create-SLIIDERS-SLR/process-localizesl-output.ipynb new file mode 100644 index 0000000..3a4cdb6 --- /dev/null +++ b/notebooks/create-SLIIDERS-SLR/process-localizesl-output.ipynb @@ -0,0 +1,836 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# Aggregate TSV outputs of LocalizeSL into Zarr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import dask.config\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from dask_gateway import Gateway\n", + "from gcsfs import GCSFileSystem\n", + "from tqdm.notebook import tqdm\n", + "\n", + "from rhg_compute_tools import xarray as rhgx\n", + "from sliiders.settings import (\n", + " DIR_SLR_INT,\n", + " LOCALIZESL_COREFILES,\n", + " PATH_SLIIDERS_SLR,\n", + " PATH_SLR_N_GCMS,\n", + ")\n", + "from sliiders.utils import upload_pkg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# attrs for output zarr\n", + "AUTHOR = \"Ian Bolliger, Daniel Allen\"\n", + "CONTACT = \"ibolliger@rhg.com, dallen@berkeley.edu\"\n", + "METHOD = \"\"\"LocalizeSL was used to estimate monte carlo draws of future GMSL and LMSL relative to a vertical datum of MSL2000. Data quality adjustments:\n", + "1. RCP6 ignored due to no post-2100 projections and fewer GCMS used for pre-2100 projections.\n", + "2. Sites with <3 GCMs for an pre-2100 years dropped.\n", + "3. Sites with any null values for post-2100 projections dropped.\"\"\"\n", + "DESCRIPTION = \"LocalizeSL-based relative sea level rise projections\"\n", + "\n", + "FS = GCSFileSystem(token=\"/opt/gcsfuse_tokens/rhg-data.json\")\n", + "PATH_SLR_N_GCMS = FS.get_mapper(PATH_SLR_N_GCMS.relative_to(\"/gcs\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gateway = Gateway()\n", + "cluster = gateway.new_cluster(\n", + " idle_timeout=3600,\n", + " profile=\"micro\",\n", + ")\n", + "client = cluster.get_client()\n", + "cluster.scale(140)\n", + "\n", + "upload_pkg(client, \"../../sliiders\")\n", + "cluster" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Get lists of outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Corefile: SLRProjections190726core_SEJ_full -- 4192 site scenario files found, 2 global files found\n", + "Corefile: SLRProjections170113GRIDDEDcore -- 6288 site scenario files found, 3 global files found\n", + "Corefile: SLRProjections200204GRIDDEDcore_D20 -- 6288 site scenario files found, 3 global files found\n", + "Corefile: SLRProjections210628GRIDDEDcore_SROCC -- 6288 site scenario files found, 3 global files found\n", + "From all corefiles, 2096 baseline paths found\n" + ] + } + ], + "source": [ + "lsl_baseline_paths = dict()\n", + "\n", + "corefile_paths = dict()\n", + "for corefile in LOCALIZESL_COREFILES:\n", + " corefile_paths[corefile] = dict()\n", + " dir_tsv = DIR_SLR_INT / \"tmp\" / corefile / \"mc_tsv\"\n", + "\n", + " all_lsl_paths = list(dir_tsv.glob(\"LSL*.tsv\"))\n", + " all_gsl_paths = list(dir_tsv.glob(\"GSL*.tsv\"))\n", + "\n", + " corefile_paths[corefile][\"lsl_scenario_paths\"] = [\n", + " p for p in all_lsl_paths if \"_rcp60\" not in p.stem and \"_baseline\" not in p.stem\n", + " ]\n", + "\n", + " all_baseline_paths = [p for p in all_lsl_paths if \"_baseline\" in p.stem]\n", + " baseline_paths = {p.stem.split(\"_\")[-2]: p for p in all_baseline_paths}\n", + "\n", + " for site_id in baseline_paths:\n", + " lsl_baseline_paths[site_id] = baseline_paths[site_id]\n", + "\n", + " corefile_paths[corefile][\"lsl_baseline_paths\"] = [\n", + " p for p in all_lsl_paths if \"_baseline\" in p.stem\n", + " ]\n", + "\n", + " corefile_paths[corefile][\"gsl_paths\"] = [\n", + " p for p in all_gsl_paths if \"_rcp60\" not in p.stem and \"_baseline\" not in p.stem\n", + " ]\n", + "\n", + " print(\n", + " f\"Corefile: {corefile} -- {len(corefile_paths[corefile]['lsl_scenario_paths'])} site scenario \"\n", + " f\"files found, \"\n", + " f\"{len(corefile_paths[corefile]['gsl_paths'])} global files found\"\n", + " )\n", + "\n", + "lsl_baseline_paths = list(lsl_baseline_paths.values())\n", + "print(f\"From all corefiles, {len(lsl_baseline_paths)} baseline paths found\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define functions to load and process TSVs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def combine_site_tsvs_into_dataframe(paths, is_baseline=False):\n", + " \"\"\"Open TSVs that are outputs of `WriteTableMC`, a function in the LocalizeSL repository\"\"\"\n", + "\n", + " dfs = []\n", + " for path in tqdm(paths):\n", + " df = pd.read_csv(\n", + " path,\n", + " sep=\"\\t\",\n", + " skiprows=2,\n", + " header=None,\n", + " names=[\"year\"] + [i for i in range(10000)],\n", + " )\n", + " rcp = path.stem.split(\"_\")[-1]\n", + " corefile = path.parent.parent.name\n", + " df.insert(0, \"scenario\", f\"{corefile}_{rcp}\")\n", + " df = df.dropna(subset=[0])\n", + " dfs.append(df)\n", + "\n", + " df_info = pd.read_csv(paths[0], nrows=0).columns[0]\n", + " coords = (df_info.split(\" \")[0]).split(\"_\")[1:]\n", + " # GSL\n", + " if coords == []:\n", + " lon = np.nan\n", + " lat = np.nan\n", + " # LSL\n", + " else:\n", + " lat = float(coords[0])\n", + " lon = float(coords[1])\n", + " site_id = path.stem.split(\"_\")[-2]\n", + "\n", + " out_df = pd.concat(dfs, ignore_index=True)\n", + "\n", + " out_df = out_df.sort_values([\"scenario\", \"year\"])\n", + " out_df.columns.name = \"mc_sample_id\"\n", + "\n", + " return out_df, site_id, lon, lat\n", + "\n", + "\n", + "def df_to_da(combined, site_id, lon, lat):\n", + "\n", + " # Move columns representing sample instances to possible values of a single column\n", + " flattened = combined.melt(id_vars=[\"scenario\", \"year\"], value_name=\"msl_msl00\")\n", + "\n", + " # Some type-casting\n", + " flattened[\"year\"] = flattened[\"year\"].astype(np.uint16)\n", + "\n", + " # Convert centimeters to meters\n", + " flattened[\"msl_msl00\"] = flattened[\"msl_msl00\"] / 100\n", + " flattened[\"msl_msl00\"] = flattened[\"msl_msl00\"].astype(np.float32)\n", + "\n", + " # Set index as dimensions of destination xarray Dataset\n", + " flattened = flattened.set_index([\"scenario\", \"year\", \"mc_sample_id\"])\n", + "\n", + " # Convert to DataArray\n", + " ds = flattened.to_xarray()\n", + "\n", + " # add in coords\n", + " ds = ds.expand_dims({\"site_id\": [site_id]})\n", + " ds.coords[\"lon\"] = (\"site_id\", [lon])\n", + " ds.coords[\"lat\"] = (\"site_id\", [lat])\n", + "\n", + " # make sure longitude is -180 to 180\n", + " ds[\"lon\"] = ds.lon.where(ds.lon <= 180, -360 + ds.lon)\n", + "\n", + " # some type casting to minimize size\n", + " ds[\"year\"] = ds.year.astype(np.uint16)\n", + " ds[\"mc_sample_id\"] = ds.mc_sample_id.astype(np.uint16)\n", + "\n", + " # convert to DataArray\n", + " da = ds.msl_msl00\n", + "\n", + " return da\n", + "\n", + "\n", + "def process_site(paths, is_baseline=False):\n", + " combined, site_id, lon, lat = combine_site_tsvs_into_dataframe(paths)\n", + " if is_baseline:\n", + " combined[\"scenario\"] = \"baseline\"\n", + "\n", + " da_out = df_to_da(\n", + " combined,\n", + " site_id,\n", + " lon,\n", + " lat,\n", + " )\n", + " if is_baseline:\n", + " return da_out.squeeze(\"scenario\").drop(\"scenario\")\n", + " return da_out\n", + "\n", + "\n", + "def get_groups_from_paths(paths):\n", + " # group jobs by site_id\n", + " site_ids = [p.stem.split(\"_\")[-2] for p in paths]\n", + " site_ser = pd.Series(paths, index=site_ids)\n", + " return site_ser.groupby(level=0).apply(list).to_list()\n", + "\n", + "\n", + "def process_all_sites(corefile):\n", + " lsl_groups = get_groups_from_paths(corefile_paths[corefile][\"lsl_scenario_paths\"])\n", + "\n", + " # submit jobs to return futures of dataarrays\n", + " gsl_fut = client.submit(process_site, corefile_paths[corefile][\"gsl_paths\"])\n", + " lsl_fut = client.map(process_site, lsl_groups)\n", + " return gsl_fut, lsl_fut" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Process all files" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SLRProjections190726core_SEJ_full\n", + "SLRProjections170113GRIDDEDcore\n", + "SLRProjections200204GRIDDEDcore_D20\n", + "SLRProjections210628GRIDDEDcore_SROCC\n" + ] + } + ], + "source": [ + "sl_arrs = []\n", + "for ix, corefile in enumerate(LOCALIZESL_COREFILES.keys()):\n", + " print(corefile)\n", + "\n", + " # process results\n", + " gsl_fut, lsl_fut = process_all_sites(corefile)\n", + "\n", + " # gather arrays\n", + " gsl_arr = rhgx.dataarrays_from_delayed([gsl_fut], client=client)[0].squeeze(\n", + " drop=True\n", + " )\n", + " lsl_arr = rhgx.dataarray_from_delayed(lsl_fut, dim=\"site_id\", client=client).astype(\n", + " np.float32\n", + " )\n", + "\n", + " # merge arrays\n", + " sl_arr = xr.Dataset(\n", + " {\n", + " \"lsl_msl00\": lsl_arr,\n", + " \"gsl_msl00\": gsl_arr,\n", + " }\n", + " ).persist()\n", + "\n", + " sl_arrs.append(sl_arr)\n", + "\n", + "baseline_groups = get_groups_from_paths(lsl_baseline_paths)\n", + "lsl_baseline_fut = client.map(process_site, baseline_groups, is_baseline=True)\n", + "\n", + "lsl_baseline_arr = rhgx.dataarray_from_delayed(\n", + " lsl_baseline_fut, dim=\"site_id\", client=client\n", + ").astype(np.float32)\n", + "\n", + "lsl_baseline_arr = xr.Dataset(\n", + " {\n", + " \"lsl_ncc_msl00\": lsl_baseline_arr,\n", + " }\n", + ").persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sl_arr = xr.merge((xr.concat(sl_arrs, \"scenario\"), lsl_baseline_arr))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# update attrs\n", + "sl_arr.lsl_msl00.attrs.update(\n", + " {\n", + " \"long_name\": \"Estimated Future LMSL, MSL00\",\n", + " \"description\": (\n", + " \"Monte Carlo estimates of local mean sea level for a given RCP scenario \"\n", + " \"and year. Estimates are made on a sparse 2-degree coastal grid, and are \"\n", + " \"relative to MSL00 vertical datum.\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "\n", + "sl_arr.gsl_msl00.attrs.update(\n", + " {\n", + " \"long_name\": \"Estimated Future GMSL, MSL00\",\n", + " \"description\": (\n", + " \"Monte Carlo estimates of global mean sea level for a given RCP scenario \"\n", + " \"and year. Estimates are relative to MSL00 vertical datum.\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "\n", + "sl_arr.lsl_ncc_msl00.attrs.update(\n", + " {\n", + " \"long_name\": \"Counterfactual Future LMSL (no climate change), MSL00\",\n", + " \"description\": (\n", + " \"Monte Carlo estimates of local mean sea level in the no-climate change scenario \"\n", + " \"for each year. Estimates are made on a sparse 2-degree coastal grid, and are \"\n", + " \"relative to MSL00 vertical datum.\"\n", + " ),\n", + " \"units\": \"m\",\n", + " }\n", + ")\n", + "\n", + "sl_arr.attrs.update(\n", + " {\n", + " \"author\": AUTHOR,\n", + " \"contact\": CONTACT,\n", + " \"description\": DESCRIPTION,\n", + " \"method\": METHOD,\n", + " \"updated\": pd.Timestamp.now(tz=\"US/Pacific\").strftime(\"%c\"),\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clean the outputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clean using the following criteria:\n", + "\n", + "- Ignore RCP6 when creating groups of trajectories binned by GMSL (this occurs later in the binning notebook). This is missing for all sites post-2100 (since no CMIP5 models were run for the extended timeline using RCP6 and has fewer GCMs used than other scenarios for the pre-2100 years (since RCP6 was not a prioritized scenario).\n", + "- Drop any sites that have <3 GCMs for any pre-2100 years.\n", + "- Ignoring RCP6 (which has missing values for all sites after 2100), drop any sites that have null values for any post-2100 years (no sites have missing values outside of RCP6 for pre-2100 years)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "local_metadata": { + "tags": [] + }, + "remote_metadata": {} + }, + "outputs": [], + "source": [ + "n_gcms = xr.open_zarr(PATH_SLR_N_GCMS, chunks=None).numGCMs.load()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# filter to only sites w/ >=3 gcms\n", + "good_sites = (\n", + " n_gcms.sel(year=slice(None, 2090)).min(dim=[\"year\", \"scenario\"]) >= 3\n", + ").values\n", + "\n", + "# filter to sites that have no missing values\n", + "good_sites = (\n", + " good_sites\n", + " & sl_arr.lsl_msl00.notnull().all(dim=[\"mc_sample_id\", \"scenario\", \"year\"]).values\n", + ")\n", + "\n", + "# execute filtering\n", + "with dask.config.set(**{\"array.slicing.split_large_chunks\": False}):\n", + " sl_arr = sl_arr.isel(site_id=good_sites).persist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# re-chunk\n", + "sl_arr = sl_arr.chunk(\n", + " {\"scenario\": -1, \"site_id\": 100, \"year\": -1, \"mc_sample_id\": 100}\n", + ").persist()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Save" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sl_arr.to_zarr(FS.get_mapper(PATH_SLIIDERS_SLR.relative_to(\"/gcs\")), mode=\"w\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cluster.close(), client.close()" + ] + } + ], + "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.10" + }, + "nbdime-conflicts": { + "local_diff": [ + { + "key": "widgets", + "op": "add", + "value": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + } + ], + "remote_diff": [ + { + "key": "widgets", + "op": "add", + "value": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0076aa049aaa4ca3903afa05d5dcf14a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "02384fe74f774f47b037d5863b7070b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_58c2f7e60e9f44f2856ae5f917718d2e", + "style": "IPY_MODEL_4fd8d719926648e384cf0302d416a20a", + "value": "

Dashboard: /services/dask-gateway/clusters/daskhub-dev.33349d5e586245c7a57e585ee1cc92a6/status

\n" + } + }, + "072710f5a5d24788beadfe83105a204a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d427b85661fc464c91e900374b75212d", + "IPY_MODEL_f3c6a0285b4f4efd878d83e6f7c20aa8" + ], + "layout": "IPY_MODEL_f0b4ddf4acd34d6384fd885c57c6d5cc" + } + }, + "13555bcc815840b98f8f4f080b9c08da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "1f0a472b1af54581a3181bf915e7e902": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "225d8927d3c649cf906e04e2149828f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2ca364e8531042f09f61623a058bd0c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "150px" + } + }, + "37616593ee214ce68284e2dedf4f74cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "4faa28ce442d4531bb90012eb58cd01f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "IntTextModel", + "state": { + "description": "Workers", + "layout": "IPY_MODEL_2ca364e8531042f09f61623a058bd0c3", + "step": 1, + "style": "IPY_MODEL_225d8927d3c649cf906e04e2149828f9" + } + }, + "4fd8d719926648e384cf0302d416a20a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "50a09203816b48a7bbe5a6b4f82447cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_7cb3b025ed42447f90ff87f2010fb123", + "style": "IPY_MODEL_cdaa5671ba4d4f769291c596fc333fab", + "value": "

GatewayCluster

" + } + }, + "54ac6e8841c04dcfb48d1d3f97b17697": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5548e78809424dd6b70acaf470126ffc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "556480de37274becb4f321d0210e50e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5790eb0bb5a54f86b731c9e433d5be4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_50a09203816b48a7bbe5a6b4f82447cd", + "IPY_MODEL_072710f5a5d24788beadfe83105a204a", + "IPY_MODEL_dd9f0374151f4865b7ef19850ac556aa", + "IPY_MODEL_02384fe74f774f47b037d5863b7070b0" + ], + "layout": "IPY_MODEL_1f0a472b1af54581a3181bf915e7e902" + } + }, + "589e0bff592c48389395393cf8e6b434": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "IntTextModel", + "state": { + "description": "Minimum", + "layout": "IPY_MODEL_2ca364e8531042f09f61623a058bd0c3", + "step": 1, + "style": "IPY_MODEL_5548e78809424dd6b70acaf470126ffc" + } + }, + "58c2f7e60e9f44f2856ae5f917718d2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "64dc4bde5b1243729f601307cb5551e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "IntTextModel", + "state": { + "description": "Maximum", + "layout": "IPY_MODEL_2ca364e8531042f09f61623a058bd0c3", + "step": 1, + "style": "IPY_MODEL_556480de37274becb4f321d0210e50e4" + } + }, + "7cb3b025ed42447f90ff87f2010fb123": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "8f09161fb4784fff940eface7043fde1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "description": "Scale", + "layout": "IPY_MODEL_2ca364e8531042f09f61623a058bd0c3", + "style": "IPY_MODEL_de3bf99ec72b4844a92d67c3761abbb7" + } + }, + "99c63563f34a41d09d2d5d98a37e6db5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "min_width": "150px" + } + }, + "b8d10e468f144cfea362b385cf79cd7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "description": "Adapt", + "layout": "IPY_MODEL_2ca364e8531042f09f61623a058bd0c3", + "style": "IPY_MODEL_0076aa049aaa4ca3903afa05d5dcf14a" + } + }, + "bf5b337abe18402bb7b5915277677be8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "c1a7fb7e3ba04c21a20719278bb006fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "cdaa5671ba4d4f769291c596fc333fab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "d1710681c40241cd9755dc88200f5149": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_4faa28ce442d4531bb90012eb58cd01f", + "IPY_MODEL_8f09161fb4784fff940eface7043fde1" + ], + "layout": "IPY_MODEL_bf5b337abe18402bb7b5915277677be8" + } + }, + "d427b85661fc464c91e900374b75212d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_99c63563f34a41d09d2d5d98a37e6db5", + "style": "IPY_MODEL_54ac6e8841c04dcfb48d1d3f97b17697", + "value": "\n
\n\n\n \n \n \n
Workers 140
Cores 140
Memory 910.00 GiB
\n
\n" + } + }, + "dd9f0374151f4865b7ef19850ac556aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_c1a7fb7e3ba04c21a20719278bb006fb", + "style": "IPY_MODEL_37616593ee214ce68284e2dedf4f74cb", + "value": "

Name: daskhub-dev.33349d5e586245c7a57e585ee1cc92a6

" + } + }, + "de3bf99ec72b4844a92d67c3761abbb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "f0b4ddf4acd34d6384fd885c57c6d5cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "f3c6a0285b4f4efd878d83e6f7c20aa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "AccordionModel", + "state": { + "_titles": { + "0": "Manual Scaling", + "1": "Adaptive Scaling" + }, + "children": [ + "IPY_MODEL_d1710681c40241cd9755dc88200f5149", + "IPY_MODEL_fdc9fde437bd4309b55f0fc168dce3a6" + ], + "layout": "IPY_MODEL_f53e6c2926114df0892b2318f23d62ec", + "selected_index": null + } + }, + "f53e6c2926114df0892b2318f23d62ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "min_width": "500px" + } + }, + "fdc9fde437bd4309b55f0fc168dce3a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_589e0bff592c48389395393cf8e6b434", + "IPY_MODEL_64dc4bde5b1243729f601307cb5551e7", + "IPY_MODEL_b8d10e468f144cfea362b385cf79cd7c" + ], + "layout": "IPY_MODEL_13555bcc815840b98f8f4f080b9c08da" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + } + ] + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/create-SLIIDERS-SLR/retrieve-num-gcms.ipynb b/notebooks/create-SLIIDERS-SLR/retrieve-num-gcms.ipynb new file mode 100644 index 0000000..a7db300 --- /dev/null +++ b/notebooks/create-SLIIDERS-SLR/retrieve-num-gcms.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d54c06e4-f962-40a2-9d51-5d53f613fc42", + "metadata": {}, + "source": [ + "# Retrieve `OceanDynN` information from LocalizeSL corefiles\n", + "`OceanDynN` represents the number of GCMs used to calculate LSL projections for each year-RCP-site\n", + "\n", + "This notebook saves this information in a `.zarr` in a format similar to the projections themselves" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06b96358-6f6c-4d18-993c-548d013f662f", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import pandas as pd\n", + "from gcsfs import GCSFileSystem\n", + "from oct2py import octave\n", + "\n", + "from sliiders.settings import (\n", + " DIR_IFILES_INT,\n", + " DIR_SLR_INT,\n", + " LOCALIZESL_COREFILES,\n", + " PATH_SLR_N_GCMS,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b1d27162-8a9b-4752-9d88-050379c29191", + "metadata": {}, + "source": [ + "#### Define paths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fb517fb-cf6c-4bb7-aeb6-575c9fe082be", + "metadata": {}, + "outputs": [], + "source": [ + "FS = GCSFileSystem(token=\"/opt/gcsfuse_tokens/rhg-data.json\")\n", + "PATH_SLR_N_GCMS = FS.get_mapper(PATH_SLR_N_GCMS.relative_to(\"/gcs\"))\n", + "\n", + "DIR_OCTAVE_OUTPUTS = DIR_SLR_INT / \"ngcm_localizeSL_outputs\"\n", + "DIR_OCTAVE_OUTPUTS.mkdir(exist_ok=True)\n", + "\n", + "DIR_MFILES = Path(\"../../LocalizeSL/MFILES\")" + ] + }, + { + "cell_type": "markdown", + "id": "c1ccca44-499b-410d-b205-23582d25a2ab", + "metadata": {}, + "source": [ + "### Define Octave function to save information about `OceanDyn` parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d9e7d86-c117-4583-bddd-7a855baacdba", + "metadata": {}, + "outputs": [], + "source": [ + "load_oceandyn_func = f\"\"\"\n", + "function oceandyn_info = save_oceandyn_info(corefile_name, subcorefile_choice)\n", + " dir_out = '{DIR_OCTAVE_OUTPUTS}';\n", + "\n", + " ifilesdir='{DIR_IFILES_INT}';\n", + " mfilesdir='{DIR_MFILES}';\n", + "\n", + " addpath(ifilesdir);\n", + " addpath(mfilesdir);\n", + "\n", + " f = [corefile_name '_v5.mat'];\n", + "\n", + " corefilewrapper=load(fullfile(ifilesdir, f));\n", + "\n", + " mkdir(dir_out);\n", + "\n", + " if strcmp(corefile_name, 'SLRProjections190726core_SEJ_full')\n", + " if strcmp(subcorefile_choice, \"H\")\n", + " corefile = corefilewrapper.corefileH;\n", + " else\n", + " corefile = corefilewrapper.corefileL;\n", + " end\n", + " else\n", + " corefile = corefilewrapper;\n", + " end\n", + "\n", + " disp([\"Corefile: \" corefile_name]);\n", + " disp([\"Corefile subgroup: \" subcorefile_choice]);\n", + "\n", + " siteids = int64(corefile.targregions);\n", + "\n", + " for i=1:length(corefile.scens)\n", + " scen = cell2mat(corefile.scens(i));\n", + " csvwrite(strcat(dir_out, '/OceanDynN_', corefile_name, '_', scen, '.csv'), corefile.OceanDynN(:,:,i));\n", + " csvwrite(strcat(dir_out, '/OceanDynYears_', corefile_name, '_', scen, '.csv'), corefile.OceanDynYears);\n", + " dlmwrite(strcat(dir_out, '/siteid_', corefile_name, '_', scen, '.csv'), siteids, 'precision', '%i')\n", + " end\n", + "end\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "id": "d3b7abb1-a454-4768-b0e1-4633950cb6ea", + "metadata": {}, + "source": [ + "### Save OceanDyn metadata for each corefile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e22ac5a3-7b5c-44ad-ac2b-2ef5b7802ad9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Corefile: SLRProjections190726core_SEJ_full\n", + "Corefile subgroup: L\n", + "Corefile: SLRProjections190726core_SEJ_full\n", + "Corefile subgroup: H\n", + "Corefile: SLRProjections170113GRIDDEDcore\n", + "warning: implicit conversion from numeric to char\n", + "Corefile subgroup: \u0000\n", + "Corefile: SLRProjections200204GRIDDEDcore_D20\n", + "warning: implicit conversion from numeric to char\n", + "Corefile subgroup: \u0000\n", + "Corefile: SLRProjections210628GRIDDEDcore_SROCC\n", + "warning: implicit conversion from numeric to char\n", + "Corefile subgroup: \u0000\n" + ] + } + ], + "source": [ + "octave.eval(load_oceandyn_func)\n", + "\n", + "for corefile_name, subcorefiles in LOCALIZESL_COREFILES.items():\n", + " for subcorefile_choice in subcorefiles:\n", + " octave.save_oceandyn_info(corefile_name, subcorefile_choice)" + ] + }, + { + "cell_type": "markdown", + "id": "78ddc154-c4e0-439a-849b-788ec59d15ea", + "metadata": {}, + "source": [ + "### Load CSV outputs into DataFrames" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83c33314-69b6-4e50-80fe-bd9462b64aae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SLRProjections190726core_SEJ_full ['2p0degree+L', 'rcp85+H']\n", + "SLRProjections170113GRIDDEDcore ['rcp26', 'rcp45', 'rcp60', 'rcp85']\n", + "SLRProjections200204GRIDDEDcore_D20 ['rcp26', 'rcp45', 'rcp60', 'rcp85']\n", + "SLRProjections210628GRIDDEDcore_SROCC ['rcp26', 'rcp45', 'rcp60', 'rcp85']\n" + ] + } + ], + "source": [ + "rcps = [\"2p0degree+L\", \"rcp85+H\", \"rcp26\", \"rcp45\", \"rcp60\", \"rcp85\"]\n", + "\n", + "dfs = []\n", + "for corefile in LOCALIZESL_COREFILES.keys():\n", + "\n", + " rcps = [\"rcp26\", \"rcp45\", \"rcp60\", \"rcp85\"]\n", + " if corefile == \"SLRProjections190726core_SEJ_full\":\n", + " rcps = [\"2p0degree+L\", \"rcp85+H\"]\n", + "\n", + " print(corefile, rcps)\n", + "\n", + " for rcp in rcps:\n", + " scenario = f\"{corefile}_{rcp}\"\n", + " sites = pd.read_csv(DIR_OCTAVE_OUTPUTS / f\"siteid_{scenario}.csv\", header=None)\n", + " sites[\"name\"] = sites[0].astype(int).astype(str)\n", + " sites = sites.drop(columns=[0])\n", + "\n", + " years = pd.read_csv(\n", + " DIR_OCTAVE_OUTPUTS / f\"OceanDynYears_{scenario}.csv\", header=None\n", + " )\n", + "\n", + " years = years.T.rename(columns={0: \"year\"})\n", + "\n", + " df = pd.read_csv(\n", + " DIR_OCTAVE_OUTPUTS / f\"OceanDynN_{scenario}.csv\",\n", + " header=None,\n", + " names=sites[\"name\"].values,\n", + " )\n", + " df = df.join(years).set_index(\"year\", drop=True)\n", + " df = df[\n", + " [c for c in df.columns if int(c) > 100000000]\n", + " ] # These high-valued sites are the gridded ones\n", + " df = df.loc[2000:]\n", + " df[\"scenario\"] = scenario\n", + " df = df.set_index(\"scenario\", append=True)\n", + "\n", + " df = df.stack()\n", + " df.index = df.index.set_names(\"scenario\", level=1)\n", + " df.index = df.index.set_names(\"site_id\", level=2)\n", + "\n", + " dfs.append(df)" + ] + }, + { + "cell_type": "markdown", + "id": "152a6a4b-5343-4c2a-881c-ca22e6716041", + "metadata": {}, + "source": [ + "## Merge DataFrames into xarray and save" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65915940-695d-4623-b58d-89862d38a2bb", + "metadata": {}, + "outputs": [], + "source": [ + "pd.concat(dfs).to_xarray().to_dataset(name=\"numGCMs\").to_zarr(PATH_SLR_N_GCMS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e2c614b-5a22-4b46-8f5a-59a59f81f5e1", + "metadata": {}, + "outputs": [], + "source": [ + "FS.rm(str(DIR_OCTAVE_OUTPUTS.relative_to(\"/gcs\")), recursive=True)" + ] + } + ], + "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.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..13129ff --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,9 @@ +[build-system] +requires = [ + "setuptools>=42", + "wheel" +] +build-backend = "setuptools.build_meta" + +[tool.isort] +profile = "black" \ No newline at end of file diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..464f498 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,18 @@ +[metadata] +name = sliiders +description = A global coastal dataset of physical and socioeconomic metrics organized by coastal segment and elevation slice for use in global coastal risk research +long_description = file: README.md +long_description_content_type = text/markdown +author = Daniel Allen, Ian Bolliger, Nicholas Depsky, Junho Choi +author_email = ian.bolliger@blackrock.com +version = v1.0.0 +url = https://github.com/ClimateImpactLab/sliiders +classifiers = + Programming Language :: Python :: 3 + License :: OSI Approved :: MIT License + Operating System :: OS Independent + +[options] +packages = find: +include_package_data = True +python_requires = >=3.6 diff --git a/sliiders/__init__.py b/sliiders/__init__.py new file mode 100644 index 0000000..3b5eb16 --- /dev/null +++ b/sliiders/__init__.py @@ -0,0 +1,2 @@ +from . import country_level_ypk, gcs, settings, spatial +from .settings import * diff --git a/sliiders/country_level_ypk.py b/sliiders/country_level_ypk.py new file mode 100644 index 0000000..3d0503a --- /dev/null +++ b/sliiders/country_level_ypk.py @@ -0,0 +1,1279 @@ +# various functions used for the country-level information workflow +from itertools import product as lstprod + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from scipy.optimize import minimize as opt_min +from tqdm.auto import tqdm + +from .settings import PATH_PWT_RAW, PPP_CCODE_IF_MSNG, SCENARIOS, SSP_PROJ_ORG_SER + + +def log_lin_interpolate(df, header="v_"): + """Simple log-linear interpolation, to fit the horizontal (or wide-panel format) + dataset that we use. + + Parameters + ---------- + df : pandas DataFrame + contains data that we may interpolate + header : str + header of the variable names; should be followed by year (e.g., "v_1950") + + Returns + ------- + df_rtn : pandas DataFrame + DataFrame containing interpolated data + + """ + + v_ = np.sort([x for x in df.columns if header in x]) + yrs = [int(x.replace(header, "")) for x in v_] + all_yrs = range(min(yrs), max(yrs) + 1) + all_v = np.sort([header + str(x) for x in all_yrs]) + front_v = [x for x in df.columns if header not in x] + + df_missing_v = np.setdiff1d(all_v, v_) + df_rtn = df.copy() + if len(df_missing_v) > 0: + df_rtn[df_missing_v] = np.nan + + ## re-ordering the columns, just in case + df_rtn = df_rtn[np.hstack([front_v, all_v])] + + for i in df_rtn.index: + fp = df_rtn.loc[i, :][all_v] + ## in case there is any nonpositive values or no missing values, + ## cannot log-linearly interpolate (former) and no need to interpolate (latter) + if (fp <= 0).any() or (not fp.isnull().any()): + continue + + where_nm = np.where(~pd.isnull(fp.values))[0] + fp, i_yrs = np.log(fp[where_nm].astype("float64")), np.array(all_yrs)[where_nm] + + ## we only want to INTERpolate with this function, and not EXTRApolate + want_interp_range = range(i_yrs.min(), i_yrs.max() + 1) + case = np.exp(np.interp(want_interp_range, i_yrs, fp)) + want_interp_v = ["v_" + str(x) for x in want_interp_range] + df_rtn.loc[i, want_interp_v] = case + + return df_rtn + + +def ssp_and_model_simplify(ssp_col, model_col, df, dic=SSP_PROJ_ORG_SER): + """Simplifying the SSP and model (IAM) designations. For instance, "SSP2" has many + corresponding versions of the same scenario including SSP2_v9_130219, + SSP2_v9_130325, and so forth. This function simplifies those different names. + + Parameters + ---------- + ssp_col : str + column name for the SSP scenario + model_col : str + column name for the IAM scenario + df : pandas DataFrame + DataFrame to apply the function to + dic : dict + containing verbose names and simplified names for SSP-IAM scenarios + + Returns + ------- + df_rtn : pandas DataFrame + cleaned DataFrame containing simplified ssp and model names + + """ + + ser = pd.Series(dic) + + df["ssp"] = ser.reindex(df[ssp_col]).values + df["iam"] = ser.reindex(df[model_col]).values + + df_rtn = df.copy() + df_rtn.rename(columns={"REGION": "ccode"}, inplace=True) + + csi = ["ccode", "ssp", "iam"] + df_rtn_rest_col = [x for x in df_rtn.columns if x not in csi] + df_rtn = df_rtn[csi + df_rtn_rest_col] + + return df_rtn + + +def yearly_growth(df, header="v_"): + """Turn a horizontal (wide-panel) DataFrame with annual values (whose variable names + start with `header` and have year designations) into containing annual growth rates. + The initial-year growth rates are set to be 0. + + Parameters + ---------- + df : pandas DataFrame + DataFrame containing annual data, where for some 4-digit year `y`, the variable + names are as follows: `{header}{y}`; should be in wide-panel format (i.e., + one row for each country) + header : str + header for the annual variable names + + Returns + ------- + rtn_df : pandas DataFrame + DataFrame containing annual growth rates + + """ + + yrs = [int(v[-4:]) for v in df.columns if header in v] + others = [v for v in df.columns if header not in v] + yrs.sort() + v_ = [header + str(yr) for yr in yrs] + rtn_df = df[others + v_].copy() + + for i, v in enumerate(v_): + if i == 0: + rtn_df[v] = 0 + continue + v_prev = v_[(i - 1)] + rtn_df[v] = np.log(df[v]) - np.log(df[v_prev]) + + return rtn_df + + +def helper_extrap_using_closest( + prob_ctry, after, avail_yr, end_yr, tgt_df, sse_good_df, wgt_power, hdr="v_" +): + """Helper function for the function `extrap_using_closest`, which is used in + detecting similar-trajectory countries and using the said trajectories to impute + the missing values of another country + + Parameters + ---------- + prob_ctry : str + country code needing extrapolation (projection) + after : boolean + for projecting forward in time, set as True; for projecting backwards in time, + set as False + avail_yr : int + latest available year if projecting forward (`after`=True), and earliest + available year if projecting backwards (`after`=False) + end_yr : int + latest year to project until if projecting forward (`after`=True), and earliest + year to project until if projecting backwards (`after`=False) + tgt_df : pandas DataFrame + DataFrame to calculate the extrapolated projections from; should be in + wide-panel format, containing + sse_good_df : pandas DataFrame + DataFrame containing the sum of squared errors (of known growth rates) with + respect to the countries that have the closest trajectories to `prob_ctry` + wgt_power : float + by what exponent the weights (for creating extrapolations) should be applied at + hdr : str + header for the annual variables in `tgt_df` + + Returns + ------- + extrapolated : numpy array + containing extrapolated information, using similar-trajectory countries + + """ + + if prob_ctry is None: + prob_ctry = tgt_df.index.unique()[0] + + if after: + v_s = [hdr + str(x) for x in range(avail_yr, end_yr + 1)] + else: + v_s = [hdr + str(x) for x in range(end_yr, avail_yr + 1)] + + gr_df_base_avail = sse_good_df[v_s + ["sse", "sse_rank"]].copy() + avail_v = hdr + str(avail_yr) + gr_df_base_avail[v_s] = gr_df_base_avail[v_s].div(gr_df_base_avail[avail_v], axis=0) + + ## if there's a PERFERCTLY matching set of growth rates, then just take that + ## country (or those countries') growth rates + if (gr_df_base_avail.sse == 0).any(): + idx = gr_df_base_avail.loc[gr_df_base_avail.sse == 0, :].index.unique() + if len(idx) == 1: + growth_rates = gr_df_base_avail.loc[idx[0], v_s] + else: + growth_rates = gr_df_base_avail.loc[idx, v_s].values.mean(axis=0) + else: + gr_df_base_avail["wgt_vals"] = (1 / gr_df_base_avail["sse"]).values ** wgt_power + denom_values = np.sum(gr_df_base_avail["wgt_vals"].values) + growth_rates = ( + np.sum( + gr_df_base_avail[v_s].mul(gr_df_base_avail["wgt_vals"], axis=0), axis=0 + ) + / denom_values + ) + + avail_val = tgt_df.loc[prob_ctry, avail_v] + extrapolated = np.array(growth_rates) * avail_val + + if after: + extrapolated = extrapolated[1:] + else: + extrapolated = extrapolated[0:-1] + + return extrapolated + + +def extrap_using_closest( + prob_lst, + orig_df, + n_det=5, + wgt_power=1, + begin_end=[1950, 2019], + exclude_these=["MAF", "WLF", "ESH"], + merge_orig=True, + header="v_", + fill_name="msng_fill", + ctry_col="ccode", +): + """Uses the "closest" countries (in terms of existing data's trajectory with + respect to a given year, with the metric for determining "closeness" as the + sum of squared errors [SSE]) whose data are non-missing to figure out the trajectory + of "problematic" (i.e., with missing data) countries. + + Parameters + ---------- + prob_lst : array-like + List of countries whose data are partially missing + n_det : int + Number of "similar countries" to use + wgt_power : float + Whether higher weights should be given to those that are "closer" or not + (higher positive number --> greater weights) + begin_end : array-like of int + The earliest and the last year that need extrapolation + exclude_these : list of str + list of countries to exclude for using as "closest" countries, or to extrapolate + in general; for instance, if a country has only one year's worth of + data (like MAF, WLF, ESH's GDP values) then it would be a good reason to + exclude these countries. + merge_orig : boolean + whether the information from non-problematic countries should be merged + when returning the data back + header : str + for the variables (e.g., "v_" for "v_1950" indicating 1950 values) + fill_name : str + column name for the missing value "fill" information (which years were filled, + using which countries) + ctry_col : str + column name for the country-code variable, default being "ccode" + + Returns + ------- + df_rtn : pandas DataFrame + DataFrame containing extrapolated and existing information countries with + missing values. If merge_orig is True, then it would also contain the countries + without any extrapolated (i.e., the "non-problematic") + + """ + ## indicing for operations below + ctry_msg = "Needs have the country-code column / index `{}` in the dataset" + ctry_msg = ctry_msg.format(ctry_col) + assert (ctry_col in orig_df.index.names) or (ctry_col in orig_df.columns), ctry_msg + + if ctry_col not in orig_df.index.names and ctry_col in orig_df.columns: + df_idxed = orig_df.set_index([ctry_col]) + else: + df_idxed = pd.DataFrame(orig_df) + + ## sorting the problematic (with missing-value) countries for consistency + prob, exclude_these = list(np.sort(prob_lst)), list(exclude_these) + + ## variable names and getting the dataframe of "good-to-go" country codes + v_ = np.sort( + [ + x + for x in orig_df.columns + if (header in x) + and (int(x[-4:]) <= begin_end[1]) + and (int(x[-4:]) >= begin_end[0]) + ] + ) + + ## good_ctries are only those that are absolutely filled + ## excluding those that should be excluded + good_ctries = df_idxed[(~df_idxed[v_].isnull().any(axis=1))].index.unique() + good_ctries = np.setdiff1d(good_ctries, prob + exclude_these) + good_df = df_idxed.loc[good_ctries, :] + good_gr = yearly_growth(good_df, header) + + ## running for each of the problematic countries + df_collection = [] + for i in tqdm(prob): + ## there could be missing values in between known yrs, so interpolate + tgt_df = df_idxed.loc[[i], :].copy() + row_vals = tgt_df.loc[i, v_].copy() + row_vals = np.where(row_vals < 0, np.nan, row_vals) + valid_where = np.where(~pd.isnull(row_vals))[0] + mn_valid_loc, mx_valid_loc = min(valid_where), max(valid_where) + v_valid = v_[mn_valid_loc : mx_valid_loc + 1] + if len(valid_where) != (mx_valid_loc + 1 - mn_valid_loc): + log_interp_vals = np.interp( + range(mn_valid_loc, mx_valid_loc + 1), + valid_where, + np.log( + tgt_df.loc[i, np.array(v_)[valid_where]].values.astype("float64") + ), + ) + tgt_df[v_valid] = np.exp(log_interp_vals) + row_valid = tgt_df.loc[i, v_valid] + + ## as yearly growth rates, with missing values filled as 0 + tgt_gr = yearly_growth(tgt_df).fillna(0) + + ## detecting which is the valid (or non-missing) growth rates + gr_row_valid = tgt_gr.loc[i, v_valid].values + + ## subtract the problematic growth rates from good-to-go growth rates, + ## and calculate the sum of squared errors to detect which is the closest + sse_df = good_gr.copy() + sse_df["sse"] = (sse_df[v_valid].sub(gr_row_valid, axis=1) ** 2).sum(axis=1) + sse_df.sort_values(["sse"], inplace=True) + sse_df["sse_rank"] = range(0, sse_df.shape[0]) + + ## top n closest in terms of trajectory + necess_sse_df = sse_df[sse_df.sse_rank < n_det][["sse", "sse_rank"]] + necess_sse_df = necess_sse_df.merge( + good_df[v_], + how="left", + left_index=True, + right_index=True, + ) + + ## if need to project backwards in time + rtn_row, past_fill, fut_fill = np.array(row_valid), None, None + if v_valid[0] != v_[0]: + avail_yr, earl_yr = int(v_valid[0][-4:]), begin_end[0] + past_vals = helper_extrap_using_closest( + i, + False, + avail_yr, + earl_yr, + tgt_df, + necess_sse_df, + wgt_power, + hdr=header, + ) + rtn_row = np.hstack([past_vals, rtn_row]) + past_fill = "{}-{}".format(earl_yr, avail_yr - 1) + + ## if need to project forward in time + if v_valid[-1] != v_[-1]: + avail_yr, late_yr = int(v_valid[-1][-4:]), begin_end[-1] + fut_vals = helper_extrap_using_closest( + i, + True, + avail_yr, + late_yr, + tgt_df, + necess_sse_df, + wgt_power, + hdr=header, + ) + rtn_row = np.hstack([rtn_row, fut_vals]) + fut_fill = "{}-{}".format(avail_yr + 1, late_yr) + + ## extrapolation information as "fill_info" + used_ccodes, fill_info = ",".join(list(necess_sse_df.index.unique())), "-" + if (past_fill is not None) and (fut_fill is not None): + fill_info = past_fill + "," + fut_fill + ":" + used_ccodes + elif past_fill is not None: + fill_info = past_fill + ":" + used_ccodes + elif fut_fill is not None: + fill_info = fut_fill + ":" + used_ccodes + + tgt_df_extrap = tgt_df.copy() + tgt_df_extrap[v_] = rtn_row + tgt_df_extrap[fill_name] = fill_info + df_collection.append(tgt_df_extrap) + + rtn_df = pd.concat(df_collection, axis=0) + + if merge_orig: + unaltered = np.setdiff1d( + orig_df.index.get_level_values("ccode").unique(), + rtn_df.index.get_level_values("ccode").unique(), + ) + orig_slice = orig_df.loc[unaltered, :].copy() + orig_slice[fill_name] = "-" + rtn_df = pd.concat([rtn_df, orig_slice], axis=0).sort_index() + + return rtn_df + + +def organize_hor_to_ver( + df, + main_cat, + sub_cats, + new_vname, + hdr="v_", + yrs=range(1950, 2020), + timename="year", +): + """Use for organizing wide-format panel data ("horizontal") to long-format panel + data ("vertical"). Serves as a wrapper for the function `pandas.wide_to_long`, but + repurposed for our workflow (mostly in terms of renaming the variables) + + Note: For every row of the "input" dataframe `df`, we assume that there is at most + one combination of the categories in `catnames`; for instance, if `catname` + is equal to ["ccode", "ssp", "iam"], we expect that there should be at most + one account for each countrycode-SSP-IAM combination. + + Parameters + ---------- + df : pandas DataFrame + dataframe containing information, that is in a "wide-format" + main_cat : str + name of the main category we want organize by (e.g., "ccode" for country-codes) + sub_cats : array-like of str or None + list or array containing the names of additional categories we want to organize + by (e.g., ["ssp", "iam"]); if equals to None, then is understood as an empty + array + new_vname : str + name of the variable to be newly assigned + hdr : str + current "header" of the columns in wide-format (e.g., "v_" would + mean that v_1950, v_1951, v_1952,... are the column names) + yrs : array-like of int + years to consider + timename : str + what to call the part of the index + + Returns + ------- + long_df : pandas DataFrame + containing the data in long-panel (or vertical) format + + """ + + if sub_cats is None: + sub_cats = [] + cats = np.hstack([[main_cat], sub_cats]) + reorder = np.hstack([[main_cat, timename], sub_cats]) + + ## resetting the index to be compliant with `pandas.wide_to_long` + df_reind = df.reset_index() + if df.index.names is None: + df_reind.drop(["index"], axis=1, inplace=True) + v_s = np.intersect1d([hdr + str(x) for x in yrs], df_reind.columns) + df_reind = df_reind[np.hstack([[x for x in df_reind.columns if hdr not in x], v_s])] + + long_df = pd.wide_to_long(df_reind, hdr, cats, timename).reset_index() + long_df.set_index(list(reorder), inplace=True) + long_df.sort_index(axis=0, inplace=True) + long_df.rename(columns={hdr: new_vname}, inplace=True) + + return long_df + + +def organize_ver_to_hor( + df, + varname, + timename, + ccodename, + total_yrs=range(1950, 2020), + impose_total=False, +): + """For organizing a "vertical dataframe" (or long-panel form data) to "horizontal + dataframe" (or wide-panel format data). Mainly works as a wrapper for pandas.pivot + but repurposed for our purposes (including re-naming the columns) + + Parameters + ---------- + df : pandas DataFrame + dataframe containing information + varname : str + column name of the variable that we want the information about + timename : str + column name of the variable that indicates time or years + ccodename : str + column name of the variable indicating country-codes + total_yrs : array-like + range of the years that we want information about + impose_total : boolean + if True, all years in the `total_yrs` array are represented (even if missing + entirely from the dataset); if False, then only necessary columns are reported + (with at least some non-missing values) + + Returns + ------- + df_rtn : pandas.DataFrame + :py:class:`pandas.DataFrame` containing information specifically about the + variable indicated by "varname", in a wide-panel format. + + """ + + ## necessary to reset the index to pass to pandas.pivot + df_rtn = df.reset_index() + names = np.array([varname, timename, ccodename]) + assert len(np.setdiff1d(names, df_rtn.columns)) == 0, "necessary columns missing." + + df_rtn.sort_values([ccodename, timename], inplace=True) + df_rtn = df_rtn.pivot(index=[ccodename], columns=timename, values=varname) + df_rtn.columns.name = None + df_rtn.columns = ["v_" + str(x) for x in df_rtn.columns] + total_v = ["v_" + str(x) for x in total_yrs] + + df_rtn = df_rtn[[v for v in total_v if v in df_rtn.columns]] + if impose_total: + leftovers = np.setdiff1d(total_v, df_rtn.columns) + df_rtn[leftovers] = np.nan + df_rtn = df_rtn[total_v] + + return df_rtn + + +def ppp_conversion_specific_year( + yr, + to=True, + extrap_sim=True, + fill_msng_ctries=PPP_CCODE_IF_MSNG, + pwtvar="pl_gdpo", +): + """Given a specified year (`yr`), creates a table of PPP conversion factors either + to that year (to=True) or from that year (to=False). The range of years to + convert from or to that year is fixed to 1950-2019, which is all the available + years from Penn World Tables. We can specify the `pwtvar` variable to change + whether we would like to use a different price level variable (e.g., `pl_n` for + capital, `pl_gdpo` for output-side GDP). + + Parameters + ---------- + yr : int + specific year that we will calculate PPP conversion rates to or from + to : boolean + boolean for indicating if the target year is the year that one should calculate + the years from (`to`=False) or to (`to`=True). e.g., if yr=2019 and to=True, + this function will calculate the conversion rates from 2019 PPP to PPP of any + year between 1950 and 2019 (but NOT change the base dollar terms) + extrap_sim : boolean + boolean for whether to extrapolate or not, for countries having partial + information (i.e., not all conversion rates for 1950-2019). + fill_msng_ctries : None or dict + indicates if we should fill in for those countries that are either entirely + missing from both WDI and PWT datasets or has too much unreliable / missing + data + pwtvar : str + the name of the price level variable to calculate PPP conversion rates from + for PWT. + + Outputs + ------- + pl_ver : pandas DataFrame + containing countrycode, year, and conversion rates (PPP); information organized + in a vertical (long-panel) format, with extrapolation done for the specified + variable when there are missing variables if `extrap_sim` is equal to True. + + """ + + print("Fetching information from PWT...") + ## reading in the necessary PWT dataframe + pwt = ( + pd.read_excel(PATH_PWT_RAW) + .rename(columns={"countrycode": "ccode"}) + .set_index(["ccode", "year"]) + ) + pwt_years = pwt.index.get_level_values("year").unique() + yr_range = range(pwt_years.min(), pwt_years.max() + 1) + + v_ = ["v_" + str(v) for v in yr_range] + pl = organize_ver_to_hor(pwt, pwtvar, "year", "ccode", yr_range) + pl_ccode = pl.index.get_level_values("ccode").unique() + + ## replace with pl_gdpo information if specific pl values for a country are + ## missing entirely + if pwtvar != "pl_gdpo": + pl_gdpo = organize_ver_to_hor(pwt, "pl_gdpo", "year", "ccode", yr_range) + for c in pl_ccode: + row = pl.loc[c, v_].values + if sum(pd.isnull(row)) == len(row): + pl.loc[c, v_] = pl_gdpo.loc[c, v_].values + + if extrap_sim: + prob = ( + pl.loc[pl[v_].isnull().any(axis=1), :] + .index.get_level_values("ccode") + .unique() + ) + pl = extrap_using_closest(prob, pl, exclude_these=[]) + + pl_ver = organize_hor_to_ver(pl, "ccode", None, pwtvar, yrs=yr_range) + fill_name = "{}_fill".format(pwtvar) + pl_ver.rename(columns={"msng_fill": fill_name}, inplace=True) + pl_ver[fill_name] = [v.split(":")[-1] for v in pl_ver[fill_name]] + + ## making sure that the fill-information is "-" if information was not missing + pl_ver = pl_ver.merge( + pwt[[pwtvar]].rename(columns={pwtvar: "temp"}), + left_index=True, + right_index=True, + how="left", + ) + pl_ver.loc[~pd.isnull(pl_ver["temp"]), fill_name] = "-" + pl_ver.drop(["temp"], axis=1, inplace=True) + + else: + pl_ver = organize_hor_to_ver(pl, "ccode", None, pwtvar, yrs=yr_range) + + ## taking care of the case of Bermuda, since it is sometimes suffering + ## from negative price levels + if (pwtvar == "pl_gdpo") and ("BMU" in pl_ccode): + pl_ccode = np.setdiff1d(pl_ccode, ["BMU"]) + bmu_copy = pl_ver.loc[("GBR", slice(None)), :].reset_index().copy() + bmu_copy[fill_name] = "copy_from_GBR" + bmu_copy["ccode"] = "BMU" + bmu_copy.set_index(["ccode", "year"], inplace=True) + pl_ver = pd.concat([pl_ver.loc[(pl_ccode, slice(None)), :], bmu_copy], axis=0) + + ## merging the "base" price level, which is that of the US + pwt_ppp = pl_ver.merge( + ( + pl_ver.loc[("USA", slice(None)), [pwtvar]] + .reset_index() + .drop(["ccode"], axis=1) + .set_index(["year"]) + .rename(columns={pwtvar: "base"}) + ), + left_index=True, + right_index=True, + how="left", + ) + + ## note that according to Feenstra et al. (2015), PPP / XR = pl / pl_base + ## with the "base" again being the United States; `ppp` below is PPP / XR + pwt_ppp["ppp"] = pwt_ppp[pwtvar] / pwt_ppp["base"] + + ## multiplying `ppp` can be understood as turning PPP-adjusted value of a certain + ## year to nominal value; turning base-year-a PPP values to base-year-b PPP values + ## therefore requires multiplying `ppp`(a) / `ppp`(b) + tgtyr_ppp = f"ppp_{yr}" + pwt_ppp = pwt_ppp.merge( + ( + pwt_ppp.loc[(slice(None), yr), ["ppp"]] + .rename(columns={"ppp": tgtyr_ppp}) + .reset_index() + .drop(["year"], axis=1) + .set_index(["ccode"]) + ), + left_index=True, + right_index=True, + how="left", + ) + + ## conversion rates + if to: + pwt_ppp["conv"] = pwt_ppp["ppp"] / pwt_ppp[tgtyr_ppp] + else: + pwt_ppp["conv"] = pwt_ppp[tgtyr_ppp] / pwt_ppp["ppp"] + pwt_ppp.drop([tgtyr_ppp], axis=1, inplace=True) + + to_keep = [] + for i in pwt_ppp.index.get_level_values("ccode").unique(): + i_case = pwt_ppp.loc[i, "conv"].isnull().all() + if not i_case: + to_keep.append(i) + + pwt_ppp = pwt_ppp.loc[(to_keep, slice(None)), :].sort_index() + + ## filling in the missing countries with known values + if fill_msng_ctries is not None: + print("Filling in the missing countries...") + pwt_ppp["conv_fill"] = "refer_to_other_cols" + + for key, replace_these in fill_msng_ctries.items(): + conv_fill_key = "copy_from_{}".format(key) + no_replace_these_ccodes = np.setdiff1d( + pwt_ppp.index.get_level_values("ccode").unique(), replace_these + ) + pwt_ppp = pwt_ppp.loc[(no_replace_these_ccodes, slice(None)), :] + + copies = [pwt_ppp] + for rep_ctry in replace_these: + ctry_copied = pwt_ppp.loc[(key, slice(None)), :].copy().reset_index() + ctry_copied["ccode"] = rep_ctry + ctry_copied["conv_fill"] = conv_fill_key + ctry_copied.set_index(["ccode", "year"], inplace=True) + copies.append(ctry_copied) + pwt_ppp = pd.concat(copies, axis=0) + + pwt_ppp = pwt_ppp[["conv", "conv_fill", fill_name]].copy() + pwt_ppp.sort_index(inplace=True) + print("...done") + + return pwt_ppp + + +def smooth_fill( + da1_in, + da2_in, + fill_all_null=True, + time_dim="time", + other_dim="storm", +): + """Fill values from 2D dataarray `da1_in` with values from 2D dataarray + `da2_in`. + + For instance, one may use this with storm datasets. If filling the beginning or end + of a storm, pin the `da2_in` value to the `da1_in` value at the first/last point of + overlap and then use the `da2_in` values only to estimate the "change" in values + over time, using a ratio of predicted value in the desired time to the reference + time. This can also be used when, for example, `da1_in` refers to RMW and `da2_in` + refers to ROCI. In this case, you want to define ``fill_all_null=False`` to avoid + filling RMW with ROCI when no RMW values are available but some ROCI values are + available. + + Parameters + ---------- + da1_in, da2_in : xarray.DataArray + DataArrays indexed by other dimension (defined by `other_dim`) and time + dimension (defined by `time_dim`) + fill_all_null : bool, optional + If True, fills even when there are no known (or non-NA) values in `da1_in` + time_dim : str, optional + variable name to indicate the time dimension, default set to be "time" + other_dim : str, optional + variable name to indicate the other dimension, default set to be "storm" but + can also indicate country or region names, for instance + + Returns + ------- + :class:`xarray.DataArray` + Same as ``da1`` but with NaN's filled by the described algorithm. + + Raises + ------ + AssertionError : + If there are "interior" NaN's in either dataset, i.e. if any storm has a NaN + after the first non-NaN but before the last non-NaN. These should have + previously been interpolated. + + Examples + -------- + >>> import xarray as xr + >>> da1 = xr.DataArray( + ... np.array( + ... [ + ... [np.nan, 1, 2, 3], + ... [np.nan, np.nan, 4, 5], + ... [6, 7, np.nan, np.nan], + ... [8, 9, 10, np.nan], + ... [11, 12, 13, 14], + ... [np.nan, np.nan, np.nan, np.nan], + ... ] + ... ), + ... coords = {"storm": range(6), "time": range(4)}, + ... dims = ["storm", "time"] + ... ) + >>> da2 = xr.DataArray( + ... np.array( + ... [ + ... [15, 16, 17, 18], + ... [19, 20, 21, 22], + ... [23, 24, 25, 26], + ... [27, 28, 29, 30], + ... [31, 32, 33, 34], + ... [35, 36, 37, 38], + ... ] + ... ), + ... coords = {"storm": range(6), "time": range(4)}, + ... dims = ["storm", "time"] + ... ) + >>> smooth_fill(da1, da2) + + array([[ 0.9375 , 1. , 2. , 3. ], + [ 3.61904762, 3.80952381, 4. , 5. ], + [ 6. , 7. , 7.29166667, 7.58333333], + [ 8. , 9. , 10. , 10.34482759], + [11. , 12. , 13. , 14. ], + [35. , 36. , 37. , 38. ]]) + Coordinates: + * storm (storm) int64 0 1 2 3 4 5 + * time (time) int64 0 1 2 3 + """ + + da1 = da1_in.copy() + da2 = da2_in.copy() + either_non_null = da1.notnull() | da2.notnull() + + da1 = da1.interpolate_na(dim=time_dim, use_coordinate=True) + da2 = da2.interpolate_na(dim=time_dim, use_coordinate=True) + for da in [da1, da2]: + assert da.interpolate_na(dim=time_dim).notnull().sum() == da.notnull().sum() + + adjust = da1.reindex({other_dim: da2[other_dim]}) + first_valid_index = (adjust.notnull() & da2.notnull()).argmax(dim=time_dim) + last_valid_index = ( + adjust.bfill(time_dim).isnull() | da2.bfill(time_dim).isnull() + ).argmax(dim=time_dim) - 1 + + all_null = adjust.isnull().all(dim=time_dim) + if not fill_all_null: + all_null *= False + + est_to_obs_rat_first = adjust.isel({time_dim: first_valid_index}) / da2.isel( + {time_dim: first_valid_index} + ) + + est_val = da2.where( + all_null | adjust.ffill(time_dim).notnull(), + da2 * est_to_obs_rat_first, + ) + + est_to_obs_rat_last = adjust.isel({time_dim: last_valid_index}) / da2.isel( + {time_dim: last_valid_index} + ) + + est_val = est_val.where( + all_null | adjust.bfill(time_dim).notnull(), + da2 * est_to_obs_rat_last, + ) + + # fill storms with da1 vals using the full da2 time series. For storms with some da1 + # vals, fill the tails using da2 scaled so that it matches at the first and last + # points seen in both da1 and da2 + out = da1.fillna(est_val) + + # make sure we didn't add vals + return out.where(either_non_null) + + +def minimize_simple_production(x, K_values, Y_values): + """Helper function for getting at the `A` (TFP) and `alpha` (GDP elasticity of + capital). Returns the sum of squared errors with respect to actual GDP values. + + Parameters + ---------- + x : array-like of floats + divided into `A` (TFP) and `alpha` (GDP elasticity of capital) + K_values : array-like of floats + containing historical capital values (in the case of only-capital production + functional form) or historical per-capita capital values (in the case of Cobb- + Douglas functional form) + Y_values : array-like of floats + containing historical GDP values (in the case of only-capital production + functional form) or historical per-capita GDP values (in the case of Cobb- + Douglas functional form) + + Returns + ------- + sse : float + Sum of squared errors from netting the actual GDP values from estimated + GDP values assuming a functional form + + """ + A, alpha = x + + diff = A * (K_values**alpha) - Y_values + sse = np.sum(diff**2) + + return sse + + +def MPK_init_calc( + ccode, + hist_df, + base2010_df, + alpha_overall, + hist_YKP=["rgdpna_19", "rnna_19", "pop"], + base_YKP=["gdp", "capital", "pop"], + init_A_alpha=[100, 1], +): + """Function for calculating the value of MPK (marginal product of capital) of the + country specified by `ccode` and in the year specified by `year`. + Parameters + ---------- + ccode : str + country code of the country we need to calculate the MPK for + hist_df : pandas.DataFrame + dataframe containing historical (1950-2020) information on GDP, capital stock, + and population; should contain the column names in `hist_YKP`. Note that its + values are in millions (of dollars for GDP and capital, of people + for population) + base2010_df : pandas.DataFrame + dataframe containing projected 2010 information on GDP and population and + baseline 2010 historical capital stock information; should contain the column + names in `base_YKP` + alpha_overall : array-like of floats + should contain elasticities of GDP w.r.t. capital values that have been pre- + calculated; two elements, the former being our own calculation of the elasticity + and the latter being the elasticity calculated in Crespo Cuaresma (2017) + hist_YKP : array-like of str + column names (of `hist_df`) in the following order: constant PPP GDP + variable, constant PPP capital stock variable, and population variable + base_YKP : array-like of str + column names (of `base2010_df`) in the following order: constant PPP GDP + variable, constant PPP capital stock variable, and population variable + init_A_alpha : array-like of floats + points of initialization for `A` (TFP) and `alpha` (elasticity of GDP w.r.t. + capital) + + Returns + ------- + MPK_overall_our, MPK_overall_iiasa, MPK_country_pc, MPK_country : tuple of floats + calculated MPKs using different versions of the GDP elasticity w.r.t. capital, + first - using our self-calculated elasticity, + second - using the Crespo Cuaresma (2017) elasticity, + third - using the country-specific elasticity assuming Cobb-Douglass function, + fourth - using the country-specific elasticity assuming capital-only function + + """ + + # Y, K, pop values of the years that we want to examine + histccodes = hist_df.index.get_level_values("ccode").unique() + baseccodes = base2010_df.index.get_level_values("ccode").unique() + msg_error = "`ccode` must be in both `hist_df` and `base2010_df`." + assert (ccode in histccodes) and (ccode in baseccodes), msg_error + + # multiplying 1,000,000 since they are in millions + YKP = hist_df.loc[ccode, hist_YKP].dropna() + Ys = YKP[hist_YKP[0]].values * 1000000 + Ks = YKP[hist_YKP[1]].values * 1000000 + Ps = YKP[hist_YKP[2]].values * 1000000 + + # creating the capital intensity values using projected base 2010 data + yk_df = base2010_df.loc[ + base2010_df.index.get_level_values("ccode") == ccode, : + ].copy() + yk_df = yk_df.reset_index().set_index(["ccode", "ssp", "iam"])[base_YKP] + yk_df["yk"] = yk_df[base_YKP[0]] / yk_df[base_YKP[1]] + + # if all zeros for any of the three variables, no reason to calculate MPK + if (Ys == 0).all() or (Ks == 0).all() or (Ps == 0).all(): + yk_df["mpk_our"], yk_df["mpk_iiasa"] = 0, 0 + yk_df["mpk_ctry_cd"], yk_df["mpk_ctry_co"] = 0, 0 + return yk_df + + # let us sort them in the order of Ks, just in case + KYPs = np.array(sorted(zip(Ks, Ys, Ps))) + Ks, Ys, Ps = KYPs[:, 0], KYPs[:, 1], KYPs[:, 2] + + # optimizing values for A (total factor productivity) and alpha (GDP elasticity + # wrt. capital); capital-only + A_alpha_getter = lambda x: minimize_simple_production(x, Ks, Ys) + A, alpha = opt_min( + A_alpha_getter, init_A_alpha, bounds=((0, np.inf), (0, np.inf)) + ).x + + # optimizing values for A and alpha; Cobb-Douglas + A_alpha_getter = lambda x: minimize_simple_production(x, Ks / Ps, Ys / Ps) + A_pc, alpha_pc = opt_min( + A_alpha_getter, init_A_alpha, bounds=((0, np.inf), (0, np.inf)) + ).x + + # calculating MPK values based on the above A and alpha calculations + yk_df["mpk_our"] = alpha_overall[0] * yk_df["yk"] + yk_df["mpk_iiasa"] = alpha_overall[-1] * yk_df["yk"] + yk_df["mpk_ctry_cd"] = alpha_pc * yk_df["yk"] + yk_df["mpk_ctry_co"] = alpha * yk_df["yk"] + + return yk_df + + +def pim_single_ctry( + ccode_df, + MPK_init, + alpha_overall, + MPK_var="mpk_our", + scenarios=SCENARIOS, + yr_startend=[2010, 2100], + MPK_bar=0.1, + gamma_MPK=0.985, + gamma_I=0.98, + Yvar="gdp", + Kvar="capital", + iy_var="iy_ratio", + depre_overall_var="delta", + depre_ctry_var="delta_c", +): + """Function for running the perpetual inventory method (PIM, as described in + Dellink et al., 2017), for a specific country, for each SSP-IAM scenario. + + ---------- + ccode_df : pandas.DataFrame + DataFrame containing country-specific information for conducting the by-country + PIM process to acquire capital stock projections. Needs to contain `Yvar`, + `Kvar`, with indices `ccode`, `year`, `ssp`, and `iam`. + MPK_init : pandas.DataFrame + DataFrame containing initial-year marginal product of capital. Also should + contain depreciation rates; so should contain `MPK_var`, `depre_overall_var`, + `iy_var`, and `depre_ctry_var` and with index `ccode`, `ssp`, and `iam` + alpha_overall : float + elasticity of GDP w.r.t. capital, global and not country-specific + MPK_var : str + column name for the initial-year marginal product of capital + scenarios : array-like of tuples of str + array-like of tuples containing SSP and IAM (in that order) scenarios + yr_startend : array-like of ints + starting year and end year of projection + MPK_bar : float + long-term elasticity of GDP w.r.t. capital, value 0.1 taken from Dellink et al. + (2017) + gamma_MPK : float + velocity of converging to long-term elasticity of GDP w.r.t. capital, value + 0.985 taken from Dellink et al. (2017) + gamma_I : float + velocity of converging to long-term investment-to-GDP ratio, value 0.98 taken + from Dellink et al. (2017) + Yvar : str + column name of the constant PPP GDP variable + Kvar : str + column name of the (initial-year) constant PPP capital stock variable + iy_var : str + column name of the (initial-year) investment-to-GDP variable + depre_overall_var : str + depreciation rate variable (over all countries) + depre_ctry_var : str + country-specific depreciation rate variable + + Returns + ------- + ccode_df : pandas.DataFrame + DataFrame containing the updated values of capital stock projection estimates + + """ + newvar = "{}_estim".format(Kvar) + ccode = ccode_df.index.get_level_values("ccode").values[0] + + ## delta is same across all scenarios + delta, delta_r = MPK_init.loc[ + (ccode, "SSP1", "OECD"), [depre_overall_var, depre_ctry_var] + ].values + + ccode_df["MPK"], ccode_df["IY"] = np.nan, np.nan + ccode_df[newvar], ccode_df["KY"] = np.nan, np.nan + for yr in range(yr_startend[0], yr_startend[-1] + 1): + for scen in scenarios: + ## advancing MPK values annually + ssp, iam = scen + if yr == yr_startend[0]: + MPK = MPK_init.loc[(ccode, ssp, iam), MPK_var] + else: + prev_MPK = ccode_df.loc[(ccode, yr - 1, ssp, iam), "MPK"] + MPK = gamma_MPK * prev_MPK + (1 - gamma_MPK) * MPK_bar + ccode_df.loc[(slice(None), yr, ssp, iam), "MPK"] = MPK + ky_LT = alpha_overall / MPK + + ## year-to-year GDP growth rates + if yr != yr_startend[-1]: + g_Ys = ccode_df.loc[(ccode, [yr, yr + 1], ssp, iam), Yvar].values + Y_yr = g_Ys[0] + else: + g_Ys = ccode_df.loc[(ccode, [yr - 1, yr], ssp, iam), Yvar].values + Y_yr = g_Ys[1] + g_Y = g_Ys[-1] / g_Ys[0] - 1 + + ## long-run I-to-Y ratio + iy_LT = (g_Y + delta) * ky_LT + + ## I-to-Y ratios time series + if yr == yr_startend[0]: + IY = MPK_init.loc[(ccode, ssp, iam), iy_var] + else: + prev_IY = ccode_df.loc[(ccode, yr - 1, ssp, iam), "IY"] + IY = (gamma_I * prev_IY) + (1 - gamma_I) * iy_LT + ccode_df.loc[(slice(None), yr, ssp, iam), "IY"] = IY + + ## Perpetual inventory method capital stock time series + if yr == yr_startend[0]: + K_yr = MPK_init.loc[(ccode, ssp, iam), Kvar] + else: + prev_K = ccode_df.loc[(ccode, yr - 1, ssp, iam), newvar] + K_yr = (1 - delta_r) * prev_K + IY * Y_yr + ccode_df.loc[(slice(None), yr, ssp, iam), newvar] = K_yr + ccode_df.loc[(slice(None), yr, ssp, iam), "KY"] = K_yr / Y_yr + + return ccode_df + + +def examine_against_fig6(pim_df, intensity="KY", fig_size=(18, 9)): + """ + Function to examine the estimated capital intensity (the variable `intensity` in the + DataFrame `pim_df`) against the Dellink et al. (2017) output of the same variable + for four countries Tanzania, India, China, and the United States (shown in Fig. 6 of + the paper). Also calculates the SSE across own estimates and Dellink et al. (2017)'s + numbers. + + Parameters + ---------- + pim_df : pandas DataFrame + containing the `intensity` variable; should have indices `ccode`, `year`, + `ssp`, and `iam` (in that order) + intensity : str + capital intensity variable in `pim_df` + fig_size : tuple of floats or ints + to set the output figure size + + Returns + ------- + sse : float + SSE (w.r.t. Dellink et al. (2017) Figure 6) calculated + also, presents the bar graphs (containing capital intensity values from data) + plotted in comparison to Dellink et al. (2017) Figure 6 + + """ + + FOUR_CTRIES = ["TZA", "IND", "CHN", "USA"] + SSP = ["SSP{}".format(x) for x in range(5, 0, -1)] + FIG_YRS = [2100, 2050, 2020] + + ## preparing the figures + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 9)) + which = np.arange(0.1, 15 * 0.5 + 0.1, 0.5) + which = which + np.array(range(0, len(which))) * 0.1 + + ## from Dellink et al. (2017); had to measure the figure with a ruler + ky_cm = 3 / 6.525 + dellink_case = pd.DataFrame( + list(lstprod(*[FOUR_CTRIES, FIG_YRS, SSP])), columns=["ccode", "year", "ssp"] + ) + dellink_case[intensity] = np.nan + dellink_case["year"] = dellink_case["year"].astype("int64") + dellink_case.set_index(["ccode", "year", "ssp"], inplace=True) + + ## Values from Figure 6, in the order of SSP5 -> SSP1 and 2100, 2050, 2020 + TZN = [ + np.array([6.2, 4.45, 4.4]) * ky_cm, + np.array([6.95, 6.1, 4.475]) * ky_cm, + np.array([6.25, 5.675, 4.5]) * ky_cm, + np.array([5.95, 5.175, 4.45]) * ky_cm, + np.array([6.25, 4.65, 4.45]) * ky_cm, + ] + IND = [ + np.array([7.4, 5.7, 5.75]) * ky_cm, + np.array([7.575, 6.7, 5.8]) * ky_cm, + np.array([7.65, 7.45, 5.85]) * ky_cm, + np.array([7.3, 6.525, 5.775]) * ky_cm, + np.array([7.6, 5.95, 5.75]) * ky_cm, + ] + CHN = [ + np.array([9.9, 8.45, 6.35]) * ky_cm, + np.array([10.25, 9.55, 6.475]) * ky_cm, + np.array([9.8, 10.55, 6.525]) * ky_cm, + np.array([9.6, 9.55, 6.45]) * ky_cm, + np.array([10.45, 8.8, 6.4]) * ky_cm, + ] + USA = [ + np.array([6.25, 5.4, 5.05]) * ky_cm, + np.array([6.75, 5.9, 5.1]) * ky_cm, + np.array([7.275, 6.325, 5.15]) * ky_cm, + np.array([6.9, 6.05, 5.1]) * ky_cm, + np.array([6.65, 5.8, 5.1]) * ky_cm, + ] + for i, ct in enumerate([TZN, IND, CHN, USA]): + ctry = FOUR_CTRIES[i] + for j, row in enumerate(ct): + ssp = SSP[j] + dellink_case.loc[(ctry, FIG_YRS, ssp), intensity] = row + + labs = [] + for j, ssp in enumerate(SSP): + labs += ["2100", "{} 2050".format(ssp), "2020"] + + ax1.set_yticks(which + 0.15) + ax1.set_yticklabels(labs) + dellink_vals = [] + for l, ctry in enumerate(FOUR_CTRIES): + ctry_vals = [] + for ssp in SSP: + ctry_vals += list(dellink_case.loc[(ctry, FIG_YRS, ssp), intensity].values) + ax1.barh(which + l * 0.1, ctry_vals, height=0.1, label=ctry) + dellink_vals += ctry_vals + ax1.legend() + ax1.set_title("Capital intensities for selected countries, Dellink et al. (2017)") + + ax2.set_yticks(which + 0.15) + ax2.set_yticklabels(labs) + our_vals = [] + for l, ctry in enumerate(FOUR_CTRIES): + ctry_vals = [] + for ssp in SSP: + ctry_vals += list( + pim_df.loc[(ctry, FIG_YRS, ssp, "OECD"), intensity].values + ) + ax2.barh(which + l * 0.1, ctry_vals, height=0.1, label=ctry) + our_vals += ctry_vals + mx = max(our_vals + dellink_vals) + ax_set = np.linspace(0, np.ceil(mx), 5) + sse = ((np.array(our_vals) - np.array(dellink_vals)) ** 2).sum() + sser = round(sse, 3) + + ax1.set_xticks(ax_set) + ax2.set_xticks(ax_set) + + ax2.legend() + ax2.set_title("Capital intensities, our own replication using the OECD method") + + fig.suptitle("Comparison of capital intensities; SSE={}".format(sser), fontsize=12) + fig.show() + + return sse + + +def top_bottom_10(df, yr=2100, ssp="SSP3", capvar="capital_estim"): + """Shows the top ten and bottom ten according to `capvar` in the DataFrame `df` + in the year `yr` and the SSP `ssp`; figures for IIASA and OECD IAMs are drawn + separately. + + Parameters + ---------- + df : pandas DataFrame + containing `capvar` variable, with indices `ccode`, `year`, + `ssp`, and `iam` (in that order) + yr : int + year in which we would like to compare the `capvar` values across countries + ssp : str + SSP scenario that we would like to examine + capvar : str + the name of the variable to produce top 10 and bottom 10 countries from + + Returns + ------- + None, but presents the top 10 and bottom 10 countries by IAMs in bar graphs + + """ + + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 14)) + + iiasa_df = df.loc[(slice(None), yr, ssp, "IIASA"), [capvar]].copy() + iiasa_df.sort_values([capvar], inplace=True) + iiasa_sma = iiasa_df.index.get_level_values("ccode")[0:10] + iiasa_sma_vals = np.log(iiasa_df[capvar].values[0:10]) + + small = list(range(1, 11)) + ax1.barh(small, iiasa_sma_vals, label="Bottom 10", color="orange", height=0.8) + ax1.set_yticks(small) + ax1.set_yticklabels(iiasa_sma) + + iiasa_big = iiasa_df.index.get_level_values("ccode")[-10:] + iiasa_big_vals = np.log(iiasa_df[capvar].values[-10:]) + + big = list(range(11, 21)) + ax1.barh(big, iiasa_big_vals, label="Top 10", color="#87CEEB", height=0.8) + ax1.set_yticks(small + big) + ax1.set_yticklabels(np.hstack([iiasa_sma, iiasa_big])) + fig.suptitle("Log of capital stock in the year {} and {} scenario".format(yr, ssp)) + ax1.set_title("Case for IIASA") + ax1.set_xlabel("Log of millions of dollars") + + oecd_df = df.loc[(slice(None), yr, ssp, "OECD"), [capvar]].copy() + oecd_df.sort_values([capvar], inplace=True) + oecd_sma = oecd_df.index.get_level_values("ccode")[0:10] + oecd_sma_vals = np.log(oecd_df[capvar].values[0:10]) + + ax2.barh(small, oecd_sma_vals, label="Bottom 10", color="orange", height=0.8) + ax2.set_yticks(small) + ax2.set_yticklabels(oecd_sma) + + oecd_big = oecd_df.index.get_level_values("ccode")[-10:] + oecd_big_vals = np.log(oecd_df[capvar].values[-10:]) + + ax2.barh(big, oecd_big_vals, label="Top 10", color="#87CEEB", height=0.8) + ax2.set_yticks(small + big) + ax2.set_yticklabels(np.hstack([oecd_sma, oecd_big])) + ax2.set_title("Case for OECD") + ax2.set_xlabel("Log of millions of dollars") + + fig.show() + + return None diff --git a/sliiders/dask.py b/sliiders/dask.py new file mode 100644 index 0000000..9c0113b --- /dev/null +++ b/sliiders/dask.py @@ -0,0 +1,19 @@ +import os +import zipfile + +from dask.utils import tmpfile + + +def upload_pkg(client, pkg_dir): + with tmpfile(extension="zip") as f: + zipf = zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) + for root, dirs, files in os.walk(pkg_dir): + for file in files: + zipf.write( + os.path.join(root, file), + os.path.relpath( + os.path.join(root, file), os.path.join(pkg_dir, "..") + ), + ) + zipf.close() + client.upload_file(f) diff --git a/sliiders/gcs.py b/sliiders/gcs.py new file mode 100644 index 0000000..695237a --- /dev/null +++ b/sliiders/gcs.py @@ -0,0 +1,56 @@ +from pathlib import Path + +import gcsfs + +# in CI, no access to creds so we need to handle this case +try: + FS = gcsfs.GCSFileSystem( + project="rhg-data", token="/opt/gcsfuse_tokens/rhg-data.json" + ) +except FileNotFoundError: + FS = None + +import gcsfs + +# in CI, no access to creds so we need to handle this case +try: + FS = gcsfs.GCSFileSystem( + project="rhg-data", token="/opt/gcsfuse_tokens/rhg-data.json" + ) +except FileNotFoundError: + FS = None + + +def fuse_to_gcsmap(path, fs=FS): + """Convert a path using the gcs FUSE file system into a mapper that can be used + for a zarr store. + + Parameters + ---------- + path : str or :class:`pathlib.Path` + Path on GCS FUSE (i.e. starts with ``/gcs/``) + fs : `:class:`gcsfs.GCSFileSystem` + If None, will just return the path on GCS + Returns + ------- + :class:`fsspec.mapping.FSMap` + Mapper to object store + """ + + # handle when fs is null by just returning the GCSFUSE path + if fs is None: + return Path(path) + + return fs.get_mapper("/".join(Path(path).parts[2:]), check=False) + + +def gcsmap_to_fuse(gcsmap): + return Path("/gcs", gcsmap.root) + + +def fuse_to_url(path): + return str(path).replace("/gcs/", "gs://") + + +def fuse_to_gspath(path): + return str(path).replace("/gcs/", "") diff --git a/sliiders/io.py b/sliiders/io.py new file mode 100644 index 0000000..a706d17 --- /dev/null +++ b/sliiders/io.py @@ -0,0 +1,66 @@ +import geopandas as gpd +import pandas as pd +from cartopy.io import shapereader + + +def load_adm0_shpfiles(vector_types, resolution_m=10): + """ + Load and return dictionary of geopandas dataframes from the Natural Earth + repository. + + Parameters + ---------- + vector_types : list of strings + each string is a natural earth admin0 vector type. + Vector type options can be found here: + https://www.naturalearthdata.com/downloads/10m-cultural-vectors/ + resolution_m : int + Resolution of file to obtain. Must match one of those available via + Natural Earth + + Returns + ------- + dict of :py:class:`geopandas.Dataframe` + Keys are vector types associated with the geopandas dataframe and values are + Dataframes from the Naturalearth API, loaded from cache if possible. + """ + return_dict = {} + for vector_type in vector_types: + return_dict[vector_type] = gpd.read_file( + shapereader.natural_earth( + resolution=f"{resolution_m}m", + category="cultural", + name="admin_0_{}".format(vector_type), + ) + ) + return return_dict + + +def read_gdf(fpath): + """Reads in the `.gdf` file located at `fpath` into `pandas.DataFrame`, assigns + columns `lon` for longitude, `lat` for latitude, and `z` for data (such as geoid), + then returns a `xarray.DataArray` containing the values of `z` and coordinates + `lon` and `lat`. + + Parameters + ---------- + fpath : pathlib.Path-like + path where the `.gdf` file of interest is located at + + Returns + ------- + xarray.DataArray + containing values of `z` with coordinates `lon` and `lat` + + """ + + return ( + pd.read_table( + fpath, + skiprows=36, + names=["lon", "lat", "z"], + delim_whitespace=True, + ) + .set_index(["lon", "lat"]) + .z.to_xarray() + ) diff --git a/sliiders/settings.py b/sliiders/settings.py new file mode 100644 index 0000000..286759d --- /dev/null +++ b/sliiders/settings.py @@ -0,0 +1,639 @@ +from pathlib import Path + +import numpy as np +import pandas as pd + +from .gcs import FS, fuse_to_gcsmap + +# Versions +GLOBAL_PROTECTED_AREAS_VERS = "v0.2" +LEVEES_VERS = "v0.2" +GPW_VERS = "v4rev11" +LANDSCAN_YEAR = "2019" +LANDSCAN_VERS = f"LandScan Global {LANDSCAN_YEAR}" +GADM_VERS = "gadm36" +LITPOP_VERS = "LitPop_v1_2" +LITPOP_DATESTAMP = "20220118" +GEG15_VERS = "v0.1" +EXPOSURE_BLENDED_VERS = "v0.5" +EXPOSURE_BINNED_VERS = "v0.14" +COUNTRY_LEVEL_TABLE_VERS = "v0.10" +DATUM_CONVERSION_VERS = "v0.3" +SLIIDERS_VERS = "v1.0" +PWT_DATESTAMP = "20220328" +MPD_DATESTAMP = "20220329" +WB_WDI_DATESTAMP = "20220329" +ALAND_STATISTICS_DATESTAMP = "20220329" +GWDB_DATESTAMP = "20220321" +OECD_DATESTAMP = "20220329" +UN_AMA_DATESTAMP = "20220329" +IMF_WEO_VERS = "October_2021" +UN_WPP_VERS = "2019" +IIASA_PROJECTIONS_DOWNLOAD_VERS = "2018" + +# Definitions +SPATIAL_WARNINGS_TO_IGNORE = [ + "CRS mismatch between the CRS", + "Geometry is in a geographic CRS", + "initial implementation of Parquet.", + "Iteration over", + "__len__ for multi-part geometries", + "The array interface is deprecated", + "Only Polygon objects have interior rings", +] + +# SLIIDERS-SLR PARAMS +LOCALIZESL_COREFILES = { + "SLRProjections190726core_SEJ_full": ["L", "H"], + "SLRProjections170113GRIDDEDcore": [None], + "SLRProjections200204GRIDDEDcore_D20": [None], + "SLRProjections210628GRIDDEDcore_SROCC": [None], +} +LOCALIZESL_REV = "c9b020a0f9409cde3f6796ca936f229c90f7d5c6" + +# Aland Islands, Western Sahara, Libya, Palestine, South Sudan, Syria, Kosovo +ISOS_IN_GEG_NOT_LITPOP = ["ALA", "ESH", "LBY", "PSE", "SSD", "SYR", "XKX"] + +# for organizing scenarios +SSP_PROJ_ORG_SER = pd.Series( + { + "SSP1_v9_130219": "SSP1", + "SSP1_v9_130325": "SSP1", + "SSP1_v9_130424": "SSP1", + "SSP1_v9_130115": "SSP1", + "SSP2_v9_130219": "SSP2", + "SSP2_v9_130325": "SSP2", + "SSP2_v9_130424": "SSP2", + "SSP2_v9_130115": "SSP2", + "SSP3_v9_130219": "SSP3", + "SSP3_v9_130325": "SSP3", + "SSP3_v9_130424": "SSP3", + "SSP3_v9_130115": "SSP3", + "SSP4_v9_130219": "SSP4", + "SSP4_v9_130325": "SSP4", + "SSP4_v9_130424": "SSP4", + "SSP4_v9_130115": "SSP4", + "SSP4d_v9_130115": "SSP4", + "SSP5_v9_130219": "SSP5", + "SSP5_v9_130325": "SSP5", + "SSP5_v9_130424": "SSP5", + "SSP5_v9_130115": "SSP5", + "IIASA GDP": "IIASA", + "IIASA-WiC POP": "IIASA-WiC", + "NCAR": "NCAR", + "OECD Env-Growth": "OECD", + "PIK GDP-32": "PIK", + } +) +SCENARIOS = [ + ("SSP1", "OECD"), + ("SSP1", "IIASA"), + ("SSP2", "OECD"), + ("SSP2", "IIASA"), + ("SSP3", "OECD"), + ("SSP3", "IIASA"), + ("SSP4", "OECD"), + ("SSP4", "IIASA"), + ("SSP5", "OECD"), + ("SSP5", "IIASA"), +] + +# country ISO code groupings +EXCLUDED_ISOS = ["ATA", "XCA"] + +FRA_MSNG = [ + "REU", + "WLF", + "ATF", + "SPM", + "AND", + "BLM", + "GLP", + "GUF", + "MAF", + "MCO", + "MTQ", + "MYT", + "NCL", + "PYF", +] +USA_MSNG = [ + "ASM", + "GUM", + "LIE", + "MNP", + "PRK", + "SOM", + "MHL", + "FSM", + "ERI", + "CUB", + "UMI", + "VIR", +] +PPP_CCODE_IF_MSNG = { + "AUS": ["CCK", "CXR", "HMD", "NFK"], + "DNK": ["GRL", "FRO"], + "FRA": FRA_MSNG, + "FIN": ["ALA"], + "ITA": ["VAT", "SMR"], + "USA": USA_MSNG, + "MAR": ["ESH"], + "CUW": ["BES"], + "NZL": ["NIU", "COK", "TKL"], + "NOR": ["BVT", "SJM"], + "GBR": ["IMN", "FLK", "GGY+JEY", "GIB", "PCN", "SGS", "SHN", "GGY", "JEY"], + "ESH": ["MAR"], +} + +PWT_ISOS = [ + "ABW", + "AGO", + "AIA", + "ALB", + "ARE", + "ARG", + "ARM", + "ATG", + "AUS", + "AUT", + "AZE", + "BDI", + "BEL", + "BEN", + "BFA", + "BGD", + "BGR", + "BHR", + "BHS", + "BIH", + "BLR", + "BLZ", + "BMU", + "BOL", + "BRA", + "BRB", + "BRN", + "BTN", + "BWA", + "CAF", + "CAN", + "CHE", + "CHL", + "CHN", + "CIV", + "CMR", + "COD", + "COG", + "COL", + "COM", + "CPV", + "CRI", + "CUW", + "CYM", + "CYP", + "CZE", + "DEU", + "DJI", + "DMA", + "DNK", + "DOM", + "DZA", + "ECU", + "EGY", + "ESP", + "EST", + "ETH", + "FIN", + "FJI", + "FRA", + "GAB", + "GBR", + "GEO", + "GHA", + "GIN", + "GMB", + "GNB", + "GNQ", + "GRC", + "GRD", + "GTM", + "GUY", + "HKG", + "HND", + "HRV", + "HTI", + "HUN", + "IDN", + "IND", + "IRL", + "IRN", + "IRQ", + "ISL", + "ISR", + "ITA", + "JAM", + "JOR", + "JPN", + "KAZ", + "KEN", + "KGZ", + "KHM", + "KNA", + "KOR", + "KWT", + "LAO", + "LBN", + "LBR", + "LCA", + "LKA", + "LSO", + "LTU", + "LUX", + "LVA", + "MAC", + "MAR", + "MDA", + "MDG", + "MDV", + "MEX", + "MKD", + "MLI", + "MLT", + "MMR", + "MNE", + "MNG", + "MOZ", + "MRT", + "MSR", + "MUS", + "MWI", + "MYS", + "NAM", + "NER", + "NGA", + "NIC", + "NLD", + "NOR", + "NPL", + "NZL", + "OMN", + "PAK", + "PAN", + "PER", + "PHL", + "POL", + "PRT", + "PRY", + "PSE", + "QAT", + "ROU", + "RUS", + "RWA", + "SAU", + "SDN", + "SEN", + "SGP", + "SLE", + "SLV", + "SRB", + "STP", + "SUR", + "SVK", + "SVN", + "SWE", + "SWZ", + "SXM", + "SYC", + "SYR", + "TCA", + "TCD", + "TGO", + "THA", + "TJK", + "TKM", + "TTO", + "TUN", + "TUR", + "TWN", + "TZA", + "UGA", + "UKR", + "URY", + "USA", + "UZB", + "VCT", + "VEN", + "VGB", + "VNM", + "YEM", + "ZAF", + "ZMB", + "ZWE", +] + +UNINHABITED_ISOS = ["ATF", "BVT", "CL-", "HMD", "IOT", "SGS"] +OTHER_ISOS = [ + "AFG", + "ALA", + "AND", + "ASM", + "BES", + "BLM", + "CCK", + "COK", + "CUB", + "CXR", + "ERI", + "ESH", + "FLK", + "FRO", + "FSM", + "GGY", + "GIB", + "GLP", + "GRL", + "GUF", + "GUM", + "IMN", + "JEY", + "KIR", + "KO-", + "LBY", + "LIE", + "MAF", + "MCO", + "MHL", + "MNP", + "MTQ", + "MYT", + "NCL", + "NFK", + "NIU", + "NRU", + "PCN", + "PLW", + "PNG", + "PRI", + "PRK", + "PYF", + "REU", + "SHN", + "SJM", + "SLB", + "SMR", + "SOM", + "SPM", + "SSD", + "TKL", + "TLS", + "TON", + "TUV", + "UMI", + "VAT", + "VIR", + "VUT", + "WLF", + "WSM", +] + +ALL_ISOS = np.sort(np.union1d(PWT_ISOS, UNINHABITED_ISOS + OTHER_ISOS)) +EXTENDED_ISOS = ["GGY+JEY", "CHI", "XKX"] +ALL_ISOS_EXTENDED = np.sort(np.union1d(ALL_ISOS, EXTENDED_ISOS)) + +# Dask image name +DASK_IMAGE = "gcr.io/rhg-project-1/pytc-image-devbase:latest" + +# Constants +# Data +LITPOP_GRID_WIDTH = 1 / 120 +GEG_GRID_WIDTH = 1 / 24 +LANDSCAN_GRID_WIDTH = 1 / 120 + +EXPOSURE_BIN_WIDTH_V = 1 / 10 # meters +EXPOSURE_BIN_WIDTH_H = 1 / 10 # 10cm +HIGHEST_WITHELEV_EXPOSURE_METERS = 20 +ELEV_CAP = HIGHEST_WITHELEV_EXPOSURE_METERS + 1 # "higher than coastal" value + +## Spatial + +# Area, in "square degrees", above which we will consider endorheic basins as protected areas +# N.B. this is an arbitrary choice (something more robust could use something like a bathtub model +# over a highly resolved elevation grid). +MIN_BASIN_TILE_DEGREE_AREA = 20.0 + +# minimum distance in degrees from the ocean to include an endorheic basin as +# a "protected area" +ENDORHEIC_BASIN_OCEAN_BUFFER = 0.2 + +MAX_VORONOI_COMPLEXITY = ( + 40e6 # Maximum number of initial points in shapefile when generating Voronoi +) + +# Width, in degrees, of squares in which to divide the shapes of administrative regions. +# The smaller shapes are more manageable and computationally efficient in many +# geometry-processing algorithms +DEFAULT_BOX_SIZE = 1.0 + +DENSIFY_TOLERANCE = 0.01 +MARGIN_DIST = 0.001 +ROUND_INPUT_POINTS = 6 +SMALLEST_INTERIOR_RING = 1e-13 + +# What are the return periods (in years) we allow for retreat and protect standards +SVALS = np.array([10, 100, 1000, 10000]) + +# Paths and Directories +DIR_DATA = Path("/gcs/rhg-data/impactlab-rhg/coastal/sliiders") + +DIR_DATA_RAW = DIR_DATA / "raw" +DIR_DATA_INT = DIR_DATA / "int" +DIR_RESULTS = DIR_DATA / "output" + +DIR_EXPOSURE_RAW = DIR_DATA_RAW / "exposure" +DIR_EXPOSURE_INT = DIR_DATA_INT / "exposure" + +DIR_LITPOP_RAW = DIR_EXPOSURE_RAW / "asset_value" / "litpop" / LITPOP_DATESTAMP +PATH_LITPOP_RAW = DIR_LITPOP_RAW / LITPOP_VERS / "LitPop_pc_30arcsec_*.csv" + +DIR_GEG15_RAW = DIR_EXPOSURE_RAW / "asset_value" / "geg15" +DIR_GEG15_INT = DIR_EXPOSURE_INT / "asset_value" / "geg15" / GEG15_VERS +PATH_GEG15_INT = DIR_GEG15_INT / "gar_exp.parquet" + +DIR_SLR_RAW = DIR_DATA_RAW / "slr" +DIR_SLR_INT = DIR_DATA_INT / "slr" + +DIR_IFILES_RAW = DIR_SLR_RAW / "ifiles" +DIR_IFILES_INT = DIR_SLR_INT / "ifiles" +PATH_SLR_N_GCMS = fuse_to_gcsmap(DIR_SLR_INT / f"numGCMs_{SLIIDERS_VERS}.zarr", FS) + +DIR_GEOG_RAW = DIR_DATA_RAW / "geography" +DIR_GEOG_INT = DIR_DATA_INT / "geography" + +PATH_CIAM_2016 = fuse_to_gcsmap( + DIR_DATA_RAW / "CIAM_2016" / "diaz2016_inputs_raw.zarr", FS +) + +PATH_SLIIDERS_ECON = fuse_to_gcsmap( + DIR_RESULTS / f"sliiders-econ-{SLIIDERS_VERS}.zarr", FS +) +PATH_SLIIDERS_SLR = fuse_to_gcsmap( + DIR_RESULTS / f"sliiders-slr-{SLIIDERS_VERS}.zarr", FS +) + +PATH_SEG_CENTROIDS = DIR_GEOG_INT / "gtsm_stations_thinned_ciam" + +PATH_CIAM_COASTLINES = DIR_GEOG_INT / "ne_coastline_lines_CIAM_wexp_or_gtsm" + +DIR_GTSM_STATIONS_TOTHIN = DIR_GEOG_RAW / "gtsm_stations_eur_tothin" + +DIR_CIAM_VORONOI = DIR_GEOG_INT / "ciam_and_adm1_intersections" / EXPOSURE_BINNED_VERS +PATH_CIAM_ADM1_VORONOI_INTERSECTIONS = ( + DIR_CIAM_VORONOI / "ciam_and_adm1_intersections.parquet" +) + +PATH_CIAM_ADM1_VORONOI_INTERSECTIONS_SHP = ( + DIR_CIAM_VORONOI / "ciam_and_adm1_intersections.shp" +) + +DIR_SHAPEFILES = Path("/gcs/rhg-data/impactlab-rhg/spatial/shapefiles/source") + +DIR_GADM = Path(DIR_SHAPEFILES / "gadm" / GADM_VERS) + +PATH_GADM = DIR_GADM / f"{GADM_VERS}_levels" / f"{GADM_VERS}_levels.gpkg" +PATH_GADM_ADM1 = DIR_GADM / "adm1.parquet" +PATH_GADM_ADM0_VORONOI = DIR_GADM / "adm0_voronoi.parquet" +PATH_GADM_ADM1_VORONOI = DIR_GADM / "adm1_voronoi.parquet" + +PATH_EXPOSURE_BLENDED = ( + DIR_EXPOSURE_INT + / "asset_value" + / "litpop" + / EXPOSURE_BLENDED_VERS + / "LitPop_pc_30arcsec.parquet" +) + +PATH_NATURALEARTH_OCEAN = DIR_SHAPEFILES / "natural_earth" / "ne_10m_ocean" +DIR_HYDROBASINS_RAW = DIR_DATA_RAW / "hydrosheds" / "hydrobasins" + +DIR_GLOBAL_PROTECTED_AREAS = ( + DIR_EXPOSURE_INT + / "protected_locations" + / "global" + / "historical" + / GLOBAL_PROTECTED_AREAS_VERS +) + +PATH_US_MANUAL_PROTECTED_AREAS = ( + DIR_EXPOSURE_RAW + / "protected_areas" + / "usa" + / "manual" + / "us_manual_protected_areas.parquet" +) + +PATH_MANUAL_PROTECTED_AREAS = ( + DIR_GLOBAL_PROTECTED_AREAS / "manual_global_basins.parquet" +) +PATH_GLOBAL_PROTECTED_AREAS = DIR_GLOBAL_PROTECTED_AREAS / "all_protected_areas.parquet" + +DIR_WETLANDS_RAW = DIR_DATA_RAW / "wetlands_mangroves" +DIR_WETLANDS_INT = DIR_DATA_INT / "wetlands_mangroves" +PATH_GLOBCOVER_2009 = ( + DIR_WETLANDS_RAW + / "Globcover2009_V2.3_Global" + / "GLOBCOVER_L4_200901_200912_V2.3.tif" +) + +PATH_GLOBAL_MANGROVES = ( + DIR_WETLANDS_RAW + / "GMW_001_GlobalMangroveWatch_2016" + / "01_Data" + / "GMW_2016_v2.shp" +) + +PATH_WETLANDS_INT = DIR_WETLANDS_INT / "wetlands.shp" + +DIR_ELEVATION = Path("/gcs/rhg-data/impactlab-rhg/common_data/elevation") +DIR_ELEVATION_RAW = DIR_ELEVATION / "raw" +DIR_ELEVATION_INT = DIR_ELEVATION / "int" + +PATH_SRTM15_PLUS = DIR_ELEVATION_RAW / "srtm15_plus" / "SRTM15_V2.3.nc" +DIR_MSS = DIR_ELEVATION_INT / "CoastalDEM_mss_corrected" +DIR_COASTALDEM = ( + DIR_ELEVATION_RAW / "climate_central" / "coastal_dem_30as" / "CoastalDEM_Global_30m" +) + +DIR_LANDSCAN_RAW = DIR_EXPOSURE_RAW / "landscan" +DIR_LANDSCAN_INT = DIR_EXPOSURE_INT / "landscan" / f"ls{LANDSCAN_YEAR}" +PATH_LANDSCAN_INT = DIR_LANDSCAN_INT / "population.parquet" + +DIR_EXPOSURE_BINNED = ( + DIR_EXPOSURE_INT / "asset_value" / "binned" / "global" / "historical" +) +DIR_EXPOSURE_BINNED_TMP = DIR_EXPOSURE_BINNED / "tmp" +DIR_EXPOSURE_BINNED_TMP_TILES = DIR_EXPOSURE_BINNED_TMP / "tiles" +DIR_EXPOSURE_BINNED_TMP_TILES_NOLAND = DIR_EXPOSURE_BINNED_TMP / "tiles_noland" +DIR_EXPOSURE_BINNED_TMP_TILES_SEGMENT_AREA = ( + DIR_EXPOSURE_BINNED_TMP / "tiles_segment_area" +) + +PATH_EXPOSURE_TILE_LIST = DIR_EXPOSURE_BINNED / "tmp" / "meta" / "tile_list.parquet" + +PATH_EXPOSURE_AREA_BY_CIAM_AND_ELEVATION = ( + DIR_EXPOSURE_BINNED / EXPOSURE_BINNED_VERS / "ciam_segs_area_by_elev.parquet" +) + +PATH_EXPOSURE_BINNED_WITHOUTELEV = ( + DIR_EXPOSURE_BINNED + / EXPOSURE_BINNED_VERS + / "binned_exposure_withoutelev_base.parquet" +) + +PATH_EXPOSURE_BINNED_WITHELEV = ( + DIR_EXPOSURE_BINNED / EXPOSURE_BINNED_VERS / "binned_exposure_withelev_base.parquet" +) + +DIR_GEOG_DATUMS_RAW = DIR_GEOG_RAW / "datum_conversions" +DIR_GEOG_DATUMS_INT = DIR_GEOG_INT / "datum_conversions" + +DIR_GEOG_DATUMS_EGM96_WGS84 = DIR_GEOG_DATUMS_RAW / "egm96" +DIR_GEOG_DATUMS_XGM2019e_WGS84 = DIR_GEOG_DATUMS_RAW / "xgm2019e" + +PATH_GEOG_MDT_RAW = DIR_GEOG_RAW / "mdt" / "aviso_2018" / "mdt_cnes_cls18_global.nc" + +PATH_GEOG_DATUMS_GRID = fuse_to_gcsmap( + DIR_GEOG_DATUMS_INT / f"datum_conversions_gridded_{DATUM_CONVERSION_VERS}.zarr", FS +) + +PATH_GTSM_SURGE = ( + DIR_DATA_RAW / "esl" / "CODEC_amax_ERA5_1979_2017_coor_mask_GUM_RPS.nc" +) + +DIR_CCI_RAW = DIR_DATA_RAW / "cci" +PATH_EXPOSURE_WB_ICP = DIR_CCI_RAW / "world_bank_ICP_2017.csv" +PATH_EXPOSURE_LINCKE = DIR_CCI_RAW / "lincke_2021_country_input.csv" + +# Various directories and paths for the country-level ("YPK") workflow +DIR_YPK_INT = DIR_EXPOSURE_INT / "ypk" +DIR_YPK_FINAL = DIR_YPK_INT / "finalized" +DIR_YPK_RAW = DIR_EXPOSURE_RAW / "ypk" +PATH_COUNTRY_LEVEL_EXPOSURE = DIR_YPK_FINAL / "gdp_gdppc_pop_capital_1950_2020.parquet" +PATH_COUNTRY_LEVEL_EXPOSURE_PROJ = ( + DIR_YPK_FINAL / "gdp_gdppc_pop_capital_proj_2010_2100.parquet" +) + +DIR_UN_AMA_RAW = DIR_YPK_RAW / "un_ama" / UN_AMA_DATESTAMP +DIR_UN_WPP_RAW = DIR_YPK_RAW / "un_wpp" / UN_WPP_VERS +DIR_WB_WDI_RAW = DIR_YPK_RAW / "wb_wdi" / WB_WDI_DATESTAMP +DIR_OECD_REGIONS_RAW = DIR_YPK_RAW / "oecd_regions" / OECD_DATESTAMP +DIR_IIASA_PROJECTIONS = ( + DIR_YPK_RAW / "iiasa_projections" / IIASA_PROJECTIONS_DOWNLOAD_VERS +) +DIR_ALAND_STATISTICS_RAW = DIR_YPK_RAW / "asub" / ALAND_STATISTICS_DATESTAMP +PATH_GWDB2021_RAW = ( + DIR_YPK_RAW / "gwdb" / GWDB_DATESTAMP / "global-wealth-databook-2021.pdf" +) +PATH_PWT_RAW = DIR_YPK_RAW / "pwt" / PWT_DATESTAMP / "pwt_100.xlsx" +PATH_IMF_WEO_RAW = DIR_YPK_RAW / "imf_weo" / IMF_WEO_VERS / "WEO_iy_ratio_pop_gdp.xlsx" +PATH_MPD_RAW = DIR_YPK_RAW / "mpd" / MPD_DATESTAMP / "maddison_project.xlsx" diff --git a/sliiders/spatial.py b/sliiders/spatial.py new file mode 100644 index 0000000..f43171f --- /dev/null +++ b/sliiders/spatial.py @@ -0,0 +1,3331 @@ +import random +import warnings +import zipfile +from collections import defaultdict +from operator import itemgetter +from typing import Any, Sequence, Union + +import geopandas as gpd +import matplotlib._color_data as mcd +import networkx as nx +import numpy as np +import pandas as pd +import pygeos +import regionmask +import rioxarray +import shapely as shp +import xarray as xr +from dask_gateway import Gateway +from IPython.display import display +from numba import jit +from pyinterp.backends.xarray import Grid2D +from scipy.spatial import SphericalVoronoi, cKDTree +from shapely.geometry import ( + GeometryCollection, + LineString, + MultiLineString, + MultiPolygon, + Point, + Polygon, + box, +) +from shapely.ops import linemerge, unary_union +from tqdm.notebook import tqdm + +from . import settings as sset +from .io import load_adm0_shpfiles + +assert sset.MARGIN_DIST < sset.DENSIFY_TOLERANCE +assert 10 ** (-sset.ROUND_INPUT_POINTS) < sset.MARGIN_DIST + +SPHERICAL_VORONOI_THRESHOLD = ( + 1e-7 # `threshold` parameter of SphericalVoronoi() (not sure it can go any lower) +) +LAT_TO_M = 111131.745 +EARTH_RADIUS = 6371.009 + + +def iso_poly_box_getter(iso, shp_df): + """Get `box`es or rectangular areas of coordinates that contains each Polygon + belonging to the shapefile of the country specified by the ISO code. + + Parameters + ---------- + iso : str + ISO code of the country that we are interested in + shp_df : geopandas DataFrame + with the indices being the iso codes and with a column called `geometry` + containing the shapefile of the relevant countries + + Returns + ------- + list of tuples (of length four) + containing the smallest and largest x and y coordinates (longitudes and + latitudes) + + """ + shp = shp_df.loc[iso, "geometry"] + if type(shp) == MultiPolygon: + shps = shp.geoms + else: + shps = [shp] + + poly_bounds = [] + for poly in shps: + xx = np.array(poly.exterior.coords.xy[0]) + yy = np.array(poly.exterior.coords.xy[1]) + xmin, xmax = np.floor(xx.min()), np.ceil(xx.max()) + ymin, ymax = np.floor(yy.min()), np.ceil(yy.max()) + poly_bounds.append((xmin, xmax, ymin, ymax)) + + return list(set(poly_bounds)) + + +def get_iso_geometry(iso=""): + """For a given list of ISO 3166-1 alpha-3 codes (or a single code), returns + corresponding Natural Earth shapefile geometries. Note that some ISO codes are + recorded differently under Natural Earth (e.g., Aland Island is originally `ALA` + but recorded as `ALD`), so such cases are fixed when encountered. + + Parameters + ---------- + iso : str or list of str + three-letter ISO 3166-1 alpha-3 code, or list of such codes, referencing a + geographic region in the Natural Earth shapefiles + + Returns + ------- + :py:class:`shapely.geometry` or list of :py:class:`shapely.geometry` + """ + input_is_list = isinstance(iso, (list, np.ndarray)) + + if input_is_list: + isos = list(iso) + else: + isos = [iso] + + shp_dict = load_adm0_shpfiles( + ["countries", "map_units", "map_subunits", "disputed_areas"] + ) + country_shps = shp_dict["countries"] + map_unit_shps = shp_dict["map_units"] + map_subunit_shps = shp_dict["map_subunits"] + disputed_area_shps = shp_dict["disputed_areas"] + + for i in range(len(isos)): + # cw between iso codes -- + if isos[i] == "ALA": + isos[i] = "ALD" + if isos[i] == "ESH": + isos[i] = "SAH" + if isos[i] == "PSE": + isos[i] = "PSX" + if isos[i] == "SJM": + isos[i] = "NSV" + if isos[i] == "SSD": + isos[i] = "SDS" + if isos[i] == "XKX": + isos[i] = "KOS" + if isos[i] == "BES": + isos[i] = "NLY" + + geos = [] + for iso in isos: + if iso == "SAH": + geo = disputed_area_shps[ + disputed_area_shps["NAME_EN"] == "Western Sahara" + ].geometry.unary_union + else: + # retrieve shape file + try: + geo = country_shps[ + country_shps["ADM0_A3"] == iso.upper() + ].geometry.iloc[0] + if iso == "MAR": + geo = geo.difference( + disputed_area_shps[ + disputed_area_shps["NAME_EN"] == "Western Sahara" + ].geometry.unary_union + ) + except IndexError: + try: + geo = map_unit_shps[ + map_unit_shps["GU_A3"] == iso.upper() + ].geometry.iloc[0] + except IndexError: + geo = map_subunit_shps[ + map_subunit_shps["SU_A3"] == iso.upper() + ].geometry.iloc[0] + geos.append(geo) + + if input_is_list: + return geos + return geos[0] + + +def filter_spatial_warnings(): + """Suppress warnings defined in `sliiders.settings.SPATIAL_WARNINGS_TO_IGNORE`""" + for msg in sset.SPATIAL_WARNINGS_TO_IGNORE: + warnings.filterwarnings("ignore", message=f".*{msg}*") + + +def add_rand_color(gdf, col=None): + """Get a list of random colors corresponding to either each row or each ID + (as defined by `col`) of a GeoDataFrame. Used in `sliiders` for diagnostic + visualizations, not functionality. + + Parameters + ---------- + gdf : geopandas.GeoDataFrame + GeoDataFrame to assign colors to + + col: str + Column name in `gdf` to use as unique ID to assign colors to + + Returns + ------- + colors : list-like, or pandas.Series + A list of random colors corresponding to each row, or to values + defined in gdf[`col`] + """ + if col is None: + colors = random.choices(list(mcd.XKCD_COLORS.keys()), k=gdf.shape[0]) + else: + unique_vals = gdf[col].unique() + color_dict = { + v: random.choice(list(mcd.XKCD_COLORS.keys())) for v in unique_vals + } + return gdf[col].apply(lambda v: color_dict[v]) + return colors + + +def get_points_on_lines(geom, distance, starting_length=0.0): + """Return evenly spaced points on a LineString or + MultiLineString object. + + Parameters + ---------- + geom : :py:class:`shapely.geometry.MultiLineString` or + :py:class:`shapely.geometry.LineString` + distance : float + Interval desired between points along LineString(s). + starting_length : float + How far in from one end of the LineString you would like + to put your first point. + + Returns + ------- + coast : :py:class:`shapely.geometry.MultiPoint` object + Contains all of the points on your line. + """ + + if geom.geom_type == "LineString": + short_length = geom.length - starting_length + num_vert = int(short_length / distance) + 1 + + # if no points should be on this linestring, return + # empty list + if short_length <= 0: + return [], -short_length + + # else return list of coordinates + remaining_length = geom.length - ((num_vert - 1) * distance + starting_length) + return ( + shp.geometry.MultiPoint( + [ + geom.interpolate(n * distance + starting_length, normalized=False) + for n in range(num_vert) + ] + ), + remaining_length, + ) + elif geom.geom_type == "MultiLineString": + this_length = starting_length + parts = [] + for part in geom: + res, this_length = get_points_on_lines(part, distance, this_length) + parts += res + return shp.geometry.MultiPoint(parts), this_length + else: + raise ValueError("unhandled geometry %s", (geom.geom_type,)) + + +def grab_lines(g): + """Get a LineString or MultiLineString representing all the lines in a + geometry. + + Parameters + ---------- + g : shapely.Geometry + Any Geometry in Shapely + + Returns + ------- + shapely.LineString or shapely.MultiLineString + A shapely.Geometry object representing all LineStrings in `g`. + """ + if isinstance(g, Point): + return LineString() + if isinstance(g, LineString): + return g + + return linemerge( + [ + component + for component in g.geoms + if isinstance(component, LineString) + or isinstance(component, MultiLineString) + ] + ) + + +def grab_polygons(g): + """Get a Polygon or MultiPolygon representing all the polygons in a + geometry. + + Parameters + ---------- + g : shapely.Geometry + Any Geometry in Shapely + + Returns + ------- + shapely.Polygon or shapely.MultiPolygon + A shapely.Geometry object representing all Polygons in `g`. + + """ + if isinstance(g, Point): + return Polygon() + if isinstance(g, Polygon): + return g + if isinstance(g, MultiPolygon): + return g + return unary_union( + [ + component + for component in g.geoms + if isinstance(component, Polygon) or isinstance(component, MultiPolygon) + ] + ) + + +def strip_line_interiors_poly(g): + """Remove tiny interior Polygons from a Polygon. + + Parameters + ---------- + g : shapely.Polygon + A Shapely Polygon + + Returns + ------- + shapely.Polygon + A Shapely Polygon equivalent to `g`, removing any interior Polygons + smaller than or equal to `sliiders.spatial.SMALLEST_INTERIOR_RING`, + measured in "square degrees". + """ + return Polygon( + g.exterior, + [i for i in g.interiors if Polygon(i).area > sset.SMALLEST_INTERIOR_RING], + ) + + +def strip_line_interiors(g): + """Remove tiny interior Polygons from a Geometry. + + Parameters + ---------- + g : shapely.Geometry + A Shapely Geometry. Must be either an object containing Polygons, i.e. + shapely.Polygon or shapely.MultiPolygonn or shapely.GeometryCollection + + Returns + ------- + shapely.Polygon or shapely.MultiPolygon + A collection of Shapely Polygons equivalent to the set of Polygons + contained in `g`, removing any interior Polygons smaller than or equal + to `sliiders.spatial.SMALLEST_INTERIOR_RING`, measured in + "square degrees". + """ + if isinstance(g, Polygon): + return strip_line_interiors_poly(g) + if isinstance(g, MultiPolygon): + return unary_union( + [ + strip_line_interiors_poly(component) + for component in g.geoms + if isinstance(component, Polygon) + ] + ) + + # Recursively call this function for each Polygon or Multipolygon contained + # in the geometry + if isinstance(g, GeometryCollection): + return unary_union( + [ + strip_line_interiors(grab_polygons(g2)) + for g2 in g.geoms + if (isinstance(g2, Polygon) or isinstance(g2, MultiPolygon)) + ] + ) + + raise ValueError( + "Geometry must be of type `Polygon`, `MultiPolygon`, or `GeometryCollection`." + ) + + +def fill_in_gaps(gser): + """Fill in the spatial gaps of a GeoSeries within the latitude-longitude + coordinate system. Approximates a "nearest shape" from the original + geometries by iteratively expanding the original shapes in degree-space. + Not ideal for precise nearest-shape-matching, but useful in cases where + gaps are small and/or insignificant but may lead to computational + difficulties. + + Parameters + ---------- + gser : :py:class:`geopandas.GeoSeries` + A GeoSeries intended to include globally comprehensive shapes + + Returns + ------- + out : :py:class:`geopandas.GeoSeries` + A GeoSeries covering the globe, with initially empty spaces filled in by a + nearby shape. + """ + uu = gser.unary_union + current_coverage = box(-180, -90, 180, 90).difference(uu) + if isinstance(current_coverage, Polygon): + current_coverage = MultiPolygon([current_coverage]) + + assert all([g.type == "Polygon" for g in current_coverage.geoms]) + + intersects_missing_mask = gser.intersects(current_coverage) + intersects_missing = gser[intersects_missing_mask].copy().to_frame(name="geometry") + + for buffer_size in tqdm([0.01, 0.01, 0.01, 0.03, 0.05, 0.1, 0.1, 0.1]): + with warnings.catch_warnings(): + filter_spatial_warnings() + intersects_missing["buffer"] = intersects_missing["geometry"].buffer( + buffer_size + ) + + new_buffers = [] + for i in intersects_missing.index: + new_buffer = ( + intersects_missing.loc[i, "buffer"] + .intersection(current_coverage) + .buffer(0) + ) + new_buffers.append(new_buffer) + current_coverage = current_coverage.difference(new_buffer) + + with warnings.catch_warnings(): + filter_spatial_warnings() + intersects_missing["new_buffer"] = gpd.GeoSeries( + new_buffers, index=intersects_missing.index, crs=intersects_missing.crs + ).buffer(0.00001) + use_new_buffer_mask = intersects_missing["new_buffer"].geometry.area > 0 + intersects_missing.loc[ + use_new_buffer_mask, "geometry" + ] = intersects_missing.loc[use_new_buffer_mask, "geometry"].union( + intersects_missing.loc[use_new_buffer_mask, "new_buffer"] + ) + + assert current_coverage.area == 0 + + out = gser[~intersects_missing_mask].copy() + + out = pd.concat( + [out, intersects_missing.geometry], + ).rename(out.name) + + assert intersects_missing.is_valid.all() + + return out + + +def get_polys_in_box(all_polys, lx, ly, ux, uy): + """Get the subset of shapes in `all_polys` that overlap with the box defined + by `lx`, `ly`, `ux`, `uy`. + + Parameters + ---------- + all_polys : pygeos.Geometry + Array of pygeos Polygons + + lx : float + Left (western) bound of box + + ly : float + Lower (southern) bound of box + + ux : float + Right (eastern) bound of box + + uy : float + Upper (northern) bound of box + + Returns + ------- + vertical_slab : pygeos.Geometry + List of the pygeos polygons from `all_polys` overlapped with (cut by) + the box. + + slab_polys : np.array + List of indices from `all_polys` corresponding to the polygons in + `vertical_slab`. + """ + + vertical_slab = pygeos.clip_by_rect(all_polys, lx, ly, ux, uy) + + poly_found_mask = ~pygeos.is_empty(vertical_slab) + slab_polys = np.where(poly_found_mask) + + vertical_slab = vertical_slab[poly_found_mask] + + # invalid shapes may occur from Polygons being cut into what should be MultiPolygons + not_valid = ~pygeos.is_valid(vertical_slab) + vertical_slab[not_valid] = pygeos.make_valid(vertical_slab[not_valid]) + + vertical_slab_shapely = pygeos.to_shapely(vertical_slab) + vertical_slab_shapely = [strip_line_interiors(p) for p in vertical_slab_shapely] + vertical_slab = pygeos.from_shapely(vertical_slab_shapely) + + return vertical_slab, slab_polys + + +def grid_gdf( + orig_gdf, + box_size=sset.DEFAULT_BOX_SIZE, + show_bar=True, +): + """Divide a GeoDataFrame into a grid, returning the gridded shape-parts and + the "empty" areas, each nested within a `box_size`-degree-width square. + This reduces the sizes and rectangular boundaries of geometries, easing + many computational processes, especially those that depend on a spatial + index. + + Note: This may be deprecated in a future version if something like this + becomes available: https://github.com/pygeos/pygeos/pull/256 + + Parameters + ---------- + orig_gdf : :py:class:`geopandas.GeoSeries` or :py:class:`geopandas.GeoSeries` + GeoDataFrame/GeoSeries to be divided into a grid + + box_size : float + Width and height of boxes to divide geometries into + + show_bar : bool + Show progress bar + + Returns + ------- + gridded_gdf : geopandas.GeoDataFrame + GeoDataFrame containing `orig_gdf` geometries divided into grid cells. + + all_oc : pygeos.Geometry + List of pygeos Polygons corresponding to the "ocean" shapes in each + grid cell. Ocean shapes are defined as areas not covered by any + geometry in `orig_gdf`. + """ + + if isinstance(orig_gdf, gpd.GeoSeries): + orig_gdf = orig_gdf.to_frame(name="geometry") + orig_geos = pygeos.from_shapely(orig_gdf.geometry) + + llon, llat, ulon, ulat = orig_gdf.total_bounds + + boxes = [] + ixs = [] + all_oc = [] + iterator = np.arange(llon - 1, ulon + 1, box_size) + if show_bar: + iterator = tqdm(iterator) + for lx in iterator: + ux = lx + box_size + vertical_slab, slab_polys = get_polys_in_box(orig_geos, lx, llat, ux, ulat) + for ly in np.arange(llat - 1, ulat + 1, box_size): + uy = ly + box_size + res = pygeos.clip_by_rect(vertical_slab, lx, ly, ux, uy) + polygon_found_mask = ~pygeos.is_empty(res) + res = res[polygon_found_mask] + # invalid shapes may occur from Polygons being cut into what should be + # MultiPolygons + not_valid = ~pygeos.is_valid(res) + res[not_valid] = pygeos.make_valid(res[not_valid]) + ix = np.take(slab_polys, np.where(polygon_found_mask)) + if res.shape[0] > 0: + boxes.append(res) + ixs.append(ix) + + if res.shape[0] > 0: + + this_uu = pygeos.union_all(res) + + this_oc = pygeos.difference( + pygeos.from_shapely(box(lx, ly, ux, uy)), this_uu + ) + + oc_parts = pygeos.get_parts(this_oc) + all_oc += list(oc_parts) + + else: + this_oc = pygeos.from_shapely(box(lx, ly, ux, uy)) + all_oc.append(this_oc) + + geom_ix = np.concatenate(ixs, axis=1).flatten() + geom = np.concatenate(boxes).flatten() + + gridded_gdf = orig_gdf.drop(columns="geometry").iloc[geom_ix] + gridded_gdf["geometry"] = geom + + all_oc = np.array(all_oc) + all_oc = all_oc[~pygeos.is_empty(all_oc)] + + return gridded_gdf, all_oc + + +def divide_pts_into_categories( + pts, + pt_gadm_ids, + all_oc, + tolerance=sset.DENSIFY_TOLERANCE, + at_blank_tolerance=sset.MARGIN_DIST, +): + """From a set of points and IDs, divide points into "coastal-coastal" and + "coastal-border" categories. + + "Coastal" indicates proximity to the "coast", i.e. the edges of the union + of all original polygons, defined by `all_oc`. "Border" indicates + non-proximity to the coast. Proximity to the coast is calculated as being + within `at_blank_tolerance` of `all_oc`. + + "Coastal-border" points are defined as all coastal points that are within + `tolerance` of "border" points (points that are not near the coast). + + "Coastal-coastal" points are defined as the remaining "coastal" points + (not near a border). + + The motivation for this function is to simplify the point set used to + generate Voronoi regions from a set of polygons. Precision matters a lot + in parts of shapes that are near borders with other regions, and less so + in coastal areas that are distant from the nearest non-same region. Points + that are neither coastal, nor near a border, can be ignored, as they do not + define the edges of a region. That is, they are entirely interior to a + region's boundaries, so will not figure in the calculation of all areas + nearest to that region. + + Parameters + ---------- + pts : np.ndarray + 2D array with dimensions 2xN, representing N longitude-latitude + coordinates. + + pt_gadm_ids : np.ndarray + 1D array representing N IDs corresponding to `pts`. + + all_oc : pygeos.Geometry + List of pygeos Polygons corresponding to the "ocean" shapes in each + grid cell. Ocean shapes should be defined as areas not covered by any + geometry in the set of shapes represented here by their component + points. + + tolerance : float + Maximum distance from one point to a point with a different ID for the + first point to be considered a "border" point. + + at_blank_tolerance : float + Maximum distance from `all_oc` for a point to be considered "coastal". + + Returns + ------- + coastal_coastal_pts : np.ndarray + 2D array representing coastal points that are not near borders. + coastal_border_pts : np.ndarray + 2D array representing coastal points that are near borders. + coastal_coastal_gadm : np.ndarray + 1D array representing IDs corresponding to `coastal_coastal_pts`. + coastal_border_gadm : np.ndarray + 1D array representing IDs corresponding to `coastal_border_pts`. + """ + at_blank_tolerance = at_blank_tolerance + (at_blank_tolerance / 10) + tolerance = tolerance + (tolerance / 10) + + tree = cKDTree(pygeos.get_coordinates(all_oc)) + + batch_size = int(1e6) + starts = np.arange(0, pts.shape[0], batch_size) + ends = starts + batch_size + ends[-1] = pts.shape[0] + + pts_at_blank = [] + for i in range(len(starts)): + start = starts[i] + end = ends[i] + pts_subset = pts[start:end] + pts_tree = cKDTree(pts_subset) + pts_at_blank_subset = pts_tree.query_ball_tree(tree, r=at_blank_tolerance) + pts_at_blank_subset = np.array( + [True if r else False for r in pts_at_blank_subset] + ) + pts_at_blank.append(pts_at_blank_subset) + + pts_at_blank = np.concatenate(pts_at_blank) + + coastal_pts = pts[pts_at_blank] + coastal_pt_gadm_ids = pt_gadm_ids[pts_at_blank] + + border_pts = pts[~pts_at_blank] + + tree = cKDTree(border_pts) + + batch_size = int(1e6) + starts = np.arange(0, coastal_pts.shape[0], batch_size) + ends = starts + batch_size + ends[-1] = coastal_pts.shape[0] + + pts_at_border = [] + for i in range(len(starts)): + start = starts[i] + end = ends[i] + pts_subset = coastal_pts[start:end] + pts_tree = cKDTree(pts_subset) + pts_at_border_subset = pts_tree.query_ball_tree(tree, r=tolerance) + pts_at_border_subset = np.array( + [True if r else False for r in pts_at_border_subset] + ) + pts_at_border.append(pts_at_border_subset) + + pts_at_border = np.concatenate(pts_at_border) + + coastal_coastal_pts = coastal_pts[~pts_at_border].copy() + coastal_coastal_gadm = coastal_pt_gadm_ids[~pts_at_border].copy() + + coastal_border_pts = coastal_pts[pts_at_border].copy() + coastal_border_gadm = coastal_pt_gadm_ids[pts_at_border].copy() + + return ( + coastal_coastal_pts, + coastal_border_pts, + coastal_coastal_gadm, + coastal_border_gadm, + ) + + +def simplify_nonborder( + coastal_coastal_pts, + coastal_border_pts, + coastal_coastal_gadm, + coastal_border_gadm, + tolerance=sset.MARGIN_DIST, +): + """Simplify coastal Voronoi generator points that are not near the border + of another administrative region. + + Parameters + ---------- + coastal_coastal_pts : np.ndarray + 2D array of longitude-latitude coordinates representing + "coastal-coastal" points (see documentation in + `divide_pts_into_categories()`.) + + coastal_border_pts : np.ndarray + 2D array of longitude-latitude coordinates representing + "coastal-border" points (see documentation in + `divide_pts_into_categories()`.) + + coastal_coastal_gadm : np.ndarray + 1D array of region IDs corresponding to `coastal_coastal_pts`. + + coastal_border_gadm : np.ndarray + 1D array of region IDs corresponding to `coastal_border_pts`. + + tolerance : float + Precision in degree-distance below which we tolerate imprecision for + all points. + + Returns + ------- + non_border : np.ndarray + 2D array of points that are not close to the border + + non_border_gadm : np.ndarray + 1D array of region IDs corresponding to `non_border`. + + now_border : np.ndarray + 2D array of points that are close to the border + + now_border_gadm : np.ndarray + 1D array of region IDs corresponding to `now_border`. + """ + border_tree = cKDTree(coastal_border_pts) + + d, i = border_tree.query(coastal_coastal_pts, distance_upper_bound=1) + + already_simplified = np.zeros_like(coastal_coastal_pts[:, 0], dtype="bool") + non_border = [] + non_border_gadm = [] + + for UPPER_BOUND in [1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6]: + if UPPER_BOUND <= tolerance: + break + + simplify = ~(d < UPPER_BOUND) + this_level_nonborder = coastal_coastal_pts[simplify & (~already_simplified)] + this_level_nonborder_gadm = coastal_coastal_gadm[ + simplify & (~already_simplified) + ] + + already_simplified[simplify] = True + + # For points >= UPPER_BOUND away from the border, round to nearest + # UPPER_BOUND/10 + this_level_nonborder = np.round( + this_level_nonborder, int(-np.log10(UPPER_BOUND) + 1) + ) + this_level_nonborder, this_level_nonborder_ix = np.unique( + this_level_nonborder, axis=0, return_index=True + ) + this_level_nonborder_gadm = this_level_nonborder_gadm[this_level_nonborder_ix] + + non_border.append(this_level_nonborder) + non_border_gadm.append(this_level_nonborder_gadm) + + non_border = np.concatenate(non_border) + non_border_gadm = np.concatenate(non_border_gadm) + + now_border = coastal_coastal_pts[~already_simplified] + now_border_gadm = coastal_coastal_gadm[~already_simplified] + + return non_border, non_border_gadm, now_border, now_border_gadm + + +def explode_gdf_to_pts(geo_array, id_array, rounding_decimals=sset.ROUND_INPUT_POINTS): + """Transform an array of shapes into an array of coordinate pairs, keeping + the IDs of shapes aligned with the coordinates. + + Parameters + ---------- + geo_array : :py:class:`numpy.ndarray` + Array of ``pygeos`` geometries + + id_array : :py:class:`numpy.ndarray` + List of IDs corresponding to shapes in `geo_array` + + Returns + ------- + pts : np.ndarray + 2D array of longitude-latitude pairs representing all points, rounded + to ``sliiders.settings.ROUND_INPUT_POINTS`` precision, represented in the + geometries of ``geo_array``. + + pt_ids : np.ndarray + 1D array of IDs corresponding to ``pts``. + """ + counts = np.array([pygeos.count_coordinates(poly) for poly in geo_array]) + + pt_ids = np.repeat(id_array, counts) + + pts = pygeos.get_coordinates(geo_array) + + pts, pts_ix = np.unique(np.round(pts, rounding_decimals), axis=0, return_index=True) + pt_ids = pt_ids[pts_ix] + + return pts, pt_ids + + +def polys_to_vor_pts(regions, all_oc, tolerance=sset.DENSIFY_TOLERANCE): + """Create a set of Voronoi region generator points from a set of shapes. + + Parameters + ---------- + regions : geopandas.GeoDataFrame + GeoDataFrame defining region boundaries, with `UID` unique ID field + + all_oc : pygeos.Geometry + List of pygeos Polygons corresponding to the "ocean" shapes in each + grid cell. Ocean shapes should be defined as areas not covered by any + geometry in the set of `regions`. + + tolerance : float + Desired precision of geometries in `regions` + + Returns + ------- + :py:class:`geopandas.GeoSeries` + Resulting points derived from `regions` to use as Voronoi generators + """ + densified = pygeos.segmentize(pygeos.from_shapely(regions["geometry"]), tolerance) + + pts, pt_gadm_ids = explode_gdf_to_pts(densified, regions.index.values) + + all_oc_densified = pygeos.segmentize(all_oc, sset.MARGIN_DIST) + + ( + coastal_coastal_pts, + coastal_border_pts, + coastal_coastal_gadm, + coastal_border_gadm, + ) = divide_pts_into_categories(pts, pt_gadm_ids, all_oc_densified, tolerance) + + non_border, non_border_gadm, now_border, now_border_gadm = simplify_nonborder( + coastal_coastal_pts, + coastal_border_pts, + coastal_coastal_gadm, + coastal_border_gadm, + tolerance=sset.MARGIN_DIST, + ) + + vor_pts = np.concatenate([non_border, now_border, coastal_border_pts]) + vor_gadm = np.concatenate([non_border_gadm, now_border_gadm, coastal_border_gadm]) + + return remove_duplicate_points( + gpd.GeoSeries.from_xy( + x=vor_pts[:, 0], + y=vor_pts[:, 1], + index=pd.Index(vor_gadm, name=regions.index.name), + crs=regions.crs, + ) + ) + + +def get_hemisphere_shape(hemisphere): + """Define Shapely boxes for each hemisphere and the globe. + + Parameters + ---------- + hemisphere : str + Options are "west", "east", and "both". + + Returns + ------- + shapely.Polygon + A single box corresponding to the requested hemisphere(s). + """ + if hemisphere == "west": + return box(-180, -90, 0, 90) + elif hemisphere == "east": + return box(0, -90, 180, 90) + elif hemisphere == "both": + return box(-180, -90, 180, 90) + else: + raise ValueError + + +def make_valid_shapely(g): + """Wrapper to call `make_valid` on a list of Shapely geometries. + Should be deprecated upon release of Shapely 2.0. + + Parameters + ---------- + g : list-like + List of Shapely geometries or geopandas.GeoSeries + + Returns + ------- + list + List of Shapely geometries, after calling `pygeos.make_valid()` on all. + """ + return pygeos.to_shapely(pygeos.make_valid(pygeos.from_shapely(g))) + + +def clip_geoseries_by_rect(gs, rect): + """Wrapper to mask a geopandas.GeoSeries by a Shapely rectangle. + Should be deprecated upon release of Shapely 2.0. + + Parameters + ---------- + gs : geopandas.GeoSeries + Any Geopandas GeoSeries + + rect : shapely.Polygon + A Shapely rectangle + + Returns + ------- + geopandas.GeoSeries + A GeoSeries equivalent to `gs`, bound by `rect`. + """ + try: + return gpd.GeoSeries(pygeos.clip_by_rect(pygeos.from_shapely(gs), *rect.bounds)) + except Exception: # weird issue with CYM, clip_by_rect doesn't work + return gs.apply(lambda g: g.intersection(rect)) + + +def diff_geoseries(gs1, gs2): + """Wrapper to get the spatial difference between two GeoSeries. + + Parameters + ---------- + gs1 : geopandas.GeoSeries + Any GeoSeries + + gs2 : geopandas.GeoSeries + Any GeoSeries + + Returns + ------- + geopandas.GeoSeries + The spatial difference between `gs1` and `gs2` (i.e. `gs1` - `gs2`) + """ + return gpd.GeoSeries( + pygeos.difference(pygeos.from_shapely(gs1), pygeos.from_shapely(gs2)) + ) + + +@jit(nopython=True, parallel=False) +def lon_lat_to_xyz(lons, lats): + """Transformation from longitude-latitude to an x-y-z cube + with centroid [0, 0, 0]. Resulting points are on the unit sphere. + + Parameters + ---------- + lons : np.ndarray + 1D array of longitudes + + lats : np.ndarray + 1D array of latitudes + + Returns + ------- + np.ndarray + 2D array representing x-y-z coordinates equivalent to inputs + """ + lat_radians, lon_radians = np.radians(lats), np.radians(lons) + sin_lat, cos_lat = np.sin(lat_radians), np.cos(lat_radians) + sin_lon, cos_lon = np.sin(lon_radians), np.cos(lon_radians) + x = cos_lat * cos_lon + y = cos_lat * sin_lon + z = sin_lat + return np.stack((x, y, z), axis=1) + + +@jit(nopython=True, parallel=False) +def xyz_to_lon_lat(xyz): + """Transformation from x-y-z cube with centroid [0, 0, 0] to + longitude-latitude. + + Parameters + ---------- + xyz : np.ndarray + 2D array representing x-y-z coordinates on the unit sphere + + Returns + ------- + np.ndarray + 2D array representing longitude-latitude coordinates equivalent to + inputs + """ + x, y, z = xyz[:, 0], xyz[:, 1], xyz[:, 2] + lats = np.degrees(np.arcsin(z).flatten()) + lons = np.degrees(np.arctan2(y, x).flatten()) + # ensure consistency with points exactly on meridian + lons = np.where(lons == -180, 180, lons) + + return np.stack((lons, lats), axis=1) + + +def combine_reg_group(reg_group): + """Combine tesselated triplets on a sphere to get the points defining region + boundaries. + """ + pairs = defaultdict(list) + + for reg in reg_group: + for v in range(len(reg)): + p1 = reg[v] + p2 = reg[(v + 1) % len(reg)] + pairs[p1].append(p2) + pairs[p2].append(p1) + + edge_pairs = {k: v for k, v in pairs.items() if len(v) != 6} + edge_pairs = { + k: [item for item in v if item in edge_pairs.keys()] + for k, v in edge_pairs.items() + } + + G = nx.Graph() + + G.add_nodes_from(list(edge_pairs.keys())) + + for k in edge_pairs: + for item in edge_pairs[k]: + G.add_edge(k, item) + G.add_edge(item, k) + + cycles = nx.cycle_basis(G) + + return cycles + + +def get_reg_group(loc_reg_lists, loc, regions): + """Get all regions, as lists of vertex indices, corresponding to an ID + used to assign Voronoi regions. + + Parameters + ---------- + loc_reg_lists : dict from object to list of int + Mapping from each ID of the Voronoi-generating Polygon, to the list + of all indices of generator points with that ID. + + loc : object + Some key (ID) in `loc_reg_lists` + + regions : list of lists of int + Corresponds to the `regions` property of a + `scipy.spatial.SphericalVoronoi` object. From their documentation: + "the n-th entry is a list consisting of the indices of the vertices + belonging to the n-th point in points" + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.SphericalVoronoi.html) + + Returns + ------- + List of ints + List of lists of vertex indices, where each sub-list represents a + region, corresponding to all the generator points sharing the ID `loc`. + + """ + reg_group = itemgetter(*loc_reg_lists[loc])(regions) + if isinstance(reg_group, tuple): + return list(reg_group) + + return [reg_group] + + +def fix_ring_topology(reg_group_polys, reg_group_loc_ids): + """Insert holes in polygons that completely surround another polygon so + that they are distinct. This resolves an issue in Voronoi construction + where some regions cover others that they surround, rather than including a + hole where the surrounded polygon should be. + + Parameters + ---------- + reg_group_polys : list of shapely.geometry.Polygon + List of all Voronoi polygons in longitude-latitude space. + + reg_group_loc_ids : list of int + List of IDs corresponding to the generating regions of + `reg_group_polys`. + + Returns + ------- + reg_group_polys, reg_group_loc_ids : tuple + The inputs, modified so that surrounding polygons have holes where + they surround other polygons. + + """ + group_polys = pygeos.from_shapely(reg_group_polys) + + tree = pygeos.STRtree(group_polys) + + contains, contained = tree.query_bulk(group_polys, "contains_properly") + + # Check that there are no rings inside rings. If there are, this function + # And `get_groups_of_regions()` may need to be re-worked + assert set(contains) & set(contained) == set([]) + + for container_ix in np.unique(contains): + + reg_group_polys[container_ix] = pygeos.to_shapely( + pygeos.make_valid( + pygeos.polygons( + pygeos.get_exterior_ring(group_polys[container_ix]), + holes=pygeos.get_exterior_ring( + group_polys[contained[contains == container_ix]] + ), + ) + ) + ) + + reg_group_polys = [ + p for (i, p) in enumerate(reg_group_polys) if i not in np.unique(contained) + ] + reg_group_loc_ids = [ + l for (i, l) in enumerate(reg_group_loc_ids) if i not in np.unique(contained) + ] + + return reg_group_polys, reg_group_loc_ids + + +@jit(nopython=True) +def numba_geometric_slerp(start, end, t): + """Optimized version of scipy.spatial.geometric_slerp + + Adapted from: + https://github.com/scipy/scipy/blob/master/scipy/spatial/_geometric_slerp.py + + Parameters + ---------- + start : np.ndarray + Single n-dimensional input coordinate in a 1-D array-like + object. `n` must be greater than 1. + + end : np.ndarray + Single n-dimensional input coordinate in a 1-D array-like + object. `n` must be greater than 1. + + t : np.ndarray + A float or 1D array-like of doubles representing interpolation + parameters, with values required in the inclusive interval + between 0 and 1. A common approach is to generate the array + with ``np.linspace(0, 1, n_pts)`` for linearly spaced points. + Ascending, descending, and scrambled orders are permitted. + + Returns + ------- + np.ndarray + An array of doubles containing the interpolated + spherical path and including start and + end when 0 and 1 t are used. The + interpolated values should correspond to the + same sort order provided in the t array. The result + may be 1-dimensional if ``t`` is a float. + """ + # create an orthogonal basis using QR decomposition + basis = np.vstack((start, end)) + Q, R = np.linalg.qr(basis.T) + signs = 2 * (np.diag(R) >= 0) - 1 + Q = Q.T * np.reshape(signs.T, (2, 1)) + R = R.T * np.reshape(signs.T, (2, 1)) + + # calculate the angle between `start` and `end` + c = np.dot(start, end) + s = np.linalg.det(R) + omega = np.arctan2(s, c) + + # interpolate + start, end = Q + s = np.sin(t * omega) + c = np.cos(t * omega) + return start * np.reshape(c, (c.shape[0], 1)) + end * np.reshape(s, (s.shape[0], 1)) + + +@jit(nopython=True, parallel=False) +def clip_to_sphere(poly_points): + """Ensure 3D points do not reach outside of unit cube. + As designed this should only correct for tiny differences that would make + x-y-z to lon-lat conversion impossible. + + Parameters + ---------- + poly_points : np.ndarray + 3D array of points (that should be) on unit sphere + + Returns + ------- + poly_points : np.ndarray + 3D array of points (that should be) on unit sphere, clipped wherever + they exceed the bounds of the unit cube. + """ + poly_points = np.minimum(poly_points, 1) + poly_points = np.maximum(poly_points, -1) + return poly_points + + +def get_polygon_covering_pole(poly_points_lon_lat, nsign): + """Convert a polygon defined by its edges into a polygon representing + its latitude-longitude space comprehensively. + + Coordinates that cover poles may define polygon boundaries but not + their relationship to a pole explicitly. For example, consider a polygon + represented by these coordinates: + + [[0, 60], [120, 60], [240, 60], [0, 60]] + + This may represent the region of the earth above the 60-degree latitude + line, or it may represent the region of the earth below that line. This + function ensures an explicit definition on a projected coordinate system. + + Parameters + ---------- + poly_points_lon_lat : np.ndarray + 2D array of coordinates (longitude, latitude) representing a polygon + that covers a pole. + + nsign : int + Integer representing positive (nsign == 1: north pole) or negative + (nsign == -1: south pole) sign of latitude of the pole to be covered. + + Returns + ------- + p : shapely.Polygon + Polygon defined by `poly_points_lon_lat`, transformed to cover the pole + indicated by `nsign` in latitude-longitude space. + """ + diff = poly_points_lon_lat[1:] - poly_points_lon_lat[:-1] + turnpoints = np.flip(np.where(np.abs(diff[:, 0]) > 180)[0]) + + for turnpoint in turnpoints: + esign = 1 if poly_points_lon_lat[turnpoint][0] > 0 else -1 + + start, end = poly_points_lon_lat[turnpoint], poly_points_lon_lat[ + turnpoint + 1 + ] + np.array([360 * esign, 0]) + + refpoint = 180 * esign + opppoint = 180 * -esign + + xdiff = end[0] - start[0] + ydiff = end[1] - start[1] + + xpart = (refpoint - start[0]) / xdiff if xdiff > 0 else 0.5 + + newpt1 = [refpoint, start[1] + ydiff * xpart] + newpt2 = [refpoint, 90 * nsign] + newpt3 = [opppoint, 90 * nsign] + newpt4 = [opppoint, start[1] + ydiff * xpart] + + insert_pts = np.array([newpt1, newpt2, newpt3, newpt4]) + + poly_points_lon_lat = np.insert( + poly_points_lon_lat, turnpoint + 1, insert_pts, axis=0 + ) + + p = Polygon(poly_points_lon_lat) + return p + + +@jit(nopython=True, parallel=False) +def ensure_validity(poly_points_lon_lat): + """Resolve duplicate points and some floating point issues in polygons + derived from `numba_process_points()`. + + Parameters + ---------- + poly_points_lon_lat : np.ndarray + 2D array of longitude-latitude coordinates + + Returns + ------- + np.ndarray + A version of `poly_points_lon_lat` with duplicates removed and some + floating point issues resolved. + """ + same_as_next = np.zeros((poly_points_lon_lat.shape[0]), dtype=np.uint8) + same_as_next = same_as_next > 1 + same_as_next[:-1] = ( + np.sum(poly_points_lon_lat[:-1] == poly_points_lon_lat[1:], axis=1) == 2 + ) + poly_points_lon_lat = poly_points_lon_lat[~same_as_next] + out = np.empty_like(poly_points_lon_lat) + return np.round(poly_points_lon_lat, 9, out) + + +@jit(nopython=True) +def numba_divide_polys_by_meridians(poly_points_lon_lat): + """Transform polygons defined by vertices that wrap around the globe, + into those same polygons represented as 2D shapes. + + Parameters + ---------- + poly_points_lon_lat : np.ndarray + 2D array of longitude-latitude coordinates + + Returns + ------- + list of np.ndarray + List of 2D array of longitude-latitude coordinates, representing all + 2D polygons formed by `poly_points_lon_lat` when represented in + projected space that does not wrap around the globe + """ + + diff = poly_points_lon_lat[1:] - poly_points_lon_lat[:-1] + turnpoints = np.flip(np.where(np.abs(diff[:, 0]) > 180)[0]) + if turnpoints.shape[0] == 0: + return [poly_points_lon_lat] + else: + for turnpoint in turnpoints: + esign = 1 if poly_points_lon_lat[turnpoint][0] > 0 else -1 + + start, end = poly_points_lon_lat[turnpoint], poly_points_lon_lat[ + turnpoint + 1 + ] + np.array([360 * esign, 0]) + + refpoint = 180 * esign + opppoint = 180 * -esign + + xdiff = end[0] - start[0] + ydiff = end[1] - start[1] + + xpart = (refpoint - start[0]) / xdiff if xdiff > 0 else 0.5 + + newpt1 = [refpoint, start[1] + ydiff * xpart] + newpt4 = [opppoint, start[1] + ydiff * xpart] + + insert_pts = np.array([newpt1, newpt4]) + + poly_points_lon_lat = np.concatenate( + ( + poly_points_lon_lat[: turnpoint + 1], + insert_pts, + poly_points_lon_lat[turnpoint + 1 :], + ), + axis=0, + ) + + diff = poly_points_lon_lat[1:] - poly_points_lon_lat[:-1] + + turnpoint_switches_off1 = np.zeros((diff[:, 0].shape[0]), dtype=np.int8) + + turnpoint_switches_off1[np.where(diff[:, 0] < -240)[0]] = 1 + turnpoint_switches_off1[np.where(diff[:, 0] > 240)[0]] = -1 + + turnpoint_switches = np.zeros( + (poly_points_lon_lat[:, 0].shape[0]), dtype=np.int8 + ) + + turnpoint_switches[1:] = turnpoint_switches_off1 + + turnpoints = np.where(turnpoint_switches)[0] + + shapeset = np.cumsum(turnpoint_switches) + + return [poly_points_lon_lat[shapeset == sh] for sh in np.unique(shapeset)] + + +@jit(nopython=True, parallel=False) +def interpolate_vertices_on_sphere(vertices): + """Interpolate points in x-y-z space on a sphere. + + Parameters + ---------- + vertices : np.ndarray + 2D array of x-y-z coordinates on the unit sphere + + Returns + ------- + np.ndarray + 2D array of x-y-z coordinates on the unit sphere, interpolated with + at least one point for every distance of length `precision`. + """ + n = len(vertices) + + poly_interp_x = [] + poly_interp_y = [] + poly_interp_z = [] + ct = 0 + for i in range(n): + precision = 1e-3 + start = vertices[i] + end_ix = (i + 1) % n + end = vertices[end_ix] + dist = np.linalg.norm(start - end) + n_pts = max(int(dist / precision), 2) + t_vals = np.linspace(0, 1, n_pts) + if i != n - 1: + t_vals = t_vals[:-1] + + result = numba_geometric_slerp(start, end, t_vals) + for x in result[:, 0]: + poly_interp_x.append(x) + for y in result[:, 1]: + poly_interp_y.append(y) + for z in result[:, 2]: + poly_interp_z.append(z) + + ct += result.shape[0] + + return np.stack( + ( + np.array(poly_interp_x)[:ct], + np.array(poly_interp_y)[:ct], + np.array(poly_interp_z)[:ct], + ), + axis=1, + ) + + +@jit(nopython=True) +def numba_process_points(vertices): + """Densify x-y-z spherical vertices and convert to lon-lat space. + + Parameters + ---------- + vertices : np.ndarray + 2D array of x-y-z coordinates on the unit sphere + + Returns + ------- + poly_points_lon_lat : np.ndarray + 2D array of longitude-latitude coordinates, representing densified + version of `vertices`. + """ + poly_points = interpolate_vertices_on_sphere(vertices) + poly_points = clip_to_sphere(poly_points) + poly_points_lon_lat = xyz_to_lon_lat(poly_points) + return poly_points_lon_lat + + +def get_groups_of_regions( + loc_reg_lists, loc, sv, includes_southpole, includes_northpole, combine_by_id=True +): + """Get Voronoi output shapes for generator points that are part of + the same original Polygon. + + Parameters + ---------- + loc_reg_lists : dict from object to list of int + Mapping from each ID of the Voronoi-generating Polygon, to the list + of all indices of generator points with that ID. + + loc : object + Some key in `loc_reg_lists` + + sv : scipy.spatial.SphericalVoronoi + SphericalVoronoi object based on input points + + includes_southpole : bool + Whether any of the Voronoi regions in `sv.regions` covers the south + pole. + + includes_northpole : bool + Whether any of the Voronoi regions in `sv.regions` covers the north + pole. + + combine_by_id : bool + Whether to combine all Voronoi regions with the same `UID`, or to keep + them separate. + + Returns + ------- + reg_group : list of int, or list of list of int + List of indices in `sv.vertices` composing the nodes of the Voronoi + polygon corresponding to `UID` == `loc`. If there are multiple polygons + formed from the combination of Voronoi shapes (e.g. if two islands of + a region are separated by an island with another `UID`), returns a list + of these lists of indices. + + """ + + reg_group = get_reg_group(loc_reg_lists, loc, sv.regions) + if not combine_by_id: + return reg_group + + if (not includes_southpole) and (not includes_northpole): + # Optimization to combine points from the same region into one large shape + # WARNING: Robust to interior rings, with `fix_ring_topology`, but not to + # rings within those rings. This is ok as long as the related assertion + # in `fix_ring_topology()` passes. + candidate = combine_reg_group(reg_group) + if len(candidate) == 1: + reg_group = candidate + + return reg_group + + +def get_polys_from_cycles( + loc_reg_lists, + reg_cycles, + sv, + loc, + includes_southpole, + includes_northpole, + ix_min, + ix_max, +): + """Transform Voronoi regions defined by `sv` on a sphere into the polygons + they define in longitude-latitude space. + + Parameters + ---------- + loc_reg_lists : dict from object to list of int + Mapping from the `UID` of the Voronoi-generating Polygon, to the list + of all indices in `pts_df` with that `UID`. + + reg_cycles : list of int, or list of list of int + List of indices in `sv.vertices` composing the nodes of the Voronoi + region corresponding to some `UID`. If there are multiple polygons + formed from the combination of Voronoi shapes (e.g. if two islands of + a region are separated by an island with another `UID`), this is a list + of these lists of indices. + + sv : scipy.spatial.SphericalVoronoi + SphericalVoronoi object based on input points + + loc : object + Some key in `loc_reg_lists` + + includes_southpole : bool + Whether any of the Voronoi regions in `sv.regions` covers the south + pole. + + includes_northpole : bool + Whether any of the Voronoi regions in `sv.regions` covers the north + pole. + + ix_min : list of int + Indices of most southerly origin points + + ix_max : list of int + Indices of most northerly origin points + + Returns + ------- + reg_group_polys : list of shapely.Polygon + Polygons representing Voronoi outputs in longitude-latitude space + + reg_group_loc_ids : list of int + `UID`s of `reg_group_polys` + + """ + reg_group_polys = [] + reg_group_loc_ids = [] + for i, reg in enumerate(reg_cycles): + + poly_points_lon_lat = numba_process_points(sv.vertices[reg]) + + if (includes_southpole or includes_northpole) and ( + loc_reg_lists[loc][i] in (set(ix_max) | set(ix_min)) + ): + nsign = 1 if loc_reg_lists[loc][i] in ix_max else -1 + poly_points_lon_lat = ensure_validity(poly_points_lon_lat) + p = get_polygon_covering_pole(poly_points_lon_lat, nsign) + reg_polys = [p] + else: + reg_polys = numba_divide_polys_by_meridians( + ensure_validity(poly_points_lon_lat) + ) + reg_polys = list(pygeos.to_shapely([pygeos.polygons(p) for p in reg_polys])) + + reg_group_polys += reg_polys + reg_group_loc_ids += [loc for i in range(len(reg_polys))] + + return reg_group_polys, reg_group_loc_ids + + +def get_spherical_voronoi_gser(pts, show_bar=True): + """From a list of points associated with IDs (which must be specified by + ``pts_df.index``), calculate the region of a globe closest to each ID-set, and + return a GeoSeries representing those "nearest" Polygons/MultiPolygons. + + Parameters + ---------- + pts_df : :py:class:`geopandas.GeoSeries` + GeoSeries of Points to be used as Voronoi generators. + + show_bar : bool + Show progress bar + + Returns + ------- + :py:class:`geopandas.GeoSeries` : GeoSeries representing Voronoi regions for each + input row. + """ + # Get indices of polar Voronoi regions + lats = pts.y.values + ymax = lats.max() + ymin = lats.min() + + ix_max = np.where(lats == ymax)[0] + ix_min = np.where(lats == ymin)[0] + + xyz_candidates = lon_lat_to_xyz(pts.x.values, lats) + + sv = SphericalVoronoi( + xyz_candidates, radius=1, threshold=SPHERICAL_VORONOI_THRESHOLD + ) + sv.sort_vertices_of_regions() + + polys = [] + loc_ids = [] + + loc_reg_lists = ( + pts.rename_axis(index="UID") + .reset_index(drop=False) + .reset_index(drop=False) + .groupby("UID")["index"] + .unique() + .to_dict() + ) + + iterator = tqdm(loc_reg_lists) if show_bar else loc_reg_lists + for loc in iterator: + includes_southpole = bool(set(ix_min) & set(loc_reg_lists[loc])) + includes_northpole = bool(set(ix_max) & set(loc_reg_lists[loc])) + + reg_cycles = get_groups_of_regions( + loc_reg_lists, + loc, + sv, + includes_southpole, + includes_northpole, + combine_by_id=True, + ) + + reg_group_polys, reg_group_loc_ids = get_polys_from_cycles( + loc_reg_lists, + reg_cycles, + sv, + loc, + includes_southpole, + includes_northpole, + ix_min, + ix_max, + ) + + reg_group_polys, reg_group_loc_ids = fix_ring_topology( + reg_group_polys, reg_group_loc_ids + ) + polys += reg_group_polys + loc_ids += reg_group_loc_ids + + # This should resolve some areas where regions are basically slivers, and + # the geometric slerp is too long to capture the correct topology of the + # region so that two lines of the same region cross along their planar coordinates. + # Based on testing and our use case, these are rare and small enough to ignore, + # and correcting for this with smaller slerp sections too computationally + # intensive, but improvements on this would be welcome. + polys = make_valid_shapely(polys) + + return ( + gpd.GeoDataFrame({pts.index.name: loc_ids}, geometry=polys, crs="EPSG:4326") + .dissolve(pts.index.name) + .geometry + ) + + +def append_extra_pts(sites): + """Define three extra points at the pole farthest from any point in `sites` + These can be necessary for compataibility with `SphericalVoronoi` when the + number of original sites is less than four. + + Parameters + ---------- + sites : :py:class:`geopandas.GeoSeries` + GeoSeries of Points. + + Returns + ------- + :py:class:`geopandas.GeoSeries` + Same as input, but with extra points near one of the poles included. + """ + y = sites.geometry.y + nsign = -1 if np.abs(y.max()) > np.abs(y.min()) else 1 + + out = sites.iloc[[0, 0, 0]].copy() + out.index = pd.Index( + ["placeholder1", "placeholder2", "placeholder3"], name=sites.index.name + ) + + out["geometry"] = gpd.GeoSeries.from_xy( + x=[0, 0, 180], + y=[90 * nsign, 89 * nsign, 89 * nsign], + index=out.index, + crs=sites.crs, + ) + + return pd.concat([sites, out]) + + +def get_voronoi_from_sites(sites): + """Get the Voronoi diagram corresponding to the points defined by `sites`. + + Parameters + ---------- + sites : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame of sites from which to generate a Voronoi diagram. Must include + index, Point `geometry` field. + + Returns + ------- + vor_gdf : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame where the geometry represents Voronoi regions for each site in + ``sites``. + """ + sites = remove_duplicate_points(sites) + if sites.index.nunique() == 1: + out = sites.iloc[0:1].copy() + out["geometry"] = box(-180, -90, 180, 90) + else: + if sites.shape[0] <= 3: + sites = append_extra_pts(sites) + vor_gser = get_spherical_voronoi_gser(sites.geometry, show_bar=False) + site_isos = ( + sites.reset_index(drop=False) + .drop(columns="geometry", errors="ignore") + .drop_duplicates() + .set_index("station_id") + ) + + out = vor_gser.to_frame().join(site_isos) + + return out + + +def get_stations_by_iso_voronoi(stations): + """From the GeoDataFrame of GTSM stations with assigned ISO values, + calculate a globally comprehensive set of shapes for each ISO mapping to the + closest station that has that ISO. + + Parameters + ---------- + stations : pandas.DataFrame + A DataFrame with fields `ISO`, `lon`, and `lat` + + Returns + ------- + out : geopandas.GeoDataFrame + A GeoDataFrame with fields `station_id` and `geometry`, indexed by `ISO` + `geometry` represents the region of the globe corresponding to the area + closer to station `station_id` than any other station in that `ISO` + + """ + + # Make sure none of the stations with too few points to calculate SphericalVoronoi + # are anywhere near the poles, so we can introduce the poles as extra points + iso_count = ( + stations.groupby("ISO")[["ISO"]].count().rename(columns={"ISO": "count"}) + ) + stations = stations.join(iso_count, on="ISO") + + lats = stations.geometry.y[stations["count"] <= 3] + assert (lats.max() < 60) and (lats.min() > -60) + + # Iterate through each country, add each Voronoi gdf to `vors` + all_isos = stations["ISO"].unique() + all_isos.sort() + + vors = [] + for iso in all_isos: + print(iso, end=" ") + iso_stations = stations[stations["ISO"] == iso].copy() + vors.append(get_voronoi_from_sites(iso_stations)) + + # Combine all Voronoi diagrams into one GeoDataFrame (results overlap) + vor_gdf = pd.concat(vors).drop( + ["placeholder1", "placeholder2", "placeholder3"], errors="ignore" + ) + + # Check that ISOs match + assert set(vor_gdf.index[vor_gdf["ISO"].isnull()].unique()) - set( + ["placeholder1", "placeholder2", "placeholder3"] + ) == set([]) + + # Clean up + vor_gdf = vor_gdf[vor_gdf["ISO"].notnull()].copy() + vor_gdf["geometry"] = vor_gdf["geometry"].apply(grab_polygons) + + return vor_gdf[["ISO", "geometry"]] + + +def remove_duplicate_points(pts, threshold=SPHERICAL_VORONOI_THRESHOLD): + """Remove points in DataFrame that are too close to each other to be + recognized as different in the `SphericalVoronoi` algorithm. + + Parameters + ---------- + pts : :py:class:`geopandas.GeoSeries` + GeoSeries of Points + + Returns + ------- + geopandas.DataFrame or pandas.DataFrame + DataFrame of `pts_df` points, with duplicates removed (i.e. leave one + of each set of duplicates). + """ + + xyz_candidates = lon_lat_to_xyz(pts.geometry.x.values, pts.geometry.y.values) + + res = cKDTree(xyz_candidates).query_pairs(threshold) + + first_point = np.array([p[0] for p in res]) + mask = np.ones(xyz_candidates.shape[0], dtype="bool") + + if len(first_point) > 0: + mask[first_point] = False + + return pts[mask] + + +def remove_already_attributed_land_from_vor( + vor_shapes, + all_gridded, + vor_ix, + existing, + vor_uid, + gridded_uid, + show_bar=True, + crs=None, +): + """Mask Voronoi regions with the pre-existing regions, so that the result + includes only the parts of the Voronoi regions that are not already + assigned to the pre-existing regions. + + Parameters + ---------- + vor_shapes : array of pygeos.Geometry + Shapes of globally comprehensive Voronoi regions + + all_gridded : array of pygeos.Geometry + Shapes of original regions + + vor_ix : np.ndarray + 1D array of indices of `vor_shapes` intersecting with `all_gridded` + + existing : np.ndarray + 1D array of indices of Polygons in `all_gridded` intersecting with + `vor_shapes` + + vor_uid : np.ndarray + 1D array of unique IDs corresponding with `vor_ix` + + gridded_uid : np.ndarray + 1D array of unique IDs corresponding with `existing` + + Returns + ------- + geopandas.GeoSeries + A GeoSeries based on `vor_shapes` that excludes the areas defined in + `all_gridded`. + """ + + calculated = [] + + iterator = range(len(vor_shapes)) + if show_bar: + iterator = tqdm(iterator) + for ix in iterator: + overlapping_ix = list(existing[(vor_ix == ix) & (gridded_uid != vor_uid)]) + if len(overlapping_ix) > 0: + overlapping_land = itemgetter(*overlapping_ix)(all_gridded) + uu = pygeos.union_all(overlapping_land) + remaining = pygeos.difference(vor_shapes[ix], uu) + else: + remaining = vor_shapes[ix] + calculated.append(remaining) + + return gpd.GeoSeries(calculated, crs=crs) + + +def get_voronoi_regions(full_regions): + """Computes a globally comprehensive set of shapes corresponding to the + nearest regions in each place from the set of `full_regions`. + + Parameters + ---------- + full_regions : :py:class:`geopandas.GeoDataFrame` + Contains regions for which you want to create Voronoi shapes + + Returns + ------- + out : :py:class:`geopandas.GeoDataFrame` + Same as input but with the geometry defined as the Voronoi shapes. + """ + + out_cols = [c for c in full_regions.columns if c != "geometry"] + + # avoiding GeoDataFrame.explode until geopandas v0.10.3 b/c of + # https://github.com/geopandas/geopandas/issues/2271 + # region_polys = full_regions.explode(index_parts=False) + region_polys = full_regions.drop(columns="geometry").join( + full_regions.geometry.explode(index_parts=False) + ) + + # This has been tested with up to 40 million coordinates, so cannot + # guarantee performance or memory usage on more complex shapefiles + assert ( + pygeos.count_coordinates(pygeos.from_shapely(region_polys.geometry.values)) + < sset.MAX_VORONOI_COMPLEXITY + ) + + gridded_gdf, all_oc = grid_gdf(region_polys) + + pts = polys_to_vor_pts(region_polys, all_oc) + + vor_gdf = get_spherical_voronoi_gser(pts).to_frame() + + vor_shapes = pygeos.from_shapely(vor_gdf["geometry"]) + all_gridded = pygeos.from_shapely(gridded_gdf["geometry"]) + + tree = pygeos.STRtree(all_gridded) + + vor_ix, existing = tree.query_bulk(vor_shapes, "intersects") + + gridded_uid = np.take(gridded_gdf.index.values, existing) + vor_uid = np.take(vor_gdf.index.values, vor_ix) + + vor_gdf["calculated"] = remove_already_attributed_land_from_vor( + vor_shapes, + all_gridded, + vor_ix, + existing, + vor_uid, + gridded_uid, + crs=full_regions.crs, + ).values + + full_regions = full_regions.join(vor_gdf.drop(columns="geometry"), how="left") + + full_regions["calculated"] = full_regions["calculated"].fillna(Polygon()) + + full_regions["combined"] = full_regions["geometry"].union( + full_regions["calculated"] + ) + + out = full_regions[full_regions.index.notnull()].combined.rename("geometry") + + out = out.apply(grab_polygons) + out = out.apply(strip_line_interiors) + + out = fill_in_gaps(out) + return gpd.GeoDataFrame(full_regions[out_cols].join(out, how="right")) + + +def get_points_along_segments(segments, tolerance=sset.DENSIFY_TOLERANCE): + """Get a set of points along line segments. Calls `pygeos.segmentize()` + to interpolate between endpoints of each line segment. + + Parameters + ---------- + segments : :py:class:`geopandas.GeoDataFrame` + Geometry column represents segments (as (Multi)LineStrings or + (Multi)Polygons). + + Returns + ------- + :py:class:`geopandas.GeoDataFrame` + GeoDataFrame of resulting endpoints and interpolated points, with same + non-geometry columns as ``segments``. + """ + + segments = segments[~segments.geometry.type.isnull()].copy() + + # avoiding GeoDataFrame.explode until geopandas v0.10.3 b/c of + # https://github.com/geopandas/geopandas/issues/2271 + # segments = segments.explode(index_parts=False) + segments = segments.drop(columns="geometry").join( + segments.geometry.explode(index_parts=False) + ) + + segments = segments[~segments["geometry"].is_empty].copy() + + segments["geometry"] = pygeos.segmentize( + pygeos.from_shapely(segments["geometry"]), tolerance + ) + + pts, pts_ix = pygeos.get_coordinates( + pygeos.from_shapely(segments["geometry"]), return_index=True + ) + + return gpd.GeoDataFrame( + segments.drop(columns="geometry").iloc[pts_ix], + geometry=gpd.points_from_xy(pts[:, 0], pts[:, 1]), + crs=segments.crs, + ) + + +def constrain_lons(arr, lon_mask): + if lon_mask is False: + return arr + out = arr.copy() + out = np.where((out > 180) & lon_mask, -360 + out, out) + out = np.where((out <= -180) & lon_mask, 360 + out, out) + return out + + +def grid_val_to_ix( + vals: Any, + cell_size: Union[int, Sequence], + map_nans: Union[int, Sequence] = None, + lon_mask: Union[bool, Sequence] = False, +) -> Any: + """Converts grid cell lon/lat/elevation values to i/j/k values. The function is + indifferent to order, of dimensions, but the order returned matches the order of the + inputs, which in turn must match the order of ``cell_size``. The origin of the grid + is the grid cell that has West, South, and bottom edges at (0,0,0) in + (lon, lat, elev) space, and we map everything to (-180,180] longitude. + + Parameters + ---------- + vals : array-like + The values in lon, lat, or elevation-space. The dimensions of this array should + be n_vals X n_dims (where dims is either 1, 2, or 3 depending on which of + lat/lon/elev are in the array). + cell_size : int or Sequence + The size of a cells along the dimensions included in ``vals``. If int, applies + to all columns of ``vals``. If Sequence, must be same length as the number of + columns of ``vals``. + map_nans : int or Sequence, optional + If not None, map this value in the input array to ``np.nan`` in the output + array. If int, applies to all columns of ``vals``. If Sequence, must be the same + length as ``vals``, with each element applied to the corresponding column of + ``vals``. + lon_mask : bool or array-like, optional + Specify an mask for values to constrain to (-180, 180] space. If value is a + bool, apply mask to all (True) or none of (False) the input ``vals``. If value + is array-like, must be broadcastable to the shape of ``vals`` and castable to + bool. + + Returns + ------- + out : array-like + An integer dtype object of the same type as vals defining the index of each grid + cell in ``vals``. + + Raises + ------ + ValueError + If `vals` contains null values but `map_nans` is None. + + Example + ------- + >>> import numpy as np + >>> lons = [-180.5, np.nan] + >>> lats = [-45, 0] + >>> elevs = [-5, 3.2] + >>> inputs = np.stack((lons, lats, elevs)).T + >>> grid_val_to_ix( + ... inputs, + ... cell_size=(.25, .25, .1), + ... map_nans=-9999, + ... lon_mask=np.array([1, 0, 0]) + ... ) # doctest: +NORMALIZE_WHITESPACE + array([[ 718, -180, -50], + [-9999, 0, 32]], dtype=int32) + """ + + # handle nans + nan_mask = np.isnan(vals) + is_nans = nan_mask.sum() + + out = vals.copy() + + if is_nans != 0: + if map_nans is None: + raise ValueError( + "NaNs not allowed in `vals`, unless `map_nans` is specified." + ) + else: + # convert to 0s to avoid warning in later type conversion + out = np.where(nan_mask, 0, out) + + out = constrain_lons(out, lon_mask) + + # convert to index + out = np.floor(out / cell_size).astype(np.int32) + + # fix nans to our chosen no data int value + if is_nans: + out = np.where(nan_mask, map_nans, out) + + return out + + +def grid_ix_to_val( + vals: Any, + cell_size: Union[int, Sequence], + map_nans: Union[int, Sequence] = None, + lon_mask: Union[bool, Sequence] = False, +) -> Any: + """Converts grid cell i/j/k values to lon/lat/elevation values. The function is + indifferent to order, of dimensions, but the order returned matches the order of the + inputs, which in turn must match the order of ``cell_size``. The origin of the grid + is the grid cell that has West, South, and bottom edges at (0,0,0) in + (lon, lat, elev) space, and we map everything to (-180,180] longitude. + + Parameters + ---------- + vals : array-like + The values in i, j, or k-space. The dimensions of this array should be + n_vals X n_dims (where dims is either 1, 2, or 3 depending on which of i/j/k are + in the array). + cell_size : Sequence + The size of a cells along the dimensions included in ``vals``. If int, applies + to all columns of ``vals``. If Sequence, must be same length as the number of + columns of ``vals``. + map_nans : int or Sequence, optional + If not None, map this value in the input array to ``np.nan`` in the output + array. If int, applies to all columns of ``vals``. If Sequence, must be the same + length as ``vals``, with each element applied to the corresponding column of + ``vals``. + lon_mask : bool or array-like, optional + Specify an mask for values to constrain to (-180, 180] space. If value is a + bool, apply mask to all (True) or none of (False) the input ``vals``. If value + is array-like, must be broadcastable to the shape of ``vals`` and castable to + bool. + + Returns + ------- + out : array-like + A float dtype object of the same type as vals defining the lat/lon/elev of each + grid cell in ``vals``. + + Raises + ------ + AssertionError + If `vals` is not an integer object + + Example + ------- + >>> i = [750, 100] + >>> j = [-3, 2] + >>> k = [-14, 34] + >>> inputs = np.stack((i, j, k)).T + >>> grid_ix_to_val( + ... inputs, + ... cell_size=(.25, .25, .1), + ... map_nans=-14, + ... lon_mask=np.array([1, 0, 0]) + ... ) # doctest: +NORMALIZE_WHITESPACE + array([[-172.375, -0.625, nan], + [ 25.125, 0.625, 3.45 ]]) + """ + + assert np.issubdtype(vals.dtype, np.integer) + + out = cell_size * (vals + 0.5) + out = constrain_lons(out, lon_mask) + + # apply nans + if map_nans is not None: + valid = vals != map_nans + out = np.where(valid, out, np.nan) + + return out + + +def great_circle_dist( + ax, + ay, + bx, + by, +): + """Calculate pair-wise Great Circle Distance (in km) between two sets of points. + + Note: ``ax``, ``ay``, ``bx``, ``by`` must be either: + a. 1-D, with the same length, in which case the distances are element-wise and + a 1-D array is returned, or + b. Broadcastable to a common shape, in which case a distance matrix is returned. + + Parameters + ---------- + ax, bx : array-like + Longitudes of the two point sets + ay, by : array-like + Latitudes of the two point sets + + Returns + ------- + array-like + The distance vector (if inputs are 1-D) or distance matrix (if inputs are + multidimensional and broadcastable to the same shape). + + Examples + -------- + We can calculate element-wise distances + + >>> lon1 = [0, 90] + >>> lat1 = [-45, 0] + >>> lon2 = [10, 100] + >>> lat2 = [-45, 10] + + >>> great_circle_dist(lon1, lat1, lon2, lat2) + array([ 785.76833086, 1568.52277257]) + + We can also create a distance matrix w/ 2-D inputs + + >>> lon1 = np.array(lon1)[:,np.newaxis] + >>> lat1 = np.array(lat1)[:,np.newaxis] + >>> lon2 = np.array(lon2)[np.newaxis,:] + >>> lat2 = np.array(lat2)[np.newaxis,:] + + >>> great_circle_dist(lon1, lat1, lon2, lat2) + array([[ 785.76833086, 11576.03341028], + [ 9223.29614889, 1568.52277257]]) + """ + radius = 6371.009 # earth radius + lat1, lon1, lat2, lon2 = map(np.radians, (ay, ax, by, bx)) + + # broadcast so it's easier to work with einstein summation below + if all(map(lambda x: isinstance(x, xr.DataArray), (lat1, lon1, lat2, lon2))): + broadcaster = xr.broadcast + else: + broadcaster = np.broadcast_arrays + lat1, lon1, lat2, lon2 = broadcaster(lat1, lon1, lat2, lon2) + + dlat = 0.5 * (lat2 - lat1) + dlon = 0.5 * (lon2 - lon1) + + # haversine formula: + hav = np.sin(dlat) ** 2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon) ** 2 + return 2 * np.arcsin(np.sqrt(hav)) * radius + + +def get_great_circle_nearest_index(df1, df2, x1="lon", y1="lat", x2="lon", y2="lat"): + """ + Finds the index in df2 of the nearest point to each element in df1 + + Parameters + ---------- + df1 : pandas.DataFrame + Points that will be assigned great circle nearest neighbors from df2 + df2 : pandas.DataFrame + Location of points to within which to select data + x1 : str + Name of x column in df1 + y1 : str + Name of y column in df1 + x2 : str + Name of x column in df2 + y2 : str + Name of y column in df2 + + Returns + ------- + nearest_indices : pandas.Series + :py:class:`pandas.Series` of indices in df2 for the nearest entries to + each row in df1, indexed by df1's index. + """ + + dists = great_circle_dist( + df1[[x1]].values, df1[[y1]].values, df2[x2].values, df2[y2].values + ) + + nearest_indices = pd.Series(df2.index.values[dists.argmin(axis=1)], index=df1.index) + + return nearest_indices + + +def coastlen_poly( + i, + coastlines_shp_path, + seg_adm_voronoi_parquet_path, + seg_var="seg_adm", + filesystem=None, +): + lensum = 0 + + # Import coastlines, CIAM seg and ADM1 voronoi polygons + clines = gpd.read_file(coastlines_shp_path) + poly = gpd.read_parquet( + seg_adm_voronoi_parquet_path, + filesystem=filesystem, + columns=["geometry"], + filters=[(seg_var, "=", i)], + ) + + assert len(poly) == 1 + + # Intersect polygon with coastlines + if not clines.intersects(poly.iloc[0].loc["geometry"]).any(): + return 0 + lines_int = gpd.overlay(clines, poly, how="intersection", keep_geom_type=True) + if len(lines_int) > 0: + for idx0 in range(len(lines_int)): + + def line_dist(line, npts=50): + dist = 0 + pts = get_points_on_lines(line, line.length / npts)[0] + for p in range(1, len(pts.geoms)): + dist += great_circle_dist( + pts.geoms[p - 1].x, + pts.geoms[p - 1].y, + pts.geoms[p].x, + pts.geoms[p].y, + ) + return dist + + line = lines_int.iloc[idx0] + + if line.geometry.type == "MultiLineString": + lines = line.geometry.explode() + for idx1 in range(len(lines)): + line = lines.iloc[idx1] + lensum += line_dist(line) + else: + lensum += line_dist(line.geometry) + + return lensum + + +def simplify_coastlines(coastlines): + """Read in coastlines and break them up into their component (2-point) + line segments + + Parameters + ---------- + coastlines : :py:class:`geopandas.GeoSeries` + GeoSeries containing a set of global coastline `LINESTRING`s. + + Returns + ------- + :py:class:`geopandas.GeoSeries` : + GeoSeries containing broken-up coastlines with their original + associated index. + + """ + + coords, linestring_ix = pygeos.get_coordinates( + pygeos.from_shapely(coastlines.values), return_index=True + ) + + start, end = coords[:-1], coords[1:] + + tiny_segs = pygeos.linestrings( + np.stack((start[:, 0], end[:, 0]), axis=1), + np.stack((start[:, 1], end[:, 1]), axis=1), + ) + + tiny_segs = tiny_segs[linestring_ix[:-1] == linestring_ix[1:]] + + linestring_ix = linestring_ix[:-1][linestring_ix[:-1] == linestring_ix[1:]] + + return gpd.GeoSeries( + tiny_segs, crs=coastlines.crs, index=coastlines.iloc[linestring_ix].index + ) + + +def join_coastlines_to_isos(coastlines, regions_voronoi): + """Get country-level coastlines by calculating intersection between + coastlines and countries. + + Parameters + ---------- + coastlines: :py:class:`geopandas.GeoSeries` + GeoSeries representing simplified global coastlines, i.e. outputs of + ``simplify_coastlines``. + + regions_voronoi: :py:class:`geopandas.GeoDataFrame` + GeoDataFrame including an `ISO` field and a `geometry` field. Should be globally + comprehensive, with a one-to-one mapping from coordinates to ISO values. + + Returns + ------- + joined : geopandas.GeoDataFrame + A GeoDataFrame with fields `region_geo`, `ISO`, and `geometry`, where `geometry` + represents the (entire) original linestring corresponding that overlaps with the + `region_geo` defined by ``regions_voronoi``. + """ + regions = regions_voronoi.to_crs(coastlines.crs) + + # Use regions as a proxy for countries. It's faster because the regions are more + # narrowly located than the countries in the STRtree, but could instead subdivide + # countries + tree = pygeos.STRtree(pygeos.from_shapely(regions["geometry"])) + + coastal_ix, region_ix = tree.query_bulk( + pygeos.from_shapely(coastlines), "intersects" + ) + + coastal_geo = coastlines.iloc[coastal_ix] + regions_out = regions.iloc[region_ix] + + joined = gpd.GeoDataFrame( + { + "region_geo": regions_out.geometry.values, + "ISO": regions_out.ISO.values, + }, + geometry=coastal_geo.values, + crs=coastal_geo.crs, + index=coastal_geo.index, + ) + + return joined + + +def get_coastlines_by_iso(coastlines, regions_voronoi, plot=True): + """Get country-level coastlines by calculating intersection between + coastlines and countries. + + Parameters + ---------- + coastlines : :py:class:`geopandas.GeoSeries` + GeoSeries containing a set of global coastline `LINESTRING`s. + + regions_voronoi: :py:class:`geopandas.GeoDataFrame` + GeoDataFrame including an `ISO` field and a `geometry` field. Should be globally + comprehensive, with a one-to-one mapping from coordinates to ISO values. + + plot : bool + True to see resulting coastlines by country, False to suppress plotting + + Returns + ------- + :py:class:`geopandas.GeoSeries` + Indexed by country, contains coastlines for each country. + """ + + # Get coastal components (line segments) + coastlines = simplify_coastlines(coastlines) + + # Get all matches between coastal components and regions + coastlines = join_coastlines_to_isos(coastlines, regions_voronoi) + + # Clip matched coastal components to the regions they are matched with + coastlines["geometry"] = coastlines["geometry"].intersection( + coastlines["region_geo"] + ) + coastlines = coastlines.drop(columns=["region_geo"]) + coastlines = coastlines[~coastlines["geometry"].is_empty] + + # Merge LineStrings where possible + coastlines["geometry"] = coastlines["geometry"].apply(grab_lines) + + out = coastlines.dissolve("ISO").geometry + + # Check output + if plot: + coastlines.reset_index(drop=False).plot( + color=add_rand_color(coastlines, col="ISO"), figsize=(20, 20) + ) + + return out + + +def get_coastal_segments_by_ciam_site(site_vor, coastlines, plot=True): + """Generate coastal segments corresponding to each CoDEC site. + + Parameters + ---------- + site_vor : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame with fields `ISO` and `geometry`, indexed by `station_id`, + where `geometry` represents the region of the globe corresponding + to the area closer to station `station_id` than any other station + in that `ISO`. (i.e. the output of ``get_stations_by_iso_voronoi``) + + coastlines : :py:class:`geopandas.GeoSeries` + Contains coastlines by country (i.e. the output of ``get_coastlines_by_iso``) + + Returns + ------- + coastal_segs : :py:class:`geopandas.GeoDataFrame` + Contains `ISO` and `geometry`, where `geometry` represents the coastline within + some ISO that is closer to the associated `station_id` than any other site + within that ISO. + """ + + # Join coastlines to CIAM site Voronoi + site_vor = site_vor.join(coastlines.rename("coastline"), on="ISO", how="left") + + assert site_vor["ISO"].isnull().sum() == 0 + + # Clip coastal segments within point-based Voronoi shapes + site_vor["segment"] = site_vor["coastline"].intersection(site_vor["geometry"]) + + coastal_segs = site_vor.drop(columns=["geometry", "coastline"]).rename( + columns={"segment": "geometry"} + ) + + # Merge LineStrings where possible + coastal_segs["geometry"] = coastal_segs["geometry"].apply(grab_lines) + + # Check output + if plot: + coastal_segs.plot(color=add_rand_color(coastal_segs, "ISO"), figsize=(20, 20)) + + return coastal_segs + + +def dist_matrix( + ax: Any, ay: Any, bx: Any, by: Any, radius: float = EARTH_RADIUS +) -> Any: + """Get the distance matrix (in km) between two sets of points defined by lat/lon. + + Parameters + ---------- + ax, bx : 1-d array-like + Longitudes of the two point sets + ay, by : 1-d array-like + Latitudes of the two point sets + + Returns + ------- + :class:`numpy.ndarray` + The distance distance matrix between the two point sets. + + Example + ------- + >>> lon1 = np.array([0, 90, 270]) + >>> lat1 = np.array([-45, 0, -60]) + >>> lon2 = np.array([10, 100]) + >>> lat2 = np.array([-45, 10]) + + >>> dist_matrix(lon1, lat1, lon2, lat2) + array([[ 785.76833086, 11576.03341028], + [ 9223.29614889, 1568.52277257], + [ 6289.84215841, 14393.39737057]]) + """ + + # broadcast manually + ax1 = ax[:, np.newaxis].repeat(bx.shape[0], axis=1) + ay1 = ay[:, np.newaxis].repeat(by.shape[0], axis=1) + bx1 = bx[np.newaxis, :].repeat(ax.shape[0], axis=0) + by1 = by[np.newaxis, :].repeat(ay.shape[0], axis=0) + + # get dist + return great_circle_dist(ax1, ay1, bx1, by1) + + +def create_overlay_voronois( + regions, seg_centroids, coastlines, overlay_name, plot=False +): + """Create two Voronoi objects necessary for assigning values to coastal segments in + SLIIDERS. + + Parameters + ---------- + regions : :py:class:`geopandas.GeoDataFrame` + Contains the Polygon/MultiPolygons of each region that you wish to run analyses + on separately. Columns are ``ISO`` and ``geometry``. Each region must be mapped + to a country (``ISO``). + seg_centroids : :py:class:`pandas.DataFrame` + Contains ``lon`` and ``lat`` columns, specifying the location of coastal segment + centroids. + coastlines : :py:class:`geopandas.GeoSeries` + Contains LineStrings representing global coastlines. The index is not important. + overlay_name : str + What you would like the variable representing each combination of segment and + region to be called + plot : bool + Whether to produce some diagnostic plots during calculation. Only valuable if + running in an interactive setting. + + Returns + ------- + all_overlays : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame representing Voronoi shapes, as administrative Voronoi + regions intersected with segment-based Voronoi regions. + + ciam_polys : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame representing segment-based Voronoi regions. + """ + # Generate global Voronoi shapes for regions + print("Generating global Voronoi shapes for regions...") + reg_vor = get_voronoi_regions(regions) + reg_vor["ISO"] = regions.ISO + adm0 = reg_vor.dissolve("ISO") + + # Assign ISO to seg centroids based on country Voronoi + print("Assigning countries to segment centroids...") + stations = ( + seg_centroids.rename("geometry") + .to_frame() + .sjoin(adm0, how="left", predicate="within") + .rename(columns={"index_right": adm0.index.name}) + ) + + # Generate ISO-level point-voronoi from CIAM points + print("Generating within-country Voronoi shapes for segment centroids...") + vor_gdf = get_stations_by_iso_voronoi(stations) + + # Get coastline by country + print("Generating country-level coastlines...") + coastlines_by_iso = get_coastlines_by_iso(coastlines, reg_vor, plot=plot) + + # Get coast-seg-by-CIAM point + print("Assigning segments to each centroid point...") + coastal_segs = get_coastal_segments_by_ciam_site( + vor_gdf, coastlines_by_iso, plot=plot + ) + + # Overlap coastline vor with region vor to get spatially comprehensive seg_reg. + print("Creating segment X region Voronoi shapes...") + return generate_voronoi_from_segments( + coastal_segs, + reg_vor, + overlay_name, + ) + + +def get_country_level_voronoi_gdf(all_pts_df): + """Get Voronoi diagram within a country based on a set of points derived + from that country's coastal segments. + + Parameters + ---------- + all_pts_df : :py:class:`geopandas.GeoDataFrame` + Voronoi-generator points within a country, containing `ISO` and `geometry` + columns. + + Returns + ------- + vor_gdf : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame representing Voronoi regions for each input point + """ + + all_isos = all_pts_df["ISO"].unique() + all_isos.sort() + + vors = [] + + for iso in all_isos: + print(iso, end=" ") + station_pts = all_pts_df[all_pts_df["ISO"] == iso].copy() + vors.append(get_voronoi_from_sites(station_pts)) + + vor_gdf = pd.concat(vors).drop( + ["placeholder1", "placeholder2", "placeholder3"], errors="ignore" + ) + + # Assign ISO to point-region shapes + assert vor_gdf["ISO"].isnull().sum() == 0 + + return vor_gdf + + +def generate_voronoi_from_segments(segments, region_gdf, overlay_name): + """Get global Voronoi diagram based on a set of coastal segments and + administrative regions. + + Parameters + ---------- + segments : :py:class:`geopandas.GeoDataFrame` + Coastal segments, including `ISO` column. + + region_gdf : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame representing administrative Voronoi regions + + overlay_name : str + Name of the field in the returned GeoDataFrame representing the + intersections between administrative Voronoi regions and segment-based + Voronoi regions. + + Returns + ------- + all_overlays : geopandas.GeoDataFrame + GeoDataFrame representing Voronoi shapes, as administrative Voronoi + regions intersected with segment-based Voronoi regions. + + ciam_polys : geopandas.GeoDataFrame + GeoDataFrame representing segment-based Voronoi regions. + """ + + all_pts_df = get_points_along_segments(segments) + + vor_gdf = get_country_level_voronoi_gdf(all_pts_df) + + # Calculate Voronoi diagram of all coastal segments, independent of ISO + all_stations_vor = get_voronoi_from_sites(all_pts_df.drop(columns="ISO")) + + # Join ISO-level Voronoi diagrams with country shapes to get final seg-region + # polygons + + coastal_isos = vor_gdf["ISO"].unique() + coastal_isos.sort() + landlocked_isos = sorted(list(set(region_gdf["ISO"].unique()) - set(coastal_isos))) + + coastal_overlays = [] + + for iso in tqdm(coastal_isos): + print(iso, end=" ") + + ciam_iso = vor_gdf[vor_gdf["ISO"] == iso].copy() + + region_iso = region_gdf[region_gdf["ISO"] == iso].copy() + + coastal_overlays.append( + gpd.overlay( + ciam_iso.reset_index(), + region_iso.reset_index().drop(columns=["ISO"]), + keep_geom_type=True, + ) + ) + + coastal_overlays = pd.concat(coastal_overlays, ignore_index=True) + + landlocked_overlays = [] + for iso in tqdm(landlocked_isos): + print(iso, end=" ") + + region_iso = region_gdf[region_gdf["ISO"] == iso].copy() + + landlocked_overlays.append( + gpd.overlay( + all_stations_vor.reset_index(), + region_iso.reset_index(), + keep_geom_type=True, + ) + ) + + if len(landlocked_overlays): + landlocked_overlays = pd.concat(landlocked_overlays, ignore_index=True) + all_overlays = pd.concat( + [landlocked_overlays, coastal_overlays], ignore_index=True + ) + else: + all_overlays = coastal_overlays + + assert all_overlays.is_valid.all() + + all_overlays["geometry"] = fill_in_gaps(all_overlays.geometry) + + all_overlays[overlay_name] = ( + "seg_" + + all_overlays[segments.index.name].str.split("_").str[-1] + + f"_{region_gdf.index.name}_" + + all_overlays[region_gdf.index.name].astype(str) + ) + + return all_overlays + + +def get_degree_box(row): + """ + Get a 1-degree box containing a centroid + defined by row["lon"] and row["lat"] + + Parameters + ---------- + row : dict + A dictionary including values for "lon" and "lat" indicating the center + of the 1-degree box + + Returns + ------- + shapely.Polygon + A Shapely box representing the spatial extent of the 1-degree tile + """ + return box( + row["lon"] - 0.5, + row["lat"] - 0.5, + row["lon"] + 0.5, + row["lat"] + 0.5, + ) + + +def get_tile_names(df, lon_col, lat_col): + """Get tile names in the format used by CoastalDEM. + Defined by the southeastern point's 2-digit degree-distance + north (N) or south (S) of the equator, and then its 3-digit + distance east (E) or west (W) of the prime meridian. + + Parameters + ---------- + df : pandas.DataFrame + DataFrame with latitude and longitude + + lon_col : str + Name of field representing longitude in `df` + + lat_col : str + Name of field representing latitude in `df` + + Returns + ------- + np.ndarray + Array of strings. Tile names defined by latitude and longitude. + """ + tlon = np.floor(df[lon_col]).astype(int) + tlat = np.floor(df[lat_col]).astype(int) + + NS = np.where(tlat >= 0, "N", "S") + EW = np.where(tlon >= 0, "E", "W") + + return ( + NS + + np.abs(tlat).astype(int).astype(str).str.zfill(2) + + EW + + np.abs(tlon).astype(int).astype(str).str.zfill(3) + ) + + +def get_all_exp_tiles(lon, lat): + """ + Get the list of CoastalDEM tiles included in an exposure dataset. + + Parameters + ---------- + lon, lat : array-like + Defines the longitude and latitude of valid grid cells in an exposure dataset + + Returns + ------- + :py:class:`numpy.ndarray` + 1D array of unique 1-degree tile names + + """ + exp = pd.DataFrame( + np.floor( + grid_ix_to_val( + np.stack((lon, lat)).T, + cell_size=sset.LITPOP_GRID_WIDTH, + lon_mask=[True, False], + ) + ).astype(int), + columns=["lon", "lat"], + ) + + lonlats = exp.drop_duplicates(["lon", "lat"]).reset_index(drop=True) + + lonlats["londir"] = np.where(lonlats["lon"] < 0, "W", "E") + lonlats["latdir"] = np.where(lonlats["lat"] < 0, "S", "N") + + lonlats["lonnum"] = np.abs(lonlats["lon"]).astype(int).astype(str).str.zfill(3) + lonlats["latnum"] = np.abs(lonlats["lat"]).astype(int).astype(str).str.zfill(2) + + lonlats["tile_name"] = ( + lonlats["latdir"] + lonlats["latnum"] + lonlats["londir"] + lonlats["lonnum"] + ) + + return lonlats["tile_name"].values + + +def get_bbox(tile_name): + """ + Return bounding box from tile name in the string format "VXXHYYY" + representing the southwestern corner of a 1-degree tile, where "V" is "N" + (north) or "S" (south), "H" is "E" (east) or "W" (west), "XX" is a + two-digit zero-padded number indicating the number of degrees north or + south from 0,0, and "YYY" is a three-digit zero-padded number indicating + the number of degrees east or west from 0,0. + + Parameters + ---------- + tile_name : str + Tile name in the format described above + + Returns + ------- + shapely.Polygon + A box representing the spatial coverage of the tile + """ + lat_term, lon_term = tile_name[:3], tile_name[3:] + + lat_direction, lat_value = lat_term[0], int(lat_term[1:]) + lon_direction, lon_value = lon_term[0], int(lon_term[1:]) + + lat_sign = 1 if lat_direction == "N" else -1 + lon_sign = 1 if lon_direction == "E" else -1 + + llat = lat_sign * lat_value + llon = lon_sign * lon_value + + ulat = llat + 1 + ulon = llon + 1 + + return box(llon, llat, ulon, ulat) + + +def get_partial_covering_matches(elev_tile, bbox, gdf, id_name=None): + """ + Get shapes in `gdf` that overlap with `bbox`, as flattened array corresponding + to the indices of `elev_tile` + + Parameters + ---------- + elev_tile : xarray.DataArray + Elevation raster tile + + bbox : shapely.Polygon + Bounding box of `elev_tile` + + gdf : geopandas.GeoDataFrame + GeoDataFrame containing geometries to match to `elev_tile` coordinates + + id_name : str + Field of `gdf` to use as IDs in returned `region_matches` + + Returns + ------- + region_matches : np.ndarray + 1D array of matches between `elev_tile` and `gdf`. Represented as a + flattened array along coordinates of `elev_tile`. If `id_name` is None, + returns flag indicating there is some match. If `id_name` is defined, + returns ID of the match, or -1 if there's no match. + """ + gdf = gdf[gdf["geometry"].intersects(bbox)].copy() + + gdf["geometry"] = gdf["geometry"].intersection(bbox) + gdf = gdf[gdf["geometry"].area > 0].copy() + + if len(gdf) == 0: + res = np.zeros(elev_tile.size, dtype=int) + if id_name is None: + return res + return res - 1 + + gdf = gdf.reset_index(drop=True) + + regions = regionmask.from_geopandas(gdf, names=id_name, name="regions") + + mask = regions.mask(elev_tile.x.values, elev_tile.y.values) + + if id_name is None: + mask = ~np.isnan(mask) + + mask_df = mask.astype(bool if id_name is None else int) + + mask_df = mask_df.to_pandas().stack().reset_index().rename(columns={0: "region_id"}) + + if id_name is None: + return mask_df["region_id"].to_numpy() + + mask_df.loc[mask_df["region_id"] < 0, "region_id"] = len(regions.names) + + region_matches = np.take( + np.array(regions.names + [-1]), np.array(mask_df["region_id"]) + ) + + return region_matches + + +def get_vor_matches(elev_tile, bbox, regions_df, id_name, out_name, assert_filled=True): + """For each pixel of `elev_tile`, assign the corresponding shape in + `regions_df`. + + Parameters + ---------- + elev_tile : xarray.DataArray + Elevation raster tile + + bbox : shapely.Polygon + Bounding box of `elev_tile` + + regions_df : geopandas.GeoDataFrame + GeoDataFrame containing geometries to match to `elev_tile` coordinates + + id_name : str + Field of `regions_df` to use as IDs in returned array + + out_name : str + Name to use for `id_name` field in output + + assert_filled : bool + Whether to assert that regions are defined over the entire `elev_tile` + + Returns + ------- + pandas.Series + Array of matches between `elev_tile` and `regions_df`, defined by the field + `id_name` in `regions_df`. + + """ + regions = regionmask.from_geopandas(regions_df, names=id_name, name=out_name) + + mask = regions.mask(elev_tile.x.values, elev_tile.y.values, wrap_lon=False) + + # if there are pixels without shapes, buffer shapes + assert mask.isnull().sum().item() == 0 + mask_df = ( + mask.astype(int) + .to_pandas() + .stack() + .reset_index() + .rename(columns={0: "region_ix"}) + ) + + if assert_filled: + assert (mask_df["region_ix"] < 0).sum() == 0 + else: + mask_df.loc[mask_df["region_ix"] < 0, "region_ix"] = len(regions.names) + + mask_df[out_name] = np.take( + np.array(regions.names + [""]), np.array(mask_df["region_ix"]) + ) + + return mask_df[out_name] + + +def get_empty_exp_grid(elev_tile, grid_width): + """Initialize DataFrame template representing an exposure tile covering + the same space as `elev_tile`. + + Parameters + ---------- + elev_tile : xarray.DataArray + Elevation raster tile + + grid_width : float + Width of grid cells indexing exposure, in degrees + + Returns + ------- + df : pandas.DataFrame + DataFrame with fields `lat`, `lon`, `x_ix`, and `y_ix`, providing + template to fill in exposure fields like asset value and population + """ + + mg = np.meshgrid(elev_tile.x.values, elev_tile.y.values) + + df = pd.DataFrame({"lat": mg[1].flatten(), "lon": mg[0].flatten()}) + + df["x_ix"] = grid_val_to_ix(df["lon"], grid_width) + df["y_ix"] = grid_val_to_ix(df["lat"], grid_width) + + out_types = { + "lat": np.float32, + "lon": np.float32, + "x_ix": np.int16, + "y_ix": np.int16, + } + + df = df.astype({k: v for k, v in out_types.items() if k in df.columns}) + + return df + + +def get_cell_size_km(elev_tile, bbox): + """Get approximate size of a grid cell in `elev_tile`. Assumes the median + latitude extends over the entire cell, so that all grid cells are equal in + size. Could be improved by evaluating size at each pixel's latitude in + `elev_tile`. + + Parameters + ---------- + elev_tile : xarray.DataArray + Elevation raster tile + + bbox : shapely.Polygon + Bounding box of `elev_tile` + + Returns + ------- + cell_size_km : float + Approximate size in km2 of each pixel in `elev_tile` + + """ + + # grid cell area is determined by latitude + tile_size_km = np.cos(np.deg2rad(bbox.centroid.y)) * (LAT_TO_M / 1000) ** 2 + cell_size_km = tile_size_km / elev_tile.size + + return cell_size_km + + +def get_closest_valid_exp_tiles( + missing_exp_tiles, valid_exp_tiles, max_batch_comparisons=int(2e7) +): + """Get the closest valid exposure tiles to the invalid tiles with exposure + values that need to be re-assigned. + + Parameters + ---------- + missing_exp_tiles : pandas.DataFrame + Tiles with attributed exposure (asset value or population) that do not + overlap any land areas in the Digital Elevation Model. + + valid_exp_tiles : pandas.DataFrame + Tiles that overlap land areas in the Digital Elevation Model. (i.e., + candidates for re-assignment of the missing exposure) + + max_batch_comparisons : int + Maximum number of simultaneous comparisons to make using + `dist_matrix()`. High number of comparisons can reduce computation time + but increase memory footprint. + + Returns + ------- + pandas.DataFrame + DataFrame mapping `missing_exp_tiles` to their closest + `valid_exp_tiles`. Original indices are `x_ix` and `y_ix`, and the + valid indices are labelled `valid_x_ix` and `valid_y_ix`. + """ + + if len(valid_exp_tiles) == 0: + return None + + src_locs = missing_exp_tiles[["lon", "lat"]].to_numpy() + dst_locs = valid_exp_tiles[["lon", "lat"]].to_numpy() + + total_comparisons = len(src_locs) * len(dst_locs) + + closest_ix = np.zeros(len(src_locs), dtype=int) - 1 + + num_batches = int(total_comparisons / max_batch_comparisons) + 1 + batch_size_src = int(len(src_locs) / num_batches) + + for batch in range(num_batches): + batch_start = batch * batch_size_src + batch_end = min((batch + 1) * batch_size_src, len(src_locs)) + closest_ix_batch = dist_matrix( + src_locs[batch_start:batch_end, 0], + src_locs[batch_start:batch_end, 1], + dst_locs[:, 0], + dst_locs[:, 1], + ).argmin(axis=1) + + closest_ix[batch_start:batch_end] = closest_ix_batch + + missing_exp_tiles["closest_ix"] = closest_ix + + missing_exp_tiles["valid_x_ix"] = np.take( + valid_exp_tiles["x_ix"].to_numpy(), + missing_exp_tiles["closest_ix"].to_numpy(), + ) + missing_exp_tiles["valid_y_ix"] = np.take( + valid_exp_tiles["y_ix"].to_numpy(), + missing_exp_tiles["closest_ix"].to_numpy(), + ) + + return missing_exp_tiles[["x_ix", "y_ix", "valid_x_ix", "valid_y_ix"]] + + +def get_granular_grid(bbox, grid_width=3601, cap=sset.ELEV_CAP): + """Generate a dummy grid on a 1-degree tile using the same format and level + of granularity as the elevation tiles used in `sliiders` (i.e. 1 arcsec). + + Parameters + ---------- + bbox : shapely.Polygon + Bounding box of the 1-degree tile + + grid_width : int + Number of pixels to use as width and height in the area defined by + `bbox`. + + cap : int + An arbitrary integer higher than any elevations saved in SLIIDERS-ECON + outputs. Allows compatibility with functions that process elevation + tiles. + + Returns + ------- + granular_grid : xarray.DataArray + Grid with a dummy elevation variable set at `cap`, in the same format + as `sliiders` 1-degree elevation tiles. + + """ + + size = 1 / grid_width + + llon, llat, ulon, ulat = bbox.bounds + + lons_small = np.arange(llon + (size / 2), ulon, size) + lats_small = np.flip(np.arange(llat + (size / 2), ulat, size)) + + xx, yy = [i.flatten() for i in np.meshgrid(lons_small, lats_small)] + + granular_grid = pd.DataFrame( + {"y": yy, "x": xx, "v": cap * np.ones(grid_width**2)} + ).set_index(["y", "x"]) + granular_grid = granular_grid.to_xarray().v + + return granular_grid + + +def process_landscan( + landscan_zip, + dir_landscan_raw, + dir_landscan_int, + landscan_year, + save_to_file=True, + NWORKERS=20, +): + """Convert raw LandScan Zip-file into format suitable for global `sliiders` + grid. + + Parameters + ---------- + landscan_zip : pathlib.Path + Path to raw Zip-file downloaded from LandScan + + dir_landscan_raw : pathlib.Path + Path to unzipped LandScan directory containing raw files + + dir_landscan_int : pathlib.Path + Path to directory in which to store output of this function + + landscan_year : str + Year (i.e. version) of LandScan dataset, e.g. "2019" + + save_to_file : bool + Whether to save the output in a file. If True, two files will be saved + within `dir_landscan_int`, one with `x_ix`, `y_ix`, and `population`, + and another with the additional fields `x` and `y` to represent + longitude and latitude. + + NWORKERS : int + Number of Dask workers with which to run this function. + + Returns + ------- + pop_df : pandas.DataFrame + DataFrame of global population indexed by `x_ix`, `y_ix` coordinates + """ + warnings.filterwarnings("ignore", message=".*Reshaping is producing a large chunk*") + + # Unzipping + path_landscan = dir_landscan_raw / f"lspop{landscan_year}" / "hdr.adf" + + if not path_landscan.exists(): + with zipfile.ZipFile(landscan_zip, "r") as zip_ref: + zip_ref.extractall(dir_landscan_raw) + + # Organizing TIF to parquet + + image_name = sset.DASK_IMAGE + gateway = Gateway() + cluster = gateway.new_cluster(worker_image=image_name, profile="micro") + client = cluster.get_client() + cluster.scale(NWORKERS) + display(cluster) + + # Open raw population raster + + pop_ds = rioxarray.open_rasterio(path_landscan, chunks={"x": 2700, "y": 10440}) + pop_ds = pop_ds.squeeze().drop("band") + + # Replace null values with 0's + pop_ds = pop_ds.where(pop_ds >= 0, 0) + pop_ds = pop_ds.persist() + + # Transform to dataframe + + pop_da = pop_ds.to_dataset(name="population") + pop_ddf = pop_da.to_dask_dataframe() + pop_ddf = pop_ddf.drop(columns=["spatial_ref"]) + pop_ddf = pop_ddf.persist() + pop_ddf = pop_ddf[pop_ddf["population"] > 0].persist() + + # Bring to local + pop_df = pop_ddf.compute() + + # Convert coordinates to indices + + pop_df["x_ix"] = grid_val_to_ix(pop_df["x"].to_numpy(), sset.LANDSCAN_GRID_WIDTH) + + pop_df["y_ix"] = grid_val_to_ix(pop_df["y"].to_numpy(), sset.LANDSCAN_GRID_WIDTH) + + # Drop unnecessary columns + + pop_with_xy = pop_df.copy() + pop_df = pop_df.drop(columns=["x", "y"]).reset_index(drop=True) + pop_with_xy = pop_with_xy.reset_index(drop=True) + + # Save and shut down workers + if save_to_file: + dir_landscan_int.mkdir(exist_ok=True) + pop_df.to_parquet(dir_landscan_int / "population.parquet", index=False) + pop_with_xy.to_parquet( + dir_landscan_int / "population_with_xy.parquet", index=False + ) + + cluster.scale(0) + client.close() + cluster.close() + cluster.shutdown() + + return pop_df + + +def interpolate_da_like(da_in, da_out): + """Based on the coordinates of `da_out`, interpolate (bicubic) the data that is + contained in `da_in`; both `da_in` and `da_out` need to be `xarray.DataArray`s in + two-dimensional grid format, with coordinates `lon` and `lat`. + + Parameters + ---------- + da_in : xarray.DataArray + containing data that needs interpolation + da_out : xarray.DataArray + containing grid structure that `da_in` data will be interpolated over + + Returns + ------- + xarray.DataArray + containing bicubic interpolated version of `da_in` based on the grids of + `da_out` + + """ + + xx, yy = np.meshgrid(da_out.lon.values, da_out.lat.values) + interpolator = Grid2D(da_in, geodetic=True) + interp_out = interpolator.bicubic(coords={"lon": xx.flatten(), "lat": yy.flatten()}) + + return xr.DataArray( + interp_out.reshape(len(da_out.lat), len(da_out.lon)), + dims=["lat", "lon"], + coords=dict(da_out.coords), + ) diff --git a/tests/placeholder.txt b/tests/placeholder.txt new file mode 100644 index 0000000..e69de29