diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 0f1e226a..f3de3f3c 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -4,6 +4,7 @@ Changelog master ------ +- (`#80 `_) Changed the names of crunchers for brevity. Also changed ``lead_gas`` to ``latest_time_ratio`` and included it in ratio notebook. - (`#78 `_) Changed how quantile rolling windows works by adding an extra interpolate step for smoothness - (`#77 `_) Added calculation of variance of rank correlation to stats - (`#76 `_) Removed command-line interface diff --git a/Makefile b/Makefile index cda1f733..cc0ed56c 100644 --- a/Makefile +++ b/Makefile @@ -59,6 +59,16 @@ black: $(VENV_DIR) ## use black to autoformat code echo Not trying any formatting, working directory is dirty... >&2; \ fi; +.PHONY: checks +checks: $(VENV_DIR) ## run checks similar to CI + @echo "=== black ==="; $(VENV_DIR)/bin/black --check src tests setup.py docs/source/conf.py --exclude silicone/_version.py || echo "--- black failed ---" >&2; \ + echo "\n\n=== isort ==="; $(VENV_DIR)/bin/isort --check-only --quiet --recursive src tests setup.py || echo "--- isort failed ---" >&2; \ + echo "\n\n=== docs ==="; $(VENV_DIR)/bin/sphinx-build -M html docs/source docs/build -qW || echo "--- docs failed ---" >&2; \ + echo "\n\n=== notebook tests ==="; $(VENV_DIR)/bin/pytest notebooks -r a --nbval --sanitize-with tests/notebook-tests.cfg || echo "--- notebook tests failed ---" >&2; \ + echo "\n\n=== tests ==="; $(VENV_DIR)/bin/pytest tests -r a --cov=silicone --cov-report='' \ + && $(VENV_DIR)/bin/coverage report --fail-under=95 || echo "--- tests failed ---" >&2; \ + echo + .PHONY: test-all test-all: ## run the testsuite and test the notebooks make test diff --git a/docs/source/database-crunchers.rst b/docs/source/database-crunchers.rst index d15b0219..be47801b 100644 --- a/docs/source/database-crunchers.rst +++ b/docs/source/database-crunchers.rst @@ -12,10 +12,10 @@ Closest RMS cruncher API .. automodule:: silicone.database_crunchers.rms_closest :members: -Lead gas cruncher API +Latest Time Ratio API ===================== -.. automodule:: silicone.database_crunchers.lead_gas +.. automodule:: silicone.database_crunchers.latest_time_ratio :members: diff --git a/notebooks/00_Introductory_infilling.ipynb b/notebooks/00_Introductory_infilling.ipynb index 7ae73e18..17d48ad8 100644 --- a/notebooks/00_Introductory_infilling.ipynb +++ b/notebooks/00_Introductory_infilling.ipynb @@ -625,7 +625,7 @@ } ], "source": [ - "print(silicone.database_crunchers.DatabaseCruncherRMSClosest.__doc__)" + "print(silicone.database_crunchers.RMSClosest.__doc__)" ] }, { @@ -780,9 +780,7 @@ "metadata": {}, "outputs": [], "source": [ - "cruncher = silicone.database_crunchers.DatabaseCruncherRMSClosest(\n", - " sr15_data_closest_rms\n", - ")" + "cruncher = silicone.database_crunchers.RMSClosest(sr15_data_closest_rms)" ] }, { @@ -802,7 +800,7 @@ "output_type": "stream", "text": [ "\n", - " Filler function derived from :obj:`DatabaseCruncherRMSClosest`.\n", + " Filler function derived from :obj:`RMSClosest`.\n", "\n", " Parameters\n", " ----------\n", diff --git a/notebooks/03_Ratio_based_crunchers.ipynb b/notebooks/03_Ratio_based_crunchers.ipynb index b4203b1f..5c2968a4 100644 --- a/notebooks/03_Ratio_based_crunchers.ipynb +++ b/notebooks/03_Ratio_based_crunchers.ipynb @@ -137,24 +137,25 @@ " Once the relationship is derived, the 'filler' function will infill following:\n", "\n", " .. math::\n", - " E_f(t) = s(t) * E_l(t)\n", + " E_f(t) = R(t) * E_l(t)\n", "\n", " where :math:`E_f(t)` is emissions of the follower variable and :math:`E_l(t)` is\n", " emissions of the lead variable.\n", "\n", - " :math:`s(t)` is the scaling factor, calculated as the ratio of the means of the\n", - " the follower and the leader in the cruncher in the database (by default, including\n", - " only cases where `sign(E_l(t))` is the same in both databases).\n", + " :math:`R(t)` is the scaling factor, calculated as the ratio of the means of the\n", + " the follower and the leader in the infiller database, denoted with\n", + " lower case e. By default, we include only cases where `sign(e_l(t))` is the same in\n", + " both databases).\n", "\n", " .. math::\n", - " s(t) = \\frac{mean( E_f(t) )}{mean( E_l(t) )})\n", + " R(t) = \\frac{mean( e_f(t) )}{mean( e_l(t) )})\n", "\n", " \n" ] } ], "source": [ - "print(silicone.database_crunchers.DatabaseCruncherTimeDepRatio.__doc__)" + "print(silicone.database_crunchers.TimeDepRatio.__doc__)" ] }, { @@ -187,7 +188,7 @@ "output_type": "stream", "text": [ "\n", - " Filler function derived from :obj:`DatabaseCruncherTimeDepRatio`.\n", + " Filler function derived from :obj:`TimeDepRatio`.\n", "\n", " Parameters\n", " ----------\n", @@ -205,24 +206,10 @@ " The key year for filling is not in ``in_iamdf``.\n", " \n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:105: RuntimeWarning: invalid value encountered in greater\n", - " pos_inds = data_leader[year].values > 0\n", - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:110: RuntimeWarning: Mean of empty slice\n", - " data_follower[year].iloc[~pos_inds].values\n", - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:111: RuntimeWarning: Mean of empty slice\n", - " ) / np.nanmean(data_leader[year].iloc[~pos_inds].values)\n" - ] } ], "source": [ - "cruncher = silicone.database_crunchers.DatabaseCruncherTimeDepRatio(\n", - " sr15_data_tdr\n", - ")\n", + "cruncher = silicone.database_crunchers.TimeDepRatio(sr15_data_tdr)\n", "filler = cruncher.derive_relationship(\"Emissions|VOC\", [\"Emissions|CO2\"])\n", "print(filler.__doc__)" ] @@ -472,8 +459,8 @@ " variable\n", " unit\n", " year\n", - " meta\n", " subannual\n", + " meta\n", " value\n", " \n", " \n", @@ -486,8 +473,8 @@ " Emissions|VOC\n", " Mt VOC/yr\n", " 2005\n", - " 0\n", " 0.0\n", + " 0\n", " 179.812508\n", " \n", " \n", @@ -498,8 +485,8 @@ " Emissions|VOC\n", " Mt VOC/yr\n", " 2010\n", - " 0\n", " 0.0\n", + " 0\n", " 181.936050\n", " \n", " \n", @@ -510,8 +497,8 @@ " Emissions|VOC\n", " Mt VOC/yr\n", " 2020\n", - " 0\n", " 0.0\n", + " 0\n", " 187.377500\n", " \n", " \n", @@ -522,8 +509,8 @@ " Emissions|VOC\n", " Mt VOC/yr\n", " 2030\n", - " 0\n", " 0.0\n", + " 0\n", " 177.988676\n", " \n", " \n", @@ -534,8 +521,8 @@ " Emissions|VOC\n", " Mt VOC/yr\n", " 2040\n", - " 0\n", " 0.0\n", + " 0\n", " 157.738311\n", " \n", " \n", @@ -543,19 +530,19 @@ "" ], "text/plain": [ - " model scenario region variable unit year meta \\\n", - "0 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2005 0 \n", - "1 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2010 0 \n", - "2 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2020 0 \n", - "3 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2030 0 \n", - "4 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2040 0 \n", + " model scenario region variable unit year subannual \\\n", + "0 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2005 0.0 \n", + "1 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2010 0.0 \n", + "2 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2020 0.0 \n", + "3 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2030 0.0 \n", + "4 AIM/CGE 2.0 SSP2-34 World Emissions|VOC Mt VOC/yr 2040 0.0 \n", "\n", - " subannual value \n", - "0 0.0 179.812508 \n", - "1 0.0 181.936050 \n", - "2 0.0 187.377500 \n", - "3 0.0 177.988676 \n", - "4 0.0 157.738311 " + " meta value \n", + "0 0 179.812508 \n", + "1 0 181.936050 \n", + "2 0 187.377500 \n", + "3 0 177.988676 \n", + "4 0 157.738311 " ] }, "execution_count": 8, @@ -681,25 +668,12 @@ "cell_type": "code", "execution_count": 11, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:110: RuntimeWarning: Mean of empty slice\n", - " data_follower[year].iloc[~pos_inds].values\n", - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:111: RuntimeWarning: Mean of empty slice\n", - " ) / np.nanmean(data_leader[year].iloc[~pos_inds].values)\n" - ] - } - ], + "outputs": [], "source": [ "sr15_data_tdr_red = sr15_data_tdr.filter(\n", " scenario=[\"*Baseline\", \"*-60\"], keep=False\n", ").filter(scenario=\"SSP*\", keep=True)\n", - "cruncher = silicone.database_crunchers.DatabaseCruncherTimeDepRatio(\n", - " sr15_data_tdr_red\n", - ")\n", + "cruncher = silicone.database_crunchers.TimeDepRatio(sr15_data_tdr_red)\n", "filler_same_sign = cruncher.derive_relationship(\n", " \"Emissions|VOC\", [\"Emissions|CO2\"], same_sign=True\n", ")\n", @@ -776,16 +750,6 @@ "text": [ "Attempt to infill ['Emissions|CO2'] data using the time_dep_ratio cruncher where the infillee data has a sign not seen in the infiller database for year 2080.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:107: RuntimeWarning: Mean of empty slice\n", - " data_follower[year].iloc[pos_inds].values\n", - "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\database_crunchers\\time_dep_ratio.py:108: RuntimeWarning: Mean of empty slice\n", - " ) / np.nanmean(data_leader[year].iloc[pos_inds].values)\n" - ] } ], "source": [ @@ -793,9 +757,7 @@ " scenario=[\"SSP1-19\", \"SSP1-26\"], keep=True\n", ")\n", "# These are cases where CO2 goes negative\n", - "cruncher = silicone.database_crunchers.DatabaseCruncherTimeDepRatio(\n", - " sr15_data_tdr_red\n", - ")\n", + "cruncher = silicone.database_crunchers.TimeDepRatio(sr15_data_tdr_red)\n", "filler_same_sign = cruncher.derive_relationship(\n", " \"Emissions|VOC\", [\"Emissions|CO2\"], same_sign=True\n", ")\n", @@ -859,6 +821,310 @@ "plt.tight_layout()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Latest time ratio\n", + "This infiller uses only a single timepoint to calculate the ratio between the lead data in the infillee database and the follower data in the infillee database. It is designed for the case where we have historic data up to a certain point. In the event that there is more than one data series at that time, the mean value is taken. All infilled timeseries will have the same follower value at that timepoint. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Database cruncher which uses the 'latest time ratio' technique.\n", + "\n", + " This cruncher derives the relationship between two variables by simply assuming\n", + " that the follower timeseries is equal to the lead timeseries multiplied by a\n", + " scaling factor. The scaling factor is derived by calculating the ratio of the\n", + " follower variable to the lead variable in the latest year in which the follower\n", + " variable is available in the database. Additionally, since\n", + " the derived relationship only depends on a single point in the database, no\n", + " regressions or other calculations are performed.\n", + "\n", + " Once the relationship is derived, the 'filler' function will infill following:\n", + "\n", + " .. math::\n", + " E_f(t) = R * E_l(t)\n", + "\n", + " where :math:`E_f(t)` is emissions of the follower variable and :math:`E_l(t)` is\n", + " emissions of the lead variable, both in the infillee database.\n", + "\n", + " :math:`R` is the scaling factor, calculated as\n", + "\n", + " .. math::\n", + " R = \\frac{ E_f(t_{\\text{last}}) }{ e_l(t_{\\text{last}}) }\n", + "\n", + " where :math:`t_{\\text{last}}` is the average of all values of the follower gas at the latest time it\n", + " appears in the database, and the lower case :math:`e` represents the infiller\n", + " database.\n", + " \n" + ] + } + ], + "source": [ + "print(silicone.database_crunchers.LatestTimeRatio.__doc__)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Filler function derived from :obj:`LatestTimeRatio`.\n", + "\n", + " Parameters\n", + " ----------\n", + " in_iamdf : :obj:`pyam.IamDataFrame`\n", + " Input data to fill data in\n", + "\n", + " interpolate : bool\n", + " If the key year for filling is not in ``in_iamdf``, should a value be\n", + " interpolated?\n", + "\n", + " Returns\n", + " -------\n", + " :obj:`pyam.IamDataFrame`\n", + " Filled in data (without original source data)\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " The key year for filling is not in ``in_iamdf`` and ``interpolate is\n", + " False``.\n", + " \n" + ] + } + ], + "source": [ + "# To make sensible use of this, we will remove all data for one HFC except for in the chosen timeseries.\n", + "pretend_history = sr15_data.filter(model=\"MESSAGE-GLOBIOM*\").filter(\n", + " year=[2010, 2015]\n", + ")\n", + "follow = \"Emissions|HFC|HFC125\"\n", + "lead = [\"Emissions|F-Gases\"]\n", + "cruncher = silicone.database_crunchers.LatestTimeRatio(pretend_history)\n", + "filler = cruncher.derive_relationship(follow, lead)\n", + "print(filler.__doc__)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
modelscenarioregionvariableunityearsubannualmetavalue
0AIM/CGE 2.0ADVANCE_2020_1.5C-2100WorldEmissions|HFC|HFC125kt HFC125/yr200523.379685
1AIM/CGE 2.0ADVANCE_2020_1.5C-2100WorldEmissions|HFC|HFC125kt HFC125/yr201031.104153
2AIM/CGE 2.0ADVANCE_2020_1.5C-2100WorldEmissions|HFC|HFC125kt HFC125/yr201536.345708
3AIM/CGE 2.0ADVANCE_2020_1.5C-2100WorldEmissions|HFC|HFC125kt HFC125/yr202041.583937
4AIM/CGE 2.0ADVANCE_2020_1.5C-2100WorldEmissions|HFC|HFC125kt HFC125/yr202524.850936
\n", + "
" + ], + "text/plain": [ + " model scenario region variable \\\n", + "0 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|HFC|HFC125 \n", + "1 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|HFC|HFC125 \n", + "2 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|HFC|HFC125 \n", + "3 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|HFC|HFC125 \n", + "4 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|HFC|HFC125 \n", + "\n", + " unit year subannual meta value \n", + "0 kt HFC125/yr 2005 23.379685 \n", + "1 kt HFC125/yr 2010 31.104153 \n", + "2 kt HFC125/yr 2015 36.345708 \n", + "3 kt HFC125/yr 2020 41.583937 \n", + "4 kt HFC125/yr 2025 24.850936 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a database to infill\n", + "sr15_data_latest = sr15_data.filter(model=\"AIM*\").filter(\n", + " variable=follow, keep=False\n", + ")\n", + "result = filler(sr15_data_latest)\n", + "result.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 AIM/CGE 2.0\n", + "1 AIM/CGE 2.1\n", + "Name: model, dtype: object" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sr15_data_latest.models()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "pyam.plotting - INFO: >=13 labels, not applying legend\n", + "pyam.plotting - INFO: >=13 labels, not applying legend\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(16, 9))\n", + "ax = fig.add_subplot(121)\n", + "sr15_data_latest.filter(variable=lead).line_plot(ax=ax)\n", + "ax = fig.add_subplot(122)\n", + "result.line_plot(ax=ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly the output values match the input values, rescaled to meet the input prediction at the latest time for which data is found in the database (2015). Note that data before this (2010) shows some spread - if we have historically accurate data for this time too, we will need to re-harmonise for it. " + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -869,7 +1135,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -894,12 +1160,12 @@ } ], "source": [ - "print(silicone.database_crunchers.DatabaseCruncherConstantRatio.__doc__)" + "print(silicone.database_crunchers.ConstantRatio.__doc__)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "metadata": { "scrolled": true }, @@ -909,7 +1175,7 @@ "output_type": "stream", "text": [ "\n", - " Filler function derived from :obj:`DatabaseCruncherTimeDepRatio`.\n", + " Filler function derived from :obj:`TimeDepRatio`.\n", "\n", " Parameters\n", " ----------\n", @@ -930,9 +1196,7 @@ } ], "source": [ - "cruncher = (\n", - " silicone.database_crunchers.DatabaseCruncherConstantRatio()\n", - ") # No input needed.\n", + "cruncher = silicone.database_crunchers.ConstantRatio() # No input needed.\n", "filler = cruncher.derive_relationship(\n", " \"Emissions|VOC\", [\"Emissions|CO2\"], 0.5, \"kt VOC/yr\"\n", ")\n", @@ -941,7 +1205,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1057,7 +1321,7 @@ "144655 0.0 0 5762.064700 " ] }, - "execution_count": 18, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1072,7 +1336,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1081,7 +1345,7 @@ "Text(0.5, 1.0, 'Database CO2 and lead emissions timeseries')" ] }, - "execution_count": 19, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, diff --git a/notebooks/04_Interpolation-based_crunchers.ipynb b/notebooks/04_Interpolation-based_crunchers.ipynb index 89f22e6d..c99ffd63 100644 --- a/notebooks/04_Interpolation-based_crunchers.ipynb +++ b/notebooks/04_Interpolation-based_crunchers.ipynb @@ -85,15 +85,13 @@ "\n", " Database cruncher which pre-filters to only use data from specific scenarios, then\n", " runs the linear interpolator to return values from that set of scenarios. See the\n", - " documentation of DatabaseCruncherLinearInterpolation for more details.\n", + " documentation of LinearInterpolation for more details.\n", " \n" ] } ], "source": [ - "print(\n", - " silicone.database_crunchers.DatabaseCruncherScenarioAndModelSpecificInterpolate.__doc__\n", - ")" + "print(silicone.database_crunchers.ScenarioAndModelSpecificInterpolate.__doc__)" ] }, { @@ -129,7 +127,7 @@ } ], "source": [ - "print(silicone.database_crunchers.DatabaseCruncherLinearInterpolation.__doc__)" + "print(silicone.database_crunchers.LinearInterpolation.__doc__)" ] }, { @@ -323,7 +321,7 @@ "metadata": {}, "outputs": [], "source": [ - "cruncher = silicone.database_crunchers.DatabaseCruncherScenarioAndModelSpecificInterpolate(\n", + "cruncher = silicone.database_crunchers.ScenarioAndModelSpecificInterpolate(\n", " sr15_data_message\n", ")\n", "filler = cruncher.derive_relationship(\n", @@ -409,7 +407,7 @@ ").filter(model=[\"AIM*\"], keep=False)\n", "\n", "\n", - "cruncher = silicone.database_crunchers.DatabaseCruncherScenarioAndModelSpecificInterpolate(\n", + "cruncher = silicone.database_crunchers.ScenarioAndModelSpecificInterpolate(\n", " too_much_data\n", ")\n", "filler = cruncher.derive_relationship(\n", diff --git a/notebooks/05_Multiple_infillers.ipynb b/notebooks/05_Multiple_infillers.ipynb index 42837a94..d691cc34 100644 --- a/notebooks/05_Multiple_infillers.ipynb +++ b/notebooks/05_Multiple_infillers.ipynb @@ -8,7 +8,7 @@ "\n", "Here we investigate three infillers that perform many cruncher operations. The first one is designed to infill all required data for running openSCM, with the minimum of inputs. One is designed to break down aggregate values, like the Kyoto gases or HFCs. The second does the opposite, recalculating aggregates from its components. These functions are purposefully not as object-oriented as the crunchers so that modellers unfamiliar with this coding structure can use them. \n", "\n", - "You will need to install silicone from https://github.com/znicholls/silicone/ in order to run this code. " + "You will need to install silicone in order to run this code. " ] }, { @@ -47,20 +47,16 @@ "import os.path\n", "import traceback\n", "\n", - "import pandas as pd\n", - "import pyam\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import pandas as pd\n", + "import pyam\n", "\n", "import silicone.multiple_infillers as mi\n", "from silicone.utils import (\n", - " _get_unit_of_variable,\n", - " find_matching_scenarios,\n", - " _make_interpolator,\n", - " _make_wide_db,\n", + " convert_units_to_MtCO2_equiv,\n", " get_sr15_scenarios,\n", " return_cases_which_consistently_split,\n", - " convert_units_to_MtCO2_equiv,\n", ")" ] }, @@ -638,8 +634,8 @@ "text": [ "c:\\users\\rlamboll\\constraincode\\silicone\\src\\silicone\\multiple_infillers\\infill_all_required_emissions_for_openscm.py:167: UserWarning: No data for ['Emissions|HFC|HFC245ca']\n", " warnings.warn(UserWarning(\"No data for {}\".format(unavailable_variables)))\n", - "Filling required variables: 100%|████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 13.89it/s]\n", - "Filling required variables: 100%|██████████████████████████████████████████████████████| 22/22 [00:20<00:00, 1.08it/s]\n" + "Filling required variables: 100%|████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 23.81it/s]\n", + "Filling required variables: 100%|██████████████████████████████████████████████████████| 22/22 [00:12<00:00, 1.70it/s]\n" ] }, { @@ -1449,8 +1445,8 @@ " variable\n", " unit\n", " year\n", - " meta\n", " subannual\n", + " meta\n", " value\n", " \n", " \n", @@ -1463,8 +1459,8 @@ " Emissions|F-Gases\n", " Mt CO2-equiv/yr\n", " 2005\n", - " 0\n", " 0.0\n", + " 0\n", " 610.958880\n", " \n", " \n", @@ -1475,8 +1471,8 @@ " Emissions|F-Gases\n", " Mt CO2-equiv/yr\n", " 2010\n", - " 0\n", " 0.0\n", + " 0\n", " 949.847085\n", " \n", " \n", @@ -1487,8 +1483,8 @@ " Emissions|F-Gases\n", " Mt CO2-equiv/yr\n", " 2015\n", - " 0\n", " 0.0\n", + " 0\n", " 567.248506\n", " \n", " \n", @@ -1499,8 +1495,8 @@ " Emissions|F-Gases\n", " Mt CO2-equiv/yr\n", " 2020\n", - " 0\n", " 0.0\n", + " 0\n", " 828.263273\n", " \n", " \n", @@ -1511,8 +1507,8 @@ " Emissions|F-Gases\n", " Mt CO2-equiv/yr\n", " 2025\n", - " 0\n", " 0.0\n", + " 0\n", " 307.759959\n", " \n", " \n", @@ -1527,12 +1523,12 @@ "23 WITCH-GLOBIOM 4.2 ADVANCE_2020_Med2C World Emissions|F-Gases \n", "24 WITCH-GLOBIOM 4.2 ADVANCE_2020_Med2C World Emissions|F-Gases \n", "\n", - " unit year meta subannual value \n", - "20 Mt CO2-equiv/yr 2005 0 0.0 610.958880 \n", - "21 Mt CO2-equiv/yr 2010 0 0.0 949.847085 \n", - "22 Mt CO2-equiv/yr 2015 0 0.0 567.248506 \n", - "23 Mt CO2-equiv/yr 2020 0 0.0 828.263273 \n", - "24 Mt CO2-equiv/yr 2025 0 0.0 307.759959 " + " unit year subannual meta value \n", + "20 Mt CO2-equiv/yr 2005 0.0 0 610.958880 \n", + "21 Mt CO2-equiv/yr 2010 0.0 0 949.847085 \n", + "22 Mt CO2-equiv/yr 2015 0.0 0 567.248506 \n", + "23 Mt CO2-equiv/yr 2020 0.0 0 828.263273 \n", + "24 Mt CO2-equiv/yr 2025 0.0 0 307.759959 " ] }, "execution_count": 19, @@ -1659,8 +1655,8 @@ " variable\n", " unit\n", " year\n", - " meta\n", " subannual\n", + " meta\n", " value\n", " \n", " \n", @@ -1673,8 +1669,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2005\n", - " 0\n", " 0.0\n", + " 0\n", " 85.2526\n", " \n", " \n", @@ -1685,8 +1681,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2010\n", - " 0\n", " 0.0\n", + " 0\n", " 89.6442\n", " \n", " \n", @@ -1697,8 +1693,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2015\n", - " 0\n", " 0.0\n", + " 0\n", " 75.3558\n", " \n", " \n", @@ -1709,8 +1705,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2020\n", - " 0\n", " 0.0\n", + " 0\n", " 78.3179\n", " \n", " \n", @@ -1721,8 +1717,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2025\n", - " 0\n", " 0.0\n", + " 0\n", " 27.3933\n", " \n", " \n", @@ -1733,8 +1729,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2030\n", - " 0\n", " 0.0\n", + " 0\n", " 20.0998\n", " \n", " \n", @@ -1745,8 +1741,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2035\n", - " 0\n", " 0.0\n", + " 0\n", " 17.3219\n", " \n", " \n", @@ -1757,8 +1753,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2040\n", - " 0\n", " 0.0\n", + " 0\n", " 15.2576\n", " \n", " \n", @@ -1769,8 +1765,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2045\n", - " 0\n", " 0.0\n", + " 0\n", " 13.5058\n", " \n", " \n", @@ -1781,8 +1777,8 @@ " Emissions|CO2|Other\n", " Mt CO2/yr\n", " 2050\n", - " 0\n", " 0.0\n", + " 0\n", " 13.4414\n", " \n", " \n", @@ -1802,17 +1798,17 @@ "8 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|CO2|Other Mt CO2/yr \n", "9 AIM/CGE 2.0 ADVANCE_2020_1.5C-2100 World Emissions|CO2|Other Mt CO2/yr \n", "\n", - " year meta subannual value \n", - "0 2005 0 0.0 85.2526 \n", - "1 2010 0 0.0 89.6442 \n", - "2 2015 0 0.0 75.3558 \n", - "3 2020 0 0.0 78.3179 \n", - "4 2025 0 0.0 27.3933 \n", - "5 2030 0 0.0 20.0998 \n", - "6 2035 0 0.0 17.3219 \n", - "7 2040 0 0.0 15.2576 \n", - "8 2045 0 0.0 13.5058 \n", - "9 2050 0 0.0 13.4414 " + " year subannual meta value \n", + "0 2005 0.0 0 85.2526 \n", + "1 2010 0.0 0 89.6442 \n", + "2 2015 0.0 0 75.3558 \n", + "3 2020 0.0 0 78.3179 \n", + "4 2025 0.0 0 27.3933 \n", + "5 2030 0.0 0 20.0998 \n", + "6 2035 0.0 0 17.3219 \n", + "7 2040 0.0 0 15.2576 \n", + "8 2045 0.0 0 13.5058 \n", + "9 2050 0.0 0 13.4414 " ] }, "execution_count": 23, diff --git a/scripts/compare_crunchers.py b/scripts/compare_crunchers.py index 86bf7417..f572ae86 100644 --- a/scripts/compare_crunchers.py +++ b/scripts/compare_crunchers.py @@ -26,11 +26,11 @@ def main(): input_data = "./sr_15_complete.csv" # A list of all crunchers to investigate, here a reference to the actual cruncher crunchers_list = [ - # dc.DatabaseCruncherLeadGas, - # dc.DatabaseCruncherTimeDepRatio, + # dc.LatestTimeRatio, + # dc.TimeDepRatio, dc.QuantileRollingWindows, - dc.DatabaseCruncherRMSClosest, - dc.DatabaseCruncherLinearInterpolation, + dc.RMSClosest, + dc.LinearInterpolation, ] options_list = [ # {}, diff --git a/src/silicone/database_crunchers/__init__.py b/src/silicone/database_crunchers/__init__.py index 321768f7..7d8cd554 100644 --- a/src/silicone/database_crunchers/__init__.py +++ b/src/silicone/database_crunchers/__init__.py @@ -7,12 +7,12 @@ timeseries. """ -from .constant_ratio import DatabaseCruncherConstantRatio # noqa: F401 +from .constant_ratio import ConstantRatio # noqa: F401 from .interpolate_specified_scenarios_and_models import ( # noqa: F401 - DatabaseCruncherScenarioAndModelSpecificInterpolate, + ScenarioAndModelSpecificInterpolate, ) -from .lead_gas import DatabaseCruncherLeadGas # noqa: F401 -from .linear_interpolation import DatabaseCruncherLinearInterpolation # noqa: F401 +from .latest_time_ratio import LatestTimeRatio # noqa: F401 +from .linear_interpolation import LinearInterpolation # noqa: F401 from .quantile_rolling_windows import QuantileRollingWindows # noqa: F401 -from .rms_closest import DatabaseCruncherRMSClosest # noqa: F401 -from .time_dep_ratio import DatabaseCruncherTimeDepRatio # noqa: F401 +from .rms_closest import RMSClosest # noqa: F401 +from .time_dep_ratio import TimeDepRatio # noqa: F401 diff --git a/src/silicone/database_crunchers/constant_ratio.py b/src/silicone/database_crunchers/constant_ratio.py index ca32b391..1885a9ca 100644 --- a/src/silicone/database_crunchers/constant_ratio.py +++ b/src/silicone/database_crunchers/constant_ratio.py @@ -11,7 +11,7 @@ logger = logging.getLogger(__name__) -class DatabaseCruncherConstantRatio(_DatabaseCruncher): +class ConstantRatio(_DatabaseCruncher): """ Database cruncher which uses the 'constant given ratio' technique. @@ -73,13 +73,13 @@ def derive_relationship(self, variable_follower, variable_leaders, ratio, units) """ if len(variable_leaders) > 1: raise ValueError( - "For `DatabaseCruncherConstantRatio`, ``variable_leaders`` should only " + "For `ConstantRatio`, ``variable_leaders`` should only " "contain one variable" ) def filler(in_iamdf): """ - Filler function derived from :obj:`DatabaseCruncherTimeDepRatio`. + Filler function derived from :obj:`TimeDepRatio`. Parameters ---------- diff --git a/src/silicone/database_crunchers/interpolate_specified_scenarios_and_models.py b/src/silicone/database_crunchers/interpolate_specified_scenarios_and_models.py index f12d6420..249250da 100644 --- a/src/silicone/database_crunchers/interpolate_specified_scenarios_and_models.py +++ b/src/silicone/database_crunchers/interpolate_specified_scenarios_and_models.py @@ -1,12 +1,12 @@ from .base import _DatabaseCruncher -from .linear_interpolation import DatabaseCruncherLinearInterpolation +from .linear_interpolation import LinearInterpolation -class DatabaseCruncherScenarioAndModelSpecificInterpolate(_DatabaseCruncher): +class ScenarioAndModelSpecificInterpolate(_DatabaseCruncher): """ Database cruncher which pre-filters to only use data from specific scenarios, then runs the linear interpolator to return values from that set of scenarios. See the - documentation of DatabaseCruncherLinearInterpolation for more details. + documentation of LinearInterpolation for more details. """ def derive_relationship( @@ -58,5 +58,5 @@ def derive_relationship( "There is no data of the appropriate type in the database." " There may be a typo in the SSP option." ) - cruncher = DatabaseCruncherLinearInterpolation(use_db) + cruncher = LinearInterpolation(use_db) return cruncher.derive_relationship(variable_follower, variable_leaders) diff --git a/src/silicone/database_crunchers/lead_gas.py b/src/silicone/database_crunchers/latest_time_ratio.py similarity index 95% rename from src/silicone/database_crunchers/lead_gas.py rename to src/silicone/database_crunchers/latest_time_ratio.py index bcf4b837..e0b2338d 100644 --- a/src/silicone/database_crunchers/lead_gas.py +++ b/src/silicone/database_crunchers/latest_time_ratio.py @@ -1,5 +1,5 @@ """ -Module for the database cruncher which uses the 'lead gas' technique. +Module for the database cruncher which uses the 'latest time ratio' technique. """ import warnings @@ -9,9 +9,9 @@ from .base import _DatabaseCruncher -class DatabaseCruncherLeadGas(_DatabaseCruncher): +class LatestTimeRatio(_DatabaseCruncher): """ - Database cruncher which uses the 'lead gas' technique. + Database cruncher which uses the 'latest time ratio' technique. This cruncher derives the relationship between two variables by simply assuming that the follower timeseries is equal to the lead timeseries multiplied by a @@ -90,7 +90,7 @@ def derive_relationship(self, variable_follower, variable_leaders): def filler(in_iamdf, interpolate=False): """ - Filler function derived from :obj:`DatabaseCruncherLeadGas`. + Filler function derived from :obj:`LatestTimeRatio`. Parameters ---------- @@ -177,7 +177,7 @@ def get_values_in_key_timepoint(idf): def _get_iamdf_follower(self, variable_follower, variable_leaders): if len(variable_leaders) > 1: raise ValueError( - "For `DatabaseCruncherLeadGas`, ``variable_leaders`` should only " + "For `LatestTimeRatio`, ``variable_leaders`` should only " "contain one variable" ) diff --git a/src/silicone/database_crunchers/linear_interpolation.py b/src/silicone/database_crunchers/linear_interpolation.py index 812c89ab..46af797d 100644 --- a/src/silicone/database_crunchers/linear_interpolation.py +++ b/src/silicone/database_crunchers/linear_interpolation.py @@ -8,7 +8,7 @@ from .base import _DatabaseCruncher -class DatabaseCruncherLinearInterpolation(_DatabaseCruncher): +class LinearInterpolation(_DatabaseCruncher): """ Database cruncher which uses linear interpolation. diff --git a/src/silicone/database_crunchers/rms_closest.py b/src/silicone/database_crunchers/rms_closest.py index 08e6355f..9dd73621 100644 --- a/src/silicone/database_crunchers/rms_closest.py +++ b/src/silicone/database_crunchers/rms_closest.py @@ -9,7 +9,7 @@ from .base import _DatabaseCruncher -class DatabaseCruncherRMSClosest(_DatabaseCruncher): +class RMSClosest(_DatabaseCruncher): """ Database cruncher which uses the 'closest RMS' technkque. @@ -73,7 +73,7 @@ def derive_relationship(self, variable_follower, variable_leaders): def filler(in_iamdf): """ - Filler function derived from :obj:`DatabaseCruncherRMSClosest`. + Filler function derived from :obj:`RMSClosest`. Parameters ---------- @@ -161,7 +161,7 @@ def get_values_at_key_timepoints(idf, time_filter): def _check_iamdf_lead(self, variable_leaders): if len(variable_leaders) > 1: raise ValueError( - "For `DatabaseCruncherRMSClosest`, ``variable_leaders`` should only " + "For `RMSClosest`, ``variable_leaders`` should only " "contain one variable" ) diff --git a/src/silicone/database_crunchers/time_dep_ratio.py b/src/silicone/database_crunchers/time_dep_ratio.py index 19ed91a1..153d246f 100644 --- a/src/silicone/database_crunchers/time_dep_ratio.py +++ b/src/silicone/database_crunchers/time_dep_ratio.py @@ -11,7 +11,7 @@ from .base import _DatabaseCruncher -class DatabaseCruncherTimeDepRatio(_DatabaseCruncher): +class TimeDepRatio(_DatabaseCruncher): """ Database cruncher which uses the 'time-dependent ratio' technique. @@ -124,7 +124,7 @@ def derive_relationship(self, variable_follower, variable_leaders, same_sign=Tru def filler(in_iamdf): """ - Filler function derived from :obj:`DatabaseCruncherTimeDepRatio`. + Filler function derived from :obj:`TimeDepRatio`. Parameters ---------- @@ -197,7 +197,7 @@ def filler(in_iamdf): def _get_iamdf_followers(self, variable_follower, variable_leaders): if len(variable_leaders) > 1: raise ValueError( - "For `DatabaseCruncherTimeDepRatio`, ``variable_leaders`` should only " + "For `TimeDepRatio`, ``variable_leaders`` should only " "contain one variable" ) diff --git a/src/silicone/multiple_infillers/decompose_collection_with_time_dep_ratio.py b/src/silicone/multiple_infillers/decompose_collection_with_time_dep_ratio.py index e7d3ce6c..2b718f8c 100644 --- a/src/silicone/multiple_infillers/decompose_collection_with_time_dep_ratio.py +++ b/src/silicone/multiple_infillers/decompose_collection_with_time_dep_ratio.py @@ -5,7 +5,7 @@ import pyam -from silicone.database_crunchers import DatabaseCruncherTimeDepRatio +from silicone.database_crunchers import TimeDepRatio from silicone.utils import convert_units_to_MtCO2_equiv @@ -159,7 +159,7 @@ def infill_components( aggregate, components, db_to_generate ) self._db.append(consistent_composite, inplace=True) - cruncher = DatabaseCruncherTimeDepRatio(self._db) + cruncher = TimeDepRatio(self._db) if self._set_of_units_without_equiv( to_infill_df ) != self._set_of_units_without_equiv(consistent_composite): diff --git a/src/silicone/multiple_infillers/infill_all_required_emissions_for_openscm.py b/src/silicone/multiple_infillers/infill_all_required_emissions_for_openscm.py index fa52d901..6e4e33cd 100644 --- a/src/silicone/multiple_infillers/infill_all_required_emissions_for_openscm.py +++ b/src/silicone/multiple_infillers/infill_all_required_emissions_for_openscm.py @@ -5,10 +5,7 @@ import pyam import tqdm -from silicone.database_crunchers import ( - DatabaseCruncherConstantRatio, - QuantileRollingWindows, -) +from silicone.database_crunchers import ConstantRatio, QuantileRollingWindows """ @@ -172,7 +169,7 @@ def infill_all_required_variables( variable_leaders, to_fill, database, - DatabaseCruncherConstantRatio, + ConstantRatio, output_timesteps, to_fill_orig, check_data_returned=False, @@ -250,7 +247,7 @@ def _perform_crunch_and_check( """ if ( not all(x in df.variables().values for x in required_variables) - and type_of_cruncher != DatabaseCruncherConstantRatio + and type_of_cruncher != ConstantRatio ): not_present = [x for x in required_variables if x not in df.variables().values] raise Warning("Missing some requested variables: {}".format(not_present)) diff --git a/tests/integration/crunchers/test_cruncher_constant_ratio.py b/tests/integration/crunchers/test_cruncher_constant_ratio.py index 2efe8c52..21c8dd84 100644 --- a/tests/integration/crunchers/test_cruncher_constant_ratio.py +++ b/tests/integration/crunchers/test_cruncher_constant_ratio.py @@ -6,14 +6,14 @@ import pytest from pyam import IamDataFrame -from silicone.database_crunchers import DatabaseCruncherConstantRatio +from silicone.database_crunchers import ConstantRatio _msa = ["model_a", "scen_a"] _msb = ["model_a", "scen_b"] class TestDatabaseCruncherTimeDepRatio: - tclass = DatabaseCruncherConstantRatio + tclass = ConstantRatio tdb = pd.DataFrame( [ _msa + ["World", "Emissions|HFC|C5F12", "kt C5F12/yr", 2, 3], @@ -84,7 +84,7 @@ def test_derive_relationship(self): def test_derive_relationship_error_multiple_lead_vars(self): tcruncher = self.tclass() error_msg = re.escape( - "For `DatabaseCruncherConstantRatio`, ``variable_leaders`` should only " + "For `ConstantRatio`, ``variable_leaders`` should only " "contain one variable" ) with pytest.raises(ValueError, match=error_msg): diff --git a/tests/integration/crunchers/test_cruncher_interpolate_specified.py b/tests/integration/crunchers/test_cruncher_interpolate_specified.py index c0c57d95..adc0e353 100644 --- a/tests/integration/crunchers/test_cruncher_interpolate_specified.py +++ b/tests/integration/crunchers/test_cruncher_interpolate_specified.py @@ -10,8 +10,8 @@ import silicone.stats from silicone.database_crunchers import ( - DatabaseCruncherLinearInterpolation, - DatabaseCruncherScenarioAndModelSpecificInterpolate, + LinearInterpolation, + ScenarioAndModelSpecificInterpolate, ) _ma = "model_a" @@ -35,7 +35,7 @@ class TestDatabaseCruncherScenarioAndModelSpecificInterpolate(_DataBaseCruncherTester): - tclass = DatabaseCruncherScenarioAndModelSpecificInterpolate + tclass = ScenarioAndModelSpecificInterpolate # The units in this dataframe are intentionally illogical for C5F12 tdb = pd.DataFrame( [ @@ -96,7 +96,7 @@ class TestDatabaseCruncherScenarioAndModelSpecificInterpolate(_DataBaseCruncherT def test_database_crunchers_with_filters(self, test_db, simple_df): test_db = self._adjust_time_style_to_match(test_db, simple_df) tcruncher_filtered = self.tclass(test_db) - tcruncher_linear = DatabaseCruncherLinearInterpolation(test_db) + tcruncher_linear = LinearInterpolation(test_db) filtered_cruncher = tcruncher_filtered.derive_relationship( "Emissions|CO2", ["Emissions|CH4"] ) diff --git a/tests/integration/crunchers/test_cruncher_lead_gas.py b/tests/integration/crunchers/test_cruncher_latest_time_ratio.py similarity index 97% rename from tests/integration/crunchers/test_cruncher_lead_gas.py rename to tests/integration/crunchers/test_cruncher_latest_time_ratio.py index 0c90006e..bc8d600f 100644 --- a/tests/integration/crunchers/test_cruncher_lead_gas.py +++ b/tests/integration/crunchers/test_cruncher_latest_time_ratio.py @@ -6,13 +6,13 @@ from base import _DataBaseCruncherTester from pyam import IamDataFrame -from silicone.database_crunchers import DatabaseCruncherLeadGas +from silicone.database_crunchers import LatestTimeRatio _msa = ["model_a", "scen_a"] class TestDatabaseCruncherLeadGas(_DataBaseCruncherTester): - tclass = DatabaseCruncherLeadGas + tclass = LatestTimeRatio tdb = pd.DataFrame( [ _msa + ["World", "Emissions|HFC|C5F12", "kt C5F12/yr", "", np.nan, 3.14], @@ -47,7 +47,7 @@ def test_derive_relationship(self, test_db): def test_derive_relationship_error_multiple_lead_vars(self, test_db): tcruncher = self.tclass(test_db) error_msg = re.escape( - "For `DatabaseCruncherLeadGas`, ``variable_leaders`` should only " + "For `LatestTimeRatio`, ``variable_leaders`` should only " "contain one variable" ) with pytest.raises(ValueError, match=error_msg): diff --git a/tests/integration/crunchers/test_cruncher_rms_closest.py b/tests/integration/crunchers/test_cruncher_rms_closest.py index 3ca5ca71..5bfe6d20 100644 --- a/tests/integration/crunchers/test_cruncher_rms_closest.py +++ b/tests/integration/crunchers/test_cruncher_rms_closest.py @@ -7,14 +7,14 @@ from base import _DataBaseCruncherTester from pyam import IamDataFrame, concat -from silicone.database_crunchers import DatabaseCruncherRMSClosest +from silicone.database_crunchers import RMSClosest from silicone.database_crunchers.rms_closest import _select_closest _msa = ["model_a", "scen_a"] class TestDatabaseCruncherRMSClosest(_DataBaseCruncherTester): - tclass = DatabaseCruncherRMSClosest + tclass = RMSClosest tdb = pd.DataFrame( [ _msa + ["World", "Emissions|HFC|C5F12", "kt C5F12/yr", np.nan, 3.14], @@ -299,8 +299,7 @@ def test_derive_relationship(self, test_db): def test_derive_relationship_error_multiple_lead_vars(self, test_db): tcruncher = self.tclass(test_db) error_msg = re.escape( - "For `DatabaseCruncherRMSClosest`, ``variable_leaders`` should only " - "contain one variable" + "For `RMSClosest`, ``variable_leaders`` should only " "contain one variable" ) with pytest.raises(ValueError, match=error_msg): tcruncher.derive_relationship("Emissions|HFC|C5F12", ["a", "b"]) diff --git a/tests/integration/crunchers/test_cruncher_time_dep_ratio.py b/tests/integration/crunchers/test_cruncher_time_dep_ratio.py index dedc3b9f..2bca1e1c 100644 --- a/tests/integration/crunchers/test_cruncher_time_dep_ratio.py +++ b/tests/integration/crunchers/test_cruncher_time_dep_ratio.py @@ -6,14 +6,14 @@ from base import _DataBaseCruncherTester from pyam import IamDataFrame -from silicone.database_crunchers import DatabaseCruncherTimeDepRatio +from silicone.database_crunchers import TimeDepRatio _msa = ["model_a", "scen_a"] _msb = ["model_a", "scen_b"] class TestDatabaseCruncherTimeDepRatio(_DataBaseCruncherTester): - tclass = DatabaseCruncherTimeDepRatio + tclass = TimeDepRatio tdb = pd.DataFrame( [ _msa + ["World", "Emissions|HFC|C5F12", "kt C5F12/yr", 2, 3], @@ -68,7 +68,7 @@ def test_derive_relationship(self, test_db): def test_derive_relationship_error_multiple_lead_vars(self, test_db): tcruncher = self.tclass(test_db) error_msg = re.escape( - "For `DatabaseCruncherTimeDepRatio`, ``variable_leaders`` should only " + "For `TimeDepRatio`, ``variable_leaders`` should only " "contain one variable" ) with pytest.raises(ValueError, match=error_msg): diff --git a/tests/integration/multiple_infillers/test_infill_all_required_emissions_for_openscm.py b/tests/integration/multiple_infillers/test_infill_all_required_emissions_for_openscm.py index 10feb307..96dab0ca 100644 --- a/tests/integration/multiple_infillers/test_infill_all_required_emissions_for_openscm.py +++ b/tests/integration/multiple_infillers/test_infill_all_required_emissions_for_openscm.py @@ -1,5 +1,4 @@ import re -import warnings import pandas as pd import pyam