diff --git a/dice_demo.ipynb b/dice_demo.ipynb new file mode 100644 index 0000000..90b8196 --- /dev/null +++ b/dice_demo.ipynb @@ -0,0 +1,497 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from diceclass import DICE2016Model\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal solution value: 5301.092483698273\n" + ] + } + ], + "source": [ + "model = DICE2016Model()\n", + "model.run_model()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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", + "
MATCCATOTPPMATFRACATFRAC2010ETATMYDAMFRACCPC...ABATECOSTSIGMAFORCFORCOTHPERIODUCETREECCAMUML
time
0851.000000500.000000400.6591340.5260000.00000038.3403850.850000125.9966740.00170512.584110...0.0010270.2919332.4633960.5000000.51122693.1601672.600000400.000000460.0000001740.000000
1891.331850552.291850419.6477640.5492240.77128435.4459211.016342150.0159370.00243814.189520...0.1272700.2705692.7387310.5294120.548622111.4315912.301000448.745751471.2893021740.670698
2925.088868600.635987435.5408990.5612200.73620637.2004651.184344176.7001140.00331015.938868...0.1861550.2508622.9655680.5588240.582956131.7334832.036385493.951590485.1276811741.419438
3959.900361651.373119451.9304900.5709480.71941738.6334991.353701206.0621050.00432517.837657...0.2660630.2326793.1911670.5882350.614527154.0990711.802201541.911328500.2088081742.263950
4995.444868704.064742468.6651920.5787040.70783839.7039221.523962238.1462560.00548119.891274...0.3723330.2158953.4136870.6176470.643608178.5551541.594948592.144958516.4070831743.212792
..................................................................
95526.664230130.841279247.958677-0.4687800.8785810.0010850.41151113450.8641560.000400867.548261...0.2832130.0009190.4149211.0000001.1164059976.7999040.0000240.005914323.7822251831.394824
96526.927319130.842759248.082542-0.4667640.8778720.0018630.41144213611.2296780.000400877.891390...0.2664810.0008760.4175741.0000001.11696810095.7465160.0000210.007362323.9373471830.978093
97527.190302130.845300248.206357-0.4647450.8771650.0149430.41147113764.1696160.000400887.755593...0.2499270.0008360.4202241.0000001.11749610209.1854100.0000190.009874324.0919401830.563059
98527.469866130.865680248.337978-0.4625360.8764563.3950420.41160713911.3435670.000400897.247910...0.0913300.0007980.4230391.0000001.11799610318.3475460.0000160.030229324.2461001830.149715
99532.356162135.496125250.638495-0.4106670.8741859.9486120.41647914053.5173060.000409906.417731...0.0002290.0007620.4720121.0000001.11847210423.8009160.0000154.660652324.4019081829.738055
\n", + "

100 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " MAT CCATOT PPM ATFRAC ATFRAC2010 E \\\n", + "time \n", + "0 851.000000 500.000000 400.659134 0.526000 0.000000 38.340385 \n", + "1 891.331850 552.291850 419.647764 0.549224 0.771284 35.445921 \n", + "2 925.088868 600.635987 435.540899 0.561220 0.736206 37.200465 \n", + "3 959.900361 651.373119 451.930490 0.570948 0.719417 38.633499 \n", + "4 995.444868 704.064742 468.665192 0.578704 0.707838 39.703922 \n", + "... ... ... ... ... ... ... \n", + "95 526.664230 130.841279 247.958677 -0.468780 0.878581 0.001085 \n", + "96 526.927319 130.842759 248.082542 -0.466764 0.877872 0.001863 \n", + "97 527.190302 130.845300 248.206357 -0.464745 0.877165 0.014943 \n", + "98 527.469866 130.865680 248.337978 -0.462536 0.876456 3.395042 \n", + "99 532.356162 135.496125 250.638495 -0.410667 0.874185 9.948612 \n", + "\n", + " TATM Y DAMFRAC CPC ... ABATECOST SIGMA \\\n", + "time ... \n", + "0 0.850000 125.996674 0.001705 12.584110 ... 0.001027 0.291933 \n", + "1 1.016342 150.015937 0.002438 14.189520 ... 0.127270 0.270569 \n", + "2 1.184344 176.700114 0.003310 15.938868 ... 0.186155 0.250862 \n", + "3 1.353701 206.062105 0.004325 17.837657 ... 0.266063 0.232679 \n", + "4 1.523962 238.146256 0.005481 19.891274 ... 0.372333 0.215895 \n", + "... ... ... ... ... ... ... ... \n", + "95 0.411511 13450.864156 0.000400 867.548261 ... 0.283213 0.000919 \n", + "96 0.411442 13611.229678 0.000400 877.891390 ... 0.266481 0.000876 \n", + "97 0.411471 13764.169616 0.000400 887.755593 ... 0.249927 0.000836 \n", + "98 0.411607 13911.343567 0.000400 897.247910 ... 0.091330 0.000798 \n", + "99 0.416479 14053.517306 0.000409 906.417731 ... 0.000229 0.000762 \n", + "\n", + " FORC FORCOTH PERIODU C ETREE CCA \\\n", + "time \n", + "0 2.463396 0.500000 0.511226 93.160167 2.600000 400.000000 \n", + "1 2.738731 0.529412 0.548622 111.431591 2.301000 448.745751 \n", + "2 2.965568 0.558824 0.582956 131.733483 2.036385 493.951590 \n", + "3 3.191167 0.588235 0.614527 154.099071 1.802201 541.911328 \n", + "4 3.413687 0.617647 0.643608 178.555154 1.594948 592.144958 \n", + "... ... ... ... ... ... ... \n", + "95 0.414921 1.000000 1.116405 9976.799904 0.000024 0.005914 \n", + "96 0.417574 1.000000 1.116968 10095.746516 0.000021 0.007362 \n", + "97 0.420224 1.000000 1.117496 10209.185410 0.000019 0.009874 \n", + "98 0.423039 1.000000 1.117996 10318.347546 0.000016 0.030229 \n", + "99 0.472012 1.000000 1.118472 10423.800916 0.000015 4.660652 \n", + "\n", + " MU ML \n", + "time \n", + "0 460.000000 1740.000000 \n", + "1 471.289302 1740.670698 \n", + "2 485.127681 1741.419438 \n", + "3 500.208808 1742.263950 \n", + "4 516.407083 1743.212792 \n", + "... ... ... \n", + "95 323.782225 1831.394824 \n", + "96 323.937347 1830.978093 \n", + "97 324.091940 1830.563059 \n", + "98 324.246100 1830.149715 \n", + "99 324.401908 1829.738055 \n", + "\n", + "[100 rows x 31 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output=model.results\n", + "output" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(output.index,output['TATM'])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/diceclass.py b/diceclass.py new file mode 100644 index 0000000..bcbdfb9 --- /dev/null +++ b/diceclass.py @@ -0,0 +1,90 @@ +import pandas as pd +import numpy as np +import pyomo.environ as pe +from dice2016 import ( + get_b, get_sig0, get_lam, get_l, get_ga, get_al, get_gsig, get_sigma, + get_pbacktime, get_cost1, get_etree, get_cumetree, get_rr, get_forcoth, + get_optlrsav, get_cpricebase, dice2016 +) + +class DICE2016Model: + def __init__(self, param_df=None): + if param_df is None: + param_df = pd.read_csv('dice2016_parameters.csv') + self.params = dict(zip(param_df.key, param_df.value)) + self.params['nt'] = int(self.params['nt']) + self.params['logfile'] = bool(self.params['logfile']) + self._define_dependent_parameters() + + def _define_dependent_parameters(self): + p = self.params + p['b11'], p['b21'], p['b22'], p['b32'], p['b33'] = get_b(p['b12'], p['b23'], p['mateq'], p['mueq'], p['mleq']) + p['sig0'] = get_sig0(p['e0'], p['q0'], p['miu0']) + p['lam'] = get_lam(p['fco22x'], p['t2xco2']) + p['l'] = get_l(p['pop0'], p['popadj'], p['popasym'], p['nt']) + p['ga'] = get_ga(p['ga0'], p['dela'], p['tstep'], p['nt']) + p['al'] = get_al(p['a0'], p['ga'], p['nt']) + p['gsig'] = get_gsig(p['gsigma1'], p['dsig'], p['tstep'], p['nt']) + p['sigma'] = get_sigma(p['sig0'], p['gsig'], p['tstep'], p['nt']) + p['pbacktime'] = get_pbacktime(p['pback'], p['gback'], p['nt']) + p['cost1'] = get_cost1(p['pbacktime'], p['sigma'], p['expcost2']) + p['etree'] = get_etree(p['eland0'], p['deland'], p['nt']) + p['cumetree'] = get_cumetree(p['etree'], p['tstep'], p['nt']) + p['rr'] = get_rr(p['prstp'], p['tstep'], p['nt']) + p['forcoth'] = get_forcoth(p['fex0'], p['fex1'], p['nt']) + p['optlrsav'] = get_optlrsav(p['dk'], p['elasmu'], p['prstp'], p['gama']) + p['cpricebase'] = get_cpricebase(p['cprice0'], p['gcprice'], p['tstep'], p['nt']) + + def run_model(self): + self.model = dice2016(**self.params) + self.results = self._extract_results() + + def _extract_results(self): + results = {} + time_periods = np.array([t for t in self.model.time_periods]) + results_df = pd.DataFrame(index=time_periods) + results_df.index.name = 'time' + + results_df['MAT'] = np.array([pe.value(self.model.MAT[t]) for t in self.model.time_periods]) + results_df['CCATOT'] = np.array([pe.value(self.model.CCATOT[t]) for t in self.model.time_periods]) + results_df['PPM'] = results_df['MAT'] / 2.124 + results_df['ATFRAC'] = (results_df['MAT'] - 588) / (results_df['CCATOT'] + 0.000001) + results_df['ATFRAC2010'] = (results_df['MAT'] - self.params['mat0']) / (0.00001 + results_df['CCATOT'] - results_df['CCATOT'][0]) + results_df['E'] = np.array([pe.value(self.model.E[t]) for t in self.model.time_periods]) + results_df['TATM'] = np.array([pe.value(self.model.TATM[t]) for t in self.model.time_periods]) + results_df['Y'] = np.array([pe.value(self.model.Y[t]) for t in self.model.time_periods]) + results_df['DAMFRAC'] = np.array([pe.value(self.model.DAMFRAC[t]) for t in self.model.time_periods]) + results_df['CPC'] = np.array([pe.value(self.model.CPC[t]) for t in self.model.time_periods]) + results_df['CPRICE'] = np.array([pe.value(self.model.CPRICE[t]) for t in self.model.time_periods]) + results_df['MIU'] = np.array([pe.value(self.model.MIU[t]) for t in self.model.time_periods]) + results_df['L'] = np.array([pe.value(self.params['l'][t]) for t in range(self.params['nt'])]) + results_df['AL'] = np.array([pe.value(self.params['al'][t]) for t in range(self.params['nt'])]) + results_df['YGROSS'] = np.array([pe.value(self.model.YGROSS[t]) for t in self.model.time_periods]) + results_df['GA'] = np.array([pe.value(self.params['ga'][t]) for t in range(self.params['nt'])]) + results_df['K'] = np.array([pe.value(self.model.K[t]) for t in self.model.time_periods]) + results_df['S'] = np.array([pe.value(self.model.S[t]) for t in self.model.time_periods]) + results_df['I'] = np.array([pe.value(self.model.I[t]) for t in self.model.time_periods]) + results_df['YNET'] = np.array([pe.value(self.model.YNET[t]) for t in self.model.time_periods]) + results_df['DAMAGES'] = np.array([pe.value(self.model.DAMAGES[t]) for t in self.model.time_periods]) + results_df['ABATECOST'] = np.array([pe.value(self.model.ABATECOST[t]) for t in self.model.time_periods]) + results_df['SIGMA'] = np.array([pe.value(self.params['sigma'][t]) for t in range(self.params['nt'])]) + results_df['FORC'] = np.array([pe.value(self.model.FORC[t]) for t in self.model.time_periods]) + results_df['FORCOTH'] = np.array([pe.value(self.params['forcoth'][t]) for t in range(self.params['nt'])]) + results_df['PERIODU'] = np.array([pe.value(self.model.PERIODU[t]) for t in self.model.time_periods]) + results_df['C'] = np.array([pe.value(self.model.C[t]) for t in self.model.time_periods]) + results_df['ETREE'] = np.array([pe.value(self.params['etree'][t]) for t in range(self.params['nt'])]) + results_df['CCA'] = np.array([pe.value(self.model.CCA[t]) for t in self.model.time_periods]) + results_df['MU'] = np.array([pe.value(self.model.MU[t]) for t in self.model.time_periods]) + results_df['ML'] = np.array([pe.value(self.model.ML[t]) for t in self.model.time_periods]) + + #results = results_df.to_dict(orient='list') + #results['UTILITY'] = pe.value(self.model.UTILITY) + return results_df + + def get_results(self): + return self.results + +# Example usage: +# model = DICE2016Model() +# model.run_model() +# results = model.get_results() \ No newline at end of file diff --git a/environment.yml b/environment.yml index 958d582..2338ce4 100644 --- a/environment.yml +++ b/environment.yml @@ -3,6 +3,7 @@ channels: - conda-forge dependencies: - pyomo + - matplotlib - pandas - numpy - - ipopt==3.14.5 # https://stackoverflow.com/questions/64912995/applicationerror-no-executable-found-for-solver-ipopt-in-pyomo + - ipopt==3.14.5