From 055985ffaba25fb2459921eb6f14548df48876a9 Mon Sep 17 00:00:00 2001 From: Diego Calderon Date: Mon, 21 Feb 2022 12:42:43 -0600 Subject: [PATCH 1/8] first pass shelby cge --- pyincore/analyses/shelbycge/README.md | 29 + pyincore/analyses/shelbycge/__init__.py | 0 pyincore/analyses/shelbycge/environment.yaml | 388 ++++ .../analyses/shelbycge/shelby/Equationlib.py | 806 +++++++ .../shelbycge/shelby/OutputFunctions.py | 73 + .../analyses/shelbycge/shelby/__init__.py | 0 .../shelbycge/shelby/shelby/__init__.py | 0 .../shelbycge/shelby/shelby_output.py | 211 ++ .../shelbycge/shelby_CD_September_21_2020.py | 1867 ++++++++++++++++ .../shelbycge/shelby_CES_September_21_2020.py | 1908 +++++++++++++++++ 10 files changed, 5282 insertions(+) create mode 100755 pyincore/analyses/shelbycge/README.md create mode 100644 pyincore/analyses/shelbycge/__init__.py create mode 100644 pyincore/analyses/shelbycge/environment.yaml create mode 100755 pyincore/analyses/shelbycge/shelby/Equationlib.py create mode 100755 pyincore/analyses/shelbycge/shelby/OutputFunctions.py create mode 100644 pyincore/analyses/shelbycge/shelby/__init__.py create mode 100644 pyincore/analyses/shelbycge/shelby/shelby/__init__.py create mode 100755 pyincore/analyses/shelbycge/shelby/shelby_output.py create mode 100755 pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py create mode 100755 pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py diff --git a/pyincore/analyses/shelbycge/README.md b/pyincore/analyses/shelbycge/README.md new file mode 100755 index 000000000..d87da9616 --- /dev/null +++ b/pyincore/analyses/shelbycge/README.md @@ -0,0 +1,29 @@ +# NIST CGE + +## Python Models + +### Shelby + +There are two main scripts for Shelby: + +- **'shelby\_CD\_September\_21\_2020.py'**: This is the Shelby CGE model with Cobb-Douglas production function. + +- **'shelby\_CES\_September\_21\_2020.py'**: This is the Shelby CGE model with CES (Constant elasticity of substitution) production function. + +Both models are created and executed with `runsolver` at the bottom of the script. +Output form 'simulation\_outputs.csv' will be created on the same directory after running script. + +## Installation + +Anaconda or Miniconda are the preferred python3 package managers for this model. Download from [anaconda.com](https://www.anaconda.com/distribution/). Packages and documentation can be found at [conda-forge.org](https://conda-forge.org/) with installation instructions here: [docs.anaconda.com](https://docs.anaconda.com/anaconda/navigator/install/) + +After downloading one of the conda apps, the *environment.yaml* file can be used to build a python3 virtual environment with the correct dependencies. + +If conda is not an option, the bare-bones set of dependencies needed are: + +- ipopt +- numpy +- pandas +- pyomo + +ipopt is part of the COIN project and can be downloaded directly from [coin-or.org](https://projects.coin-or.org/Ipopt) or installed as a package from Anaconda Cloud. diff --git a/pyincore/analyses/shelbycge/__init__.py b/pyincore/analyses/shelbycge/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/pyincore/analyses/shelbycge/environment.yaml b/pyincore/analyses/shelbycge/environment.yaml new file mode 100644 index 000000000..b9ad676d6 --- /dev/null +++ b/pyincore/analyses/shelbycge/environment.yaml @@ -0,0 +1,388 @@ +name: base +channels: + - conda-forge + - defaults +dependencies: + - _anaconda_depends=2020.07=py37_0 + - _ipyw_jlab_nb_ext_conf=0.1.0=py37_0 + - alabaster=0.7.12=py_0 + - anaconda=custom=py37_1 + - anaconda-client=1.7.2=py_0 + - anaconda-navigator=1.9.12=py37_0 + - anaconda-project=0.8.3=py_0 + - appdirs=1.4.3=py_1 + - applaunchservices=0.2.1=py_0 + - appnope=0.1.0=py37hc8dfbb8_1001 + - appscript=1.1.1=py37h9bfed18_0 + - argh=0.26.2=pyh9f0ad1d_1002 + - argon2-cffi=20.1.0=py37h60d8a13_1 + - asn1crypto=1.4.0=pyh9f0ad1d_0 + - astroid=2.4.2=py37hc8dfbb8_0 + - astropy=4.0.1.post1=py37h9bfed18_0 + - async_generator=1.10=py_0 + - atomicwrites=1.4.0=pyh9f0ad1d_0 + - attrs=20.2.0=pyh9f0ad1d_0 + - autopep8=1.4.4=py_0 + - babel=2.8.0=py_0 + - backcall=0.2.0=pyh9f0ad1d_0 + - backports=1.0=py_2 + - backports.functools_lru_cache=1.6.1=py_0 + - backports.shutil_get_terminal_size=1.0.0=py_3 + - beautifulsoup4=4.9.1=py_1 + - bitarray=1.5.3=py37h60d8a13_0 + - bkcharts=0.2=py37_0 + - blas=2.17=openblas + - bleach=3.2.1=pyh9f0ad1d_0 + - blosc=1.20.1=hb1e8313_0 + - bokeh=2.2.1=py37hc8dfbb8_0 + - boost-cpp=1.74.0=he5d75e3_0 + - boto=2.49.0=py_0 + - bottleneck=1.3.2=py37h10e2902_1 + - brotli=1.0.9=hb1e8313_0 + - brotlipy=0.7.0=py37h60d8a13_1000 + - brunsli=0.1=hb1e8313_0 + - bzip2=1.0.8=haf1e3a3_3 + - c-ares=1.16.1=haf1e3a3_3 + - ca-certificates=2020.6.20=hecda079_0 + - cairo=1.16.0=ha8983da_1005 + - certifi=2020.6.20=py37hc8dfbb8_0 + - cffi=1.14.3=py37hf5b7abd_0 + - cfitsio=3.470=hdf94aef_6 + - chardet=3.0.4=py37hc8dfbb8_1007 + - charls=2.1.0=h4a8c4bd_2 + - click=7.1.2=pyh9f0ad1d_0 + - click-plugins=1.1.1=py_0 + - cligj=0.5.0=py_0 + - cloudpickle=1.6.0=py_0 + - clyent=1.2.2=py_1 + - colorama=0.4.3=py_0 + - conda=4.8.5=py37hc8dfbb8_1 + - conda-build=3.20.2=py37hc8dfbb8_0 + - conda-env=2.6.0=1 + - conda-package-handling=1.7.0=py37h60d8a13_5 + - conda-verify=3.1.1=py37hc8dfbb8_1001 + - contextlib2=0.6.0.post1=py_0 + - cryptography=3.1=py37h94e4008_0 + - curl=7.71.1=hcb81553_6 + - cycler=0.10.0=py_2 + - cython=0.29.21=py37hdadc0f0_0 + - cytoolz=0.10.1=py37h0b31af3_0 + - dask=2.27.0=py_0 + - dask-core=2.27.0=py_0 + - dbus=1.13.6=h2f22bb5_0 + - decorator=4.4.2=py_0 + - defusedxml=0.6.0=py_0 + - diff-match-patch=20200713=pyh9f0ad1d_0 + - distributed=2.27.0=py37hc8dfbb8_0 + - docutils=0.16=py37hc8dfbb8_1 + - entrypoints=0.3=py37hc8dfbb8_1001 + - et_xmlfile=1.0.1=py_1001 + - expat=2.2.9=hb1e8313_2 + - fastcache=1.1.0=py37h9bfed18_1 + - filelock=3.0.12=pyh9f0ad1d_0 + - fiona=1.8.17=py37h8cd0b58_0 + - flake8=3.7.9=py37hc8dfbb8_1 + - flask=1.1.2=pyh9f0ad1d_0 + - fontconfig=2.13.1=h79c0d67_1002 + - freetype=2.10.2=h8da9a1a_0 + - freexl=1.0.5=h0b31af3_1002 + - fsspec=0.8.2=py_0 + - future=0.18.2=py37hc8dfbb8_1 + - gdal=3.1.2=py37h85de8e7_1 + - geopandas=0.8.1=py_0 + - geos=3.8.1=h4a8c4bd_0 + - geotiff=1.6.0=h4e9c399_1 + - get_terminal_size=1.0.0=h7520d66_0 + - gettext=0.19.8.1=h46ab8bc_1002 + - gevent=20.6.2=py37h9bfed18_0 + - giflib=5.2.1=h0b31af3_2 + - glib=2.66.0=hdb5fb44_0 + - glob2=0.7=py_0 + - gmp=6.2.0=hb1e8313_2 + - gmpy2=2.1.0b1=py37h4160ff4_0 + - greenlet=0.4.16=py37h9bfed18_0 + - h5py=2.10.0=nompi_py37h28defc4_104 + - hdf4=4.2.13=h84186c3_1003 + - hdf5=1.10.6=nompi_haae91d6_101 + - heapdict=1.0.1=py_0 + - html5lib=1.1=pyh9f0ad1d_0 + - icu=67.1=hb1e8313_0 + - idna=2.10=pyh9f0ad1d_0 + - imagecodecs=2020.5.30=py37h64a549b_2 + - imageio=2.9.0=py_0 + - imagesize=1.2.0=py_0 + - importlib-metadata=1.7.0=py37hc8dfbb8_0 + - importlib_metadata=1.7.0=0 + - iniconfig=1.0.1=pyh9f0ad1d_0 + - intel-openmp=2020.2=258 + - intervaltree=3.0.2=py_0 + - ipopt=3.13.2=he217970_0 + - ipykernel=5.3.4=py37h43977f1_0 + - ipython=7.18.1=py37hc6149b9_0 + - ipython_genutils=0.2.0=py_1 + - ipywidgets=7.5.1=pyh9f0ad1d_1 + - isort=5.5.3=py37hc8dfbb8_0 + - itsdangerous=1.1.0=py_0 + - jbig=2.1=h0b31af3_2002 + - jdcal=1.4.1=py_0 + - jedi=0.15.1=py37_0 + - jinja2=2.11.2=pyh9f0ad1d_0 + - joblib=0.16.0=py_0 + - jpeg=9d=h0b31af3_0 + - json-c=0.13.1=h575e443_1002 + - json5=0.9.5=pyh9f0ad1d_0 + - jsonschema=3.2.0=py37hc8dfbb8_1 + - jupyter=1.0.0=py_2 + - jupyter_client=6.1.7=py_0 + - jupyter_console=6.2.0=py_0 + - jupyter_core=4.6.3=py37hc8dfbb8_1 + - jupyterlab=2.2.8=py_0 + - jupyterlab_pygments=0.1.1=pyh9f0ad1d_0 + - jupyterlab_server=1.2.0=py_0 + - jxrlib=1.1=h0b31af3_2 + - kealib=1.4.13=h40102fb_1 + - keyring=21.4.0=py37hc8dfbb8_1 + - kiwisolver=1.2.0=py37ha1cc60f_0 + - krb5=1.17.1=h75d18d8_3 + - lazy-object-proxy=1.4.3=py37h9bfed18_2 + - lcms2=2.11=h174193d_0 + - lerc=2.2=hb1e8313_0 + - libaec=1.0.4=h4a8c4bd_1 + - libarchive=3.3.3=hf12134e_1008 + - libblas=3.8.0=17_openblas + - libcblas=3.8.0=17_openblas + - libclang=10.0.1=default_hf57f61e_1 + - libcurl=7.71.1=h9bf37e3_6 + - libcxx=10.0.1=h5f48129_0 + - libdap4=3.20.6=h993cace_1 + - libedit=3.1.20191231=h0678c8f_2 + - libev=4.33=haf1e3a3_1 + - libffi=3.2.1=hb1e8313_1007 + - libgdal=3.1.2=h6dfbaa8_1 + - libgfortran=4.0.0=h2d743fc_10 + - libgfortran4=7.5.0=h2d743fc_10 + - libiconv=1.16=haf1e3a3_0 + - libkml=1.3.0=h8ca2c65_1012 + - liblapack=3.8.0=17_openblas + - liblapacke=3.8.0=17_openblas + - liblief=0.10.1=hb1e8313_1 + - libllvm10=10.0.1=h009f743_3 + - libllvm9=9.0.1=h7475705_1 + - libnetcdf=4.7.4=nompi_hc5b2cf3_105 + - libnghttp2=1.41.0=h7580e61_2 + - libopenblas=0.3.10=openmp_h63d9170_4 + - libpng=1.6.37=hb0a8c7a_2 + - libpq=12.3=h489d428_0 + - libsodium=1.0.18=h01d97ff_0 + - libspatialindex=1.9.3=h4a8c4bd_3 + - libspatialite=4.3.0a=h231dce8_1039 + - libssh2=1.9.0=h8a08a2b_5 + - libtiff=4.1.0=h2ae36a8_6 + - libwebp-base=1.1.0=h0b31af3_3 + - libxml2=2.9.10=h2c6e4a5_2 + - libxslt=1.1.33=h29b7fa6_1 + - libzopfli=1.0.3=h4a8c4bd_0 + - llvm-openmp=10.0.1=h28b9765_0 + - llvmlite=0.34.0=py37h3986384_1 + - locket=0.2.0=py_2 + - lxml=4.5.2=py37heb1707f_0 + - lz4-c=1.9.2=hb1e8313_3 + - lzo=2.10=haf1e3a3_1000 + - markupsafe=1.1.1=py37h60d8a13_1 + - matplotlib=3.3.2=0 + - matplotlib-base=3.3.2=py37h886f89f_0 + - mccabe=0.6.1=py_1 + - metis=5.1.0=hb1e8313_1006 + - mistune=0.8.4=py37h9bfed18_1001 + - mkl=2020.2=260 + - mkl-service=2.3.0=py37h60d8a13_1 + - mkl_fft=1.2.0=py37h57c32b8_1 + - mkl_random=1.1.1=py37h570ac47_0 + - mock=4.0.2=py37hc8dfbb8_0 + - more-itertools=8.5.0=py_0 + - mpc=1.1.0=ha57cd0f_1009 + - mpfr=4.0.2=h72d8aaf_1 + - mpmath=1.1.0=py_0 + - msgpack-python=1.0.0=py37ha1cc60f_1 + - multipledispatch=0.6.0=py_0 + - munch=2.5.0=py_0 + - mysql-common=8.0.21=2 + - mysql-libs=8.0.21=hfb8f7af_2 + - navigator-updater=0.2.1=py37_0 + - nbclient=0.5.0=py_0 + - nbconvert=6.0.5=py37hc8dfbb8_0 + - nbformat=5.0.7=py_0 + - ncurses=6.2=hb1e8313_1 + - nest-asyncio=1.4.0=py_1 + - networkx=2.5=py_0 + - nltk=3.4.4=py_0 + - nose=1.3.7=py37hc8dfbb8_1004 + - notebook=6.1.4=py37hc8dfbb8_0 + - nspr=4.20=h0a44026_1000 + - nss=3.47=hc0980d9_0 + - numba=0.51.2=py37h6d0141a_0 + - numexpr=2.7.1=py37h94625e5_1 + - numpydoc=1.1.0=pyh9f0ad1d_0 + - olefile=0.46=py_0 + - openjpeg=2.3.1=h254dc36_3 + - openpyxl=3.0.5=py_0 + - openssl=1.1.1g=haf1e3a3_1 + - packaging=20.4=pyh9f0ad1d_0 + - pandas=1.1.2=py37hdadc0f0_0 + - pandoc=2.10.1=haf1e3a3_0 + - pandocfilters=1.4.2=py_1 + - parso=0.8.0=pyh9f0ad1d_0 + - partd=1.1.0=py_0 + - path=15.0.0=py37hc8dfbb8_0 + - path.py=12.5.0=0 + - pathlib2=2.3.5=py37hc8dfbb8_1 + - pathtools=0.1.2=py_1 + - patsy=0.5.1=py_0 + - pcre=8.44=h4a8c4bd_0 + - pep8=1.7.1=py_0 + - pexpect=4.8.0=py37hc8dfbb8_1 + - pickleshare=0.7.5=py37hc8dfbb8_1001 + - pillow=7.2.0=py37hfd78ece_1 + - pip=20.2.3=py_0 + - pixman=0.38.0=h01d97ff_1003 + - pkginfo=1.5.0.1=py_0 + - pluggy=0.13.1=py37hc8dfbb8_2 + - ply=3.11=py_1 + - poppler=0.89.0=h3232a60_1 + - poppler-data=0.4.9=1 + - postgresql=12.3=h62ab893_0 + - proj=7.1.0=h45baca5_1 + - prometheus_client=0.8.0=pyh9f0ad1d_0 + - prompt-toolkit=3.0.7=py_0 + - prompt_toolkit=3.0.7=0 + - psutil=5.7.2=py37h60d8a13_0 + - ptyprocess=0.6.0=py_1001 + - py=1.9.0=pyh9f0ad1d_0 + - py-lief=0.10.1=py37hdadc0f0_1 + - pycodestyle=2.5.0=py37_0 + - pycosat=0.6.3=py37h60d8a13_1004 + - pycparser=2.20=pyh9f0ad1d_2 + - pycrypto=2.6.1=py37h9bfed18_1004 + - pycurl=7.43.0.5=py37h7d0efee_2 + - pydocstyle=5.1.1=py_0 + - pyflakes=2.1.1=py37_0 + - pygments=2.7.1=py_0 + - pylint=2.6.0=py37hc8dfbb8_0 + - pyodbc=4.0.30=py37h4a8c4bd_0 + - pyomo=5.7.1=py37hdadc0f0_0 + - pyopenssl=19.1.0=py_1 + - pyparsing=2.4.7=pyh9f0ad1d_0 + - pyproj=2.6.1.post1=py37h05a9fa5_1 + - pyqt=5.12.3=py37ha62fc16_3 + - pyrsistent=0.17.3=py37h60d8a13_0 + - pysocks=1.7.1=py37hc8dfbb8_1 + - pytables=3.6.1=py37he7827f7_2 + - pytest=6.0.2=py37hc8dfbb8_0 + - python=3.7.8=hc9dea61_1_cpython + - python-dateutil=2.8.1=py_0 + - python-jsonrpc-server=0.3.4=pyh9f0ad1d_1 + - python-language-server=0.31.10=py37_0 + - python-libarchive-c=2.9=py37hc8dfbb8_0 + - python.app=1.3=py37h9bfed18_1 + - python_abi=3.7=1_cp37m + - pytz=2020.1=pyh9f0ad1d_0 + - pyutilib=6.0.0=pyh9f0ad1d_0 + - pywavelets=1.1.1=py37h57c32b8_2 + - pyyaml=5.3.1=py37h60d8a13_0 + - pyzmq=19.0.2=py37hf1e22d8_0 + - qdarkstyle=2.8.1=pyh9f0ad1d_1 + - qt=5.12.9=h717870c_0 + - qtawesome=0.7.2=pyh9f0ad1d_0 + - qtconsole=4.7.7=pyh9f0ad1d_0 + - qtpy=1.9.0=py_0 + - readline=8.0=h0678c8f_2 + - regex=2020.7.14=py37h60d8a13_0 + - requests=2.24.0=pyh9f0ad1d_0 + - ripgrep=12.1.1=h0b31af3_0 + - rope=0.17.0=pyh9f0ad1d_0 + - rtree=0.9.4=py37h8526d28_1 + - ruamel_yaml=0.15.80=py37h60d8a13_1002 + - scikit-image=0.17.2=py37h6d0141a_2 + - scikit-learn=0.23.2=py37hb7e9fed_0 + - scipy=1.5.2=py37h2702c91_0 + - seaborn=0.11.0=0 + - seaborn-base=0.11.0=py_0 + - send2trash=1.5.0=py_0 + - shapely=1.7.1=py37h40e7c26_0 + - simplegeneric=0.8.1=py_1 + - singledispatch=3.4.0.3=py37_1000 + - sip=4.19.24=py37hdadc0f0_0 + - six=1.15.0=pyh9f0ad1d_0 + - snappy=1.1.8=hb1e8313_3 + - snowballstemmer=2.0.0=py_0 + - sortedcollections=1.2.1=pyh9f0ad1d_0 + - sortedcontainers=2.2.2=pyh9f0ad1d_0 + - soupsieve=2.0.1=py_1 + - sphinx=3.2.1=py_0 + - sphinxcontrib=1.0=py37_1 + - sphinxcontrib-applehelp=1.0.2=py_0 + - sphinxcontrib-devhelp=1.0.2=py_0 + - sphinxcontrib-htmlhelp=1.0.3=py_0 + - sphinxcontrib-jsmath=1.0.1=py_0 + - sphinxcontrib-qthelp=1.0.3=py_0 + - sphinxcontrib-serializinghtml=1.1.4=py_0 + - sphinxcontrib-websupport=1.2.4=pyh9f0ad1d_0 + - spyder=3.3.6=py37_0 + - spyder-kernels=0.5.2=py37_0 + - sqlalchemy=1.3.19=py37h60d8a13_0 + - sqlite=3.33.0=h960bd1c_0 + - statsmodels=0.12.0=py37h60d8a13_0 + - sympy=1.6.2=py37hc8dfbb8_0 + - tbb=2019.9=ha1b3eb9_1 + - tblib=1.6.0=py_0 + - terminado=0.9.1=py37hc8dfbb8_0 + - testpath=0.4.4=py_0 + - threadpoolctl=2.1.0=pyh5ca1d4c_0 + - tifffile=2020.9.3=py_0 + - tiledb=2.0.8=h8973ade_0 + - tk=8.6.10=hb0a8c7a_0 + - toml=0.10.1=pyh9f0ad1d_0 + - toolz=0.10.0=py_0 + - tornado=6.0.4=py37h9bfed18_1 + - tqdm=4.49.0=pyh9f0ad1d_0 + - traitlets=5.0.4=py_0 + - typed-ast=1.4.1=py37h0b31af3_0 + - typing_extensions=3.7.4.2=py_0 + - tzcode=2020a=h0b31af3_0 + - ujson=1.35=py37h570ac47_1002 + - unicodecsv=0.14.1=py_1 + - unixodbc=2.3.9=hcdbd15d_0 + - urllib3=1.25.10=py_0 + - watchdog=0.10.3=py37h60d8a13_1 + - wcwidth=0.2.5=pyh9f0ad1d_1 + - webencodings=0.5.1=py_1 + - werkzeug=1.0.1=pyh9f0ad1d_0 + - wheel=0.35.1=pyh9f0ad1d_0 + - widgetsnbextension=3.5.1=py37hc8dfbb8_1 + - wrapt=1.11.2=py37h9bfed18_0 + - wurlitzer=2.0.0=py37hc8dfbb8_1 + - xerces-c=3.2.3=h0a0444a_1 + - xlrd=1.2.0=pyh9f0ad1d_1 + - xlsxwriter=1.3.4=pyh9f0ad1d_0 + - xlwings=0.20.7=py37hc8dfbb8_0 + - xlwt=1.3.0=py_1 + - xmltodict=0.12.0=py_0 + - xz=5.2.5=haf1e3a3_1 + - yaml=0.2.5=haf1e3a3_0 + - yapf=0.30.0=pyh9f0ad1d_0 + - zeromq=4.3.2=h4a8c4bd_3 + - zfp=0.5.5=h4a8c4bd_1 + - zict=2.0.0=py_0 + - zipp=3.1.0=py_0 + - zlib=1.2.11=h7795811_1009 + - zope=1.0=py37_1 + - zope.event=4.5.0=pyh9f0ad1d_0 + - zope.interface=5.1.0=py37h9bfed18_0 + - zstd=1.4.5=h289c70a_2 + - pip: + - numpy==1.19.2 + - pyqt5-sip==4.19.18 + - pyqtchart==5.12 + - pyqtwebengine==5.12.1 + - setuptools==50.3.0 +prefix: /Users/taolu/anaconda3 diff --git a/pyincore/analyses/shelbycge/shelby/Equationlib.py b/pyincore/analyses/shelbycge/shelby/Equationlib.py new file mode 100755 index 000000000..42fb37a12 --- /dev/null +++ b/pyincore/analyses/shelbycge/shelby/Equationlib.py @@ -0,0 +1,806 @@ +from copy import deepcopy +import pandas as pd +import operator as op +import math + + +class VarContainer: + """ + All matrix variable(tables) in the GAMS model is flatten to a array to make a better + interface to the solver. + + AllVarList stores all initial values of varibles used in the GAMS model in an array. + It also has a indexing system for looking up. + + Attributes: + namelist: A dictionary with all stored GAMS variables and its information. + nvars: The length of the array, i.e. the size of all matrix variables summed up. + initialVals: Stored initial values of all variables + + """ + + def __init__(self): + """ + Initialize to an empty list + """ + self.namelist = {} + self.initialVals = [] + self.nvars = 0 + self.LO = [] + self.UP = [] + + def add(self, name, rows=None, cols=None): + """ + :param name: + :param rows: + :param cols: + :return: + """ + if rows is not None and cols is not None: + size = len(rows) * len(cols) + self.namelist[name] = { + 'nrows': len(rows), + 'ncols': len(cols), + 'rows': rows, + 'cols': cols, + 'start': self.nvars, + 'size': size + } + elif rows is not None and cols is None: + size = len(rows) + self.namelist[name] = { + 'nrows': len(rows), + 'rows': rows, + 'start': self.nvars, + 'size': size + } + else: + size = 1 + self.namelist[name] = {'start': self.nvars, 'size': 1} + + self.initialVals.extend([None] * size) + self.LO.extend([None] * size) + self.UP.extend([None] * size) + self.nvars += size + + return ExprM(self, name=name, rows=rows, cols=cols) + + def set_value(self, name, values, target): + """ + An internal method for setting the initial values or UPs and LOs for variables + + :param name: Name of the variable in GAMS + :param value: a pandas DataFrame, pandas Series, int or float with initial values + :param target: target array to be set + + :return: None + """ + if type(values) == int or type(values) == float: + info = self.namelist[name] + if 'nrows' in info and 'ncols' in info: + values = pd.DataFrame(index=info['rows'], columns=info['cols']).fillna(values) + elif 'nrows' in info and 'ncols' not in info: + values = pd.Series(index=info['rows']).fillna(values) + + if type(values) == pd.DataFrame: + rows = values.index.tolist() + cols = values.columns.tolist() + for i in rows: + for j in cols: + target[self.getIndex(name, row=i, col=j)] = float(values.loc[i][j]) + elif type(values) == pd.Series: + rows = values.index.tolist() + for i in rows: + target[self.getIndex(name, row=i)] = float(values.loc[i]) + else: + target[self.getIndex(name)] = values + + def init(self, name, initialValue): + """ + Flatten the table variable and add to the list. + Also set the initial variable values array. + + :param name: Name of the variable in GAMS + :param initialValue: a pandas DataFrame or pandas Series with initial values + + :return: None. + """ + self.set_value(name, initialValue, self.initialVals) + + def inList(self, name): + """ + Check if a GAMS varible is added to the container + + :param name(str): name of GAMS variable you want to look up + :return: Boolean, whether the variable is added. + """ + return name in self.namelist + + def getInfo(self, name): + """ + Get the information about a GAMS variable + + :param name(str): name of GAMS variable you want to look up + :return: a dictionary with all information + """ + return self.namelist[name] + + def getIndex(self, name, row=None, col=None): + """ + Look up the index by providing the variable name and label information + + :param name: name of GAMS variable you want to look up + :param row: row label of the position you want to look up index for(if it has row labels) + :param col: column label of the position you want to look up index for(if it has column labels) + :return: the index of the position in the array + """ + info = self.namelist[name] + result = info['start'] + if row is not None and col is not None: + result += info['rows'].index(row) * info['ncols'] + info['cols'].index(col) + elif row is not None: + result += info['rows'].index(row) + return result + + def getLabel(self, index): + """ + Look up variable name and label information by providing the index + + :param index: the index in the array + :return: its information including the variable name, row label and column label if applicable + """ + result = [] + for i in self.namelist.keys(): + if index >= self.namelist[i]['start'] and index < self.namelist[i]['start'] + self.namelist[i]['size']: + result.append(i) + if self.namelist[i]['size'] > 1: + diff = index - self.namelist[i]['start'] + if 'ncols' in self.namelist[i]: + result.append(self.namelist[i]['rows'][int(diff / self.namelist[i]['ncols'])]) + result.append(self.namelist[i]['cols'][diff % self.namelist[i]['ncols']]) + else: + result.append(self.namelist[i]['rows'][diff]) + return result + + def get_all_variable_printed(self, output=None): + if output is None: + output = self.initialVals + for i in range(len(output)): + label = self.getLabel(i) + if len(label) == 1: + print(label[0] + '=' + '{0:.7f}'.format(output[i]) + ';') + elif len(label) == 2: + print(label[0] + '(\'' + label[1] + '\')' + '=' + '{0:.7f}'.format(output[i]) + ';') + elif len(label) == 3: + print( + label[0] + '(\'' + label[1] + '\',\'' + label[2] + '\')' + '=' + '{0:.7f}'.format(output[i]) + ';') + + def get(self, name, x=None): + """ + Returns a Dataframe, Series, or a variable based on the given name and the result array returned from the solver + + :param name: GAMS variable name + :return: if x is not given, it returns the initial values + if x is set to the result, returns the result variable value + """ + if x is None: + x = self.initialVals + + info = self.namelist[name] + if 'nrows' in info and 'ncols' in info: + ret = pd.DataFrame(index=info['rows'], columns=info['cols']).fillna(0.0) + for i in info['rows']: + for j in info['cols']: + ret.at[i, j] = x[self.getIndex(name, row=i, col=j)] + elif 'nrows' in info and 'ncols' not in info: + ret = pd.Series(index=info['rows']).fillna(0.0) + for i in info['rows']: + ret.at[i] = x[self.getIndex(name, row=i)] + elif 'nrows' not in info and 'ncols' not in info: + ret = x[self.getIndex(name)] + + return ret + + def lo(self, name, value): + """ + Set the LOs of a GAMS variable providing the LOs with a Dataframe, Series, int or float + + :param name: GAMS variable name + :param value: The lower bound to be set + :return: None + """ + self.set_value(name, value, self.LO) + + def up(self, name, value): + """ + Set the UPs of a GAMS variable providing the LOs with a Dataframe, Series, int or float + + :param name: GAMS variable name + :param value: The upper bound to be set + :return: None + """ + self.set_value(name, value, self.UP) + + def write(self, filename): + """ + Write(append) the variables to a file, in the format of setting ipopt model variables + + :param filename: the output filename + :return: None + """ + with open(filename, 'a') as f: + for i in range(self.nvars): + lower = -1e20 if self.LO[i] == None else self.LO[i] + upper = 1e20 if self.UP[i] == None else self.UP[i] + value = 0 if math.isnan(self.initialVals[i]) else self.initialVals[i] + + f.write('model.x' + str(i) + ' = Var(bounds=(' + str(lower) + ',' + str(upper) + '),initialize=' + str( + value) + ')' + '\n') + + +class variable: + """ + A GMAS variable, initialized by given the GAMS variable value and its label + """ + + def __init__(self, vars, name, row=None, col=None): + """ + Initialize it with a variable container, the GAMS name, the labels + + :param vars: the variable container that already added the GAMS variable + :param name: GAMS variable name + :param row: GAMS row label if there is + :param col: GAMS col label if there is + :return: None + """ + try: + self.index = vars.getIndex(name, row, col) + except Exception as e: + print(e) + + def __str__(self): + """ + returns the variable in the format of "model.x#" if gets printed, + with # being the index in the array in the container + + :return: String + """ + return 'model.x' + str(self.index) + '' + + def debug_test_str(self): + return 'x[' + str(self.index) + ']' + + +class ExprItem: + """ + You can construct it with a variable, a constant or a deepcopy of another ExprItem + """ + + def __init__(self, v, const=1): + self.varList = [] + self.const = const + if type(v) == variable: + self.varList.append(v) + elif type(v) == int or type(v) == float: + self.const = v + elif type(v) == ExprItem: + self.const = deepcopy(v.const) + self.varList = deepcopy(v.varList) + else: + print("invalid parameter to create a item") + + ''' + You could multiply it with a number, a variable, a ExprItem or Expression + ''' + + def __mul__(self, rhs): + copy = ExprItem(self) + if type(rhs) == int or type(rhs) == float: + copy.const = copy.const * rhs + elif type(rhs) == variable: + copy.varList.append(rhs) + elif type(rhs) == ExprItem: + copy.const *= rhs.const + copy.varList.extend(deepcopy(rhs.varList)) + elif type(rhs) == Expr: + if rhs.isComposite: + if rhs.operator == '/': + return rhs * copy + else: + copy.varList.append(Expr(rhs)) + else: + copyrhs = Expr(rhs) + copyrhs.itemList = [i * copy for i in copyrhs.itemList] + return copyrhs + return copy + + def __str__(self): + result = '' + str(self.const) + for i in range(len(self.varList)): + result += "*" + self.varList[i].__str__() + return result + + def debug_test_str(self): + result = '' + str(self.const) + for i in range(len(self.varList)): + result += "*" + self.varList[i].debug_test_str() + return result + + def is_empty(self): + if abs(self.const) < 0.00000001: + return True + else: + return False + + def is_one(self): + if abs(self.const - 1) < 0.0000001 and len(self.varList) == 0: + return True + else: + return False + + +class Expr: + + def __init__(self, item): + self.itemList = [] + self.isComposite = False + if type(item) == ExprItem or type(item) == variable or type(item) == int or type(item) == float: + self.itemList.append(ExprItem(item)) + elif type(item) == Expr: + self.itemList = [ + ExprItem(item.itemList[i]) if type(item.itemList[i]) == ExprItem else Expr(item.itemList[i]) for i in + range(len(item.itemList))] + try: + self.isComposite = deepcopy(item.isComposite) + except Exception as e: + pass + try: + self.operator = deepcopy(item.operator) + except Exception as e: + pass + try: + self.first = Expr(item.first) + except Exception as e: + pass + try: + self.second = Expr(item.second) + except Exception as e: + pass + else: + print("invalid parameter for creating a Expr") + + self.clear_empty() + + def __add__(self, rhs): + copy = Expr(self) + if self.isComposite: + tmp = Expr(self) + copy.itemList = [tmp] + copy.isComposite = False + if type(rhs) == Expr: + if rhs.isComposite: + rhscopy = Expr(rhs) + copy.itemList.append(rhscopy) + else: + rhscopy = Expr(rhs) + copy.itemList = copy.itemList + rhscopy.itemList + elif type(rhs) == ExprItem or type(rhs) == int or type(rhs) == float or type(rhs) == variable: + copy.itemList.append(ExprItem(rhs)) + return copy + + def __sub__(self, rhs): + copy = Expr(self) + return copy + rhs * -1 + + def __mul__(self, rhs): + copy = Expr(self) + if type(rhs) == int or type(rhs) == float or type(rhs) == ExprItem: + if copy.isComposite: + if copy.operator == '/': + copy.first = copy.first * rhs + elif copy.opeartor == '**': + return ExprItem(rhs) * copy + else: + result = [] + for i in copy.itemList: + result.append(i * rhs) + copy.itemList = result + + elif type(rhs) == Expr: + if copy.isComposite and not rhs.isComposite: + if copy.operator == '/': + copy.first = copy.first * rhs + else: + copy.itemList = [i * copy for i in rhs.itemList] + copy.isComposite = False + elif not copy.isComposite and not rhs.isComposite: + if len(copy.itemList) * len(rhs.itemList) > 10: + + tmpItem = ExprItem(1) + tmpItem.varList.append(Expr(copy)) + tmpItem.varList.append(Expr(rhs)) + copy.itemList = [tmpItem] + else: + + # The expanding way is super slow for long equations + result = [] + for i in copy.itemList: + for j in rhs.itemList: + if type(i) == Expr: + tmp = Expr(i) + elif type(i) == ExprItem: + tmp = ExprItem(i) + result.append(tmp * j) + copy.itemList = result + + elif not self.isComposite and rhs.isComposite: + return rhs * copy + else: + # both are composite + if copy.operator == '/' and rhs.operator == '/': + copy.first = copy.first * rhs.first + copy.second = copy.second * rhs.second + elif copy.operator == '**' and rhs.operator == '**': + copy.first = copy.first * rhs.first + copy.second = copy.second + rhs.second + elif copy.operator == '/' and rhs.operator == '**': + copy.first = copy.first * rhs + elif copy.operator == '**' and rhs.operator == '/': + copyrhs = Expr(rhs) + copyrhs.first = copyrhs.first * copy + return copy + + def __truediv__(self, rhs): + copy = Expr(self) + tmp = Expr(copy) + copy.isComposite = True + copy.operator = '/' + copy.first = tmp + copy.second = Expr(rhs) + return copy + + def __pow__(self, rhs): + copy = Expr(self) + tmp = Expr(copy) + copy.isComposite = True + copy.operator = '**' + copy.first = tmp + copy.second = Expr(rhs) + return copy + + def __str__(self): + if self.isComposite: + result = "(" + self.first.__str__() + self.operator + self.second.__str__() + ")" + else: + if len(self.itemList) == 0: + return '0' + result = '' + for i in self.itemList[0:-1]: + result += "(" + i.__str__() + ")" + "+" + result += "(" + self.itemList[-1].__str__() + ")" + if len(self.itemList) > 1: + result = "(" + result + ")" + return result + + def debug_test_str(self): + if self.isComposite: + result = "(" + self.first.debug_test_str() + self.operator + self.second.debug_test_str() + ")" + else: + if len(self.itemList) == 0: + return '0' + result = '' + for i in self.itemList[0:-1]: + result += "(" + i.debug_test_str() + ")" + "+" + result += "(" + self.itemList[-1].debug_test_str() + ")" + if len(self.itemList) > 1: + result = "(" + result + ")" + return result + + def is_empty(self): + if not self.isComposite and len(self.itemList) == 0: + return True + else: + return False + + def clear_empty(self): + result = [] + if self.isComposite == False: + for i in range(len(self.itemList)): + if type(self.itemList[i]) == ExprItem: + if not self.itemList[i].is_empty(): + result.append(self.itemList[i]) + if type(self.itemList[i]) == Expr: + self.itemList[i].clear_empty() + if not self.itemList[i].is_empty(): + result.append(self.itemList[i]) + self.itemList = result + + +class ExprM: + """ + Three ways to create a ExprMatrix: + 1. Give it the variable name, selected rows and cols(could be empty), + The constructor will create a Expression matrix from the variable matrix + 2. Give it a pandas Series or DataFrame, it will create the Expression matrix + with the content in the Series or DataFrame as constants + 3. Give it a ExprMatrix, will return a deep copy of it + """ + + def __init__(self, vars, name=None, rows=None, cols=None, m=None, em=None): + self.vars = vars + self.hasCondition = False + if em is None: + # if these are the variables, we need to create an Expression by the variable name + if name is not None: + if self.vars.inList(name): + self.info = deepcopy(self.vars.getInfo(name)) + else: + print("Can't find this variable in the all variable list") + + self.info['height'] = 1 + self.info['width'] = 1 + self.info['rows'] = deepcopy(rows) + self.info['cols'] = deepcopy(cols) + if cols is not None: + self.info['width'] = len(cols) + if rows is not None: + self.info['height'] = len(rows) + + if cols is not None: # if it is a DataFrame + self.m = [[Expr(variable(self.vars, name, i, j)) for j in cols] for i in rows] + elif rows is not None: # if it is a Series + self.m = [[Expr(variable(self.vars, name, i))] for i in rows] + else: # if it is a variable + self.m = [[Expr(variable(self.vars, name))]] + + # otherwise these are just constants + else: + self.info = {} + self.info['height'] = 1 + self.info['width'] = 1 + self.info['rows'] = None + self.info['cols'] = None + if type(m) == pd.DataFrame: + self.info['rows'] = m.index.tolist() + self.info['height'] = len(self.info['rows']) + self.info['cols'] = m.columns.tolist() + self.info['width'] = len(self.info['cols']) + self.m = [[Expr(float(m.loc[i, j])) for j in self.info['cols']] for i in self.info['rows']] + elif type(m) == pd.Series: + self.info['rows'] = m.index.tolist() + self.info['height'] = len(self.info['rows']) + self.m = [[Expr(float(m.loc[i]))] for i in self.info['rows']] + else: + self.m = [[Expr(float(m))]] + else: + # make deep copy + self.info = deepcopy(em.info) + self.m = [[Expr(em.m[i][j]) for j in range(em.info['width'])] for i in range(em.info['height'])] + + def operation(self, rhs, oper): + copy = ExprM(self.vars, em=self) + + if type(rhs) == int or type(rhs) == float: + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j], Expr(rhs)) + + elif type(rhs) == pd.DataFrame or type(rhs) == pd.Series: + return self.operation(ExprM(self.vars, m=rhs), oper) + + elif type(rhs) == ExprM: + if copy.info['rows'] == rhs.info['rows'] and copy.info['cols'] == rhs.info['cols']: + # same size, apply operation element-wise + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j], rhs.m[i][j]) + elif copy.info['rows'] == rhs.info['rows'] and copy.info['width'] == 1: + # for each column in rhs + result = [[Expr(0) for j in range(rhs.info['width'])] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(rhs.info['width']): + result[i][j] = oper(copy.m[i][0], rhs.m[i][j]) + copy.m = result + copy.info['width'] = rhs.info['width'] + copy.info['cols'] = deepcopy(rhs.info['cols']) + elif copy.info['rows'] == rhs.info['rows'] and rhs.info['width'] == 1: + # for each column in lhs + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j], rhs.m[i][0]) + elif copy.info['height'] == 1 and copy.info['cols'] == rhs.info['cols']: + # for each row in rhs + result = [[Expr(0) for j in range(rhs.info['width'])] for i in range(rhs.info['height'])] + for i in range(rhs.info['height']): + for j in range(rhs.info['width']): + result[i][j] = oper(copy.m[0][j], rhs.m[i][j]) + copy.m = result + copy.info['height'] = rhs.info['height'] + copy.info['rows'] = deepcopy(rhs.info['rows']) + elif rhs.info['height'] == 1 and copy.info['cols'] == rhs.info['cols']: + # for each row in lhs + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j], rhs.m[0][j]) + elif (self.info['width'] == rhs.info['height'] and self.info['cols'] == rhs.info['rows']) or \ + (self.info['height'] == rhs.info['width'] and self.info['rows'] == rhs.info['cols']): + # flip the matrix + return oper(self, ~rhs) + + else: + print(copy.info['rows'], copy.info['cols'], rhs.info['rows'], rhs.info['cols']) + print(copy.info['height'], copy.info['width'], rhs.info['height'], rhs.info['width']) + print("Invalid size for ", str(oper)) + return copy + + def __add__(self, rhs): + return self.operation(rhs, op.add) + + def __radd__(self, lhs): + return self + lhs + + def __sub__(self, rhs): + return self.operation(rhs, op.sub) + + def __rsub__(self, lhs): + return self * -1 + lhs + + def __mul__(self, rhs): + return self.operation(rhs, op.mul) + + def __truediv__(self, rhs): + return self.operation(rhs, op.truediv) + + def __pow__(self, rhs): + return self.operation(rhs, op.pow) + + def __xor__(self, rhs): + """ + create 2d list out of 2 single lists + """ + # has to be 2 single lists + if self.info['width'] != 1 or rhs.info['width'] != 1: + print("Invalid size for creating a 2-D matrix") + else: + copy = ExprM(self.vars, em=self) + copy.m = [[copy.m[i][0] * rhs.m[j][0] for j in range(rhs.info['height'])] for i in + range(copy.info['height'])] + copy.info['cols'] = deepcopy(rhs.info['rows']) + copy.info['width'] = deepcopy(rhs.info['height']) + return copy + + def __invert__(self): + """ + Return the transpose of a Expression matrix + """ + copy = ExprM(self.vars, em=self) + result = [[copy.m[i][j] for i in range(copy.info['height'])] for j in range(copy.info['width'])] + copy.info['height'], copy.info['width'] = copy.info['width'], copy.info['height'] + copy.info['rows'], copy.info['cols'] = copy.info['cols'], copy.info['rows'] + copy.m = result + return copy + + def __str__(self): + result = '' + for i in self.m: + for j in i: + result += j.__str__() + '\n' + result += '///////////////////\n' + return result + + def loc(self, rows=None, cols=None): + """ + get a subset of the matrix by labels + """ + copy = ExprM(self.vars, em=self) + if cols is not None: + result = [[Expr(copy.m[self.info['rows'].index(i)][self.info['cols'].index(j)]) for j in cols] for i in + rows] + copy.m = result + copy.info['rows'] = deepcopy(rows) + copy.info['height'] = len(copy.info['rows']) + copy.info['cols'] = deepcopy(cols) + copy.info['width'] = len(copy.info['cols']) + return copy + elif rows is not None: + result = [[Expr(copy.m[self.info['rows'].index(i)][0])] for i in rows] + copy.m = result + copy.info['rows'] = deepcopy(rows) + copy.info['height'] = len(copy.info['rows']) + return copy + else: + return copy + + def sum(self, label=None): + copy = ExprM(self.vars, em=self) + if label is None: + result = Expr(0) + for i in range(self.info['height']): + for j in range(self.info['width']): + result = result + copy.m[i][j] + copy.m = [[result]] + copy.info['width'] = 1 + copy.info['height'] = 1 + copy.info['rows'] = None + copy.info['cols'] = None + + elif label == self.info['rows'] or label == 0: + result = [[Expr(0) for j in range(self.info['width'])]] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[0][j] = result[0][j] + copy.m[i][j] + copy.m = result + copy.info['height'] = 1 + copy.info['rows'] = None + + elif label == self.info['cols'] or label == 1: + result = [[Expr(0)] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[i][0] = result[i][0] + copy.m[i][j] + copy.m = result + copy.info['width'] = 1 + copy.info['cols'] = None + return copy + + def prod(self, label): + copy = ExprM(self.vars, em=self) + if label == self.info['rows'] or label == 0: + result = [[Expr(1) for j in range(self.info['width'])]] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[0][j] = result[0][j] * copy.m[i][j] + copy.m = result + copy.info['height'] = 1 + copy.info['rows'] = None + elif label == self.info['cols'] or label == 1: + result = [[Expr(1)] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[i][0] = result[i][0] * copy.m[i][j] + copy.m = result + copy.info['width'] = 1 + copy.info['cols'] = None + return copy + + def setCondition(self, matrix, operator=None, value=None): + self.hasCondition = True + mappings = {'LT': op.lt, 'LE': op.le, 'EQ': op.eq, 'INEQ': op.ne} # not complete list + if type(matrix) == pd.DataFrame: + self.mark = [[False for j in range(self.info['width'])] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(self.info['width']): + if operator == None: + self.mark[i][j] = op.ne(matrix.loc[self.info['rows'][i]][self.info['cols'][j]], 0) + else: + self.mark[i][j] = mappings[operator](matrix.loc[self.info['rows'][i]][self.info['cols'][j]], + value) + + if type(matrix) == pd.Series: + self.mark = [[False] for i in range(self.info['height'])] + for i in range(self.info['height']): + if operator == None: + self.mark[i][0] = op.ne(matrix.loc[self.info['rows'][i]], 0) + else: + self.mark[i][0] = mappings[operator](matrix.loc[self.info['rows'][i]], value) + + def write(self, count, filename): + f = open(filename, 'a') + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + f.write( + 'model.equality' + str(count[0]) + ' = Constraint(expr=' + self.m[i][j].__str__() + ' == 0)\n') + count[0] += 1 + f.close() + + def test(self, x): + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + fun = lambda x: eval(self.m[i][j].debug_test_str()) + print(i, j, fun(x)) diff --git a/pyincore/analyses/shelbycge/shelby/OutputFunctions.py b/pyincore/analyses/shelbycge/shelby/OutputFunctions.py new file mode 100755 index 000000000..25b9f6ec7 --- /dev/null +++ b/pyincore/analyses/shelbycge/shelby/OutputFunctions.py @@ -0,0 +1,73 @@ +''' +functions for output validation + +# NOTE: +This is a hack to create dataframes that resemble matrix results +returned in GAMS +''' + +import shelby.Equationlib +import pandas as pd +import numpy as np + + +# Return initial values function +def baseValue(vars, soln, eqName): + if vars.getInfo(eqName)['size'] == 1: + basevalues = vars.initialVals[vars.getIndex(eqName)] + + else: + rows = vars.getInfo(eqName)['rows'] + rws = [] + if vars.getInfo(eqName)['size'] == vars.getInfo(eqName)['nrows']: + for rr in rows: + number = vars.initialVals[vars.getIndex(eqName, row=rr)] + rws.append(number) + basevalues = pd.DataFrame(rws, index=rows) + + else: + cols = vars.getInfo(eqName)['cols'] + for rr in rows: + clms = [] + for cc in cols: + number = vars.initialVals[vars.getIndex(eqName, row=rr, col=cc)] + clms.append(number) + rws.append(clms) + basevalues = pd.DataFrame(rws, index=rows, columns=cols) + + return basevalues + + +# Get the new values function +def newValue(vars, soln, eqName, ittr): + # for scalar + if vars.getInfo(eqName)['size'] == 1: + newvalue = soln[ittr][vars.getIndex(eqName)] + + else: + rows = vars.getInfo(eqName)['rows'] + rws = [] + # vectors + if vars.getInfo(eqName)['size'] == vars.getInfo(eqName)['nrows']: + for rr in rows: + number = soln[ittr][vars.getIndex(eqName, row=rr)] + rws.append(number) + newvalue = pd.DataFrame(rws, index=rows) + # data frames + else: + for rr in rows: + cols = vars.getInfo(eqName)['cols'] + clms = [] + for cc in cols: + number = soln[ittr][vars.getIndex(eqName, row=rr, col=cc)] + clms.append(number) + rws.append(clms) + newvalue = pd.DataFrame(rws, index=rows, columns=cols) + + return newvalue + + +# Get differences function +def getDiff(vars, soln, eqName, ittr): + difference = newValue(vars, soln, eqName, ittr) - baseValue(vars, soln, eqName) + return difference diff --git a/pyincore/analyses/shelbycge/shelby/__init__.py b/pyincore/analyses/shelbycge/shelby/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/pyincore/analyses/shelbycge/shelby/shelby/__init__.py b/pyincore/analyses/shelbycge/shelby/shelby/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/pyincore/analyses/shelbycge/shelby/shelby_output.py b/pyincore/analyses/shelbycge/shelby/shelby_output.py new file mode 100755 index 000000000..4d8a6596d --- /dev/null +++ b/pyincore/analyses/shelbycge/shelby/shelby_output.py @@ -0,0 +1,211 @@ +""" +# After running a model, use solution dictionaries to replicate GAMS +# results with DataFrames +# +# NOTE: +# solution variables stored in "vars" and "soln" objects should +# be the primary source for model evaluation. +# This swas only created to assist those unfamiliar with python objects +""" + +#from jopSmall.OutputFunctions import baseValue, newValue, getDiff +import pandas as pd + +#CG0 +CG0 = vars.get('CG', x=soln[0]) + +#CH0 +CH0 = vars.get('CH', x=soln[0]) + +#CMI0 +CMI0 = vars.get('CMI', x=soln[0]) + +#CMO0 +CMO0 = vars.get('CMO', x=soln[0]) + +#CN0 +CN0 = vars.get('CN', x=soln[0]) + +#CPI0 +CPI0 = vars.get('CPI', x=soln[0]) + +#CX0 +CX0 = vars.get('CX', x=soln[0]) + +#D0 +D0 = vars.get('D', x=soln[0]) + +#DD0 +DD0 = vars.get('DD', x=soln[0]) + +#DS0 +DS0 = vars.get('DS', x=soln[0]) + +#FD +FD0 = vars.get('FD', x=soln[0]) + +#IGT +IGT0 = vars.get('IGT', x=soln[0]) + +#KS +KS0 = vars.get('KS', x=soln[0]) + +#LAS +#LAS0 = vars.get('LAS', x=soln[0]) + +#HH +HH0 = vars.get('HH', x=soln[0]) + +#HN +HN0 = vars.get('HN', x=soln[0]) + +#HW +HW0 = vars.get('HW', x=soln[0]) + +#M +M0 = vars.get('M', x=soln[0]) + +#N +N0 = vars.get('N', x=soln[0]) + +#NKI +NKI0 = vars.get('NKI', x=soln[0]) + +#LNFOR +#LNFOR0 = vars.get('LNFOR', x=soln[0]) + +#KPFOR +KPFOR0 = vars.get('KPFOR', x=soln[0]) + +#GVFOR +GVFOR0 = vars.get('GVFOR', x=soln[0]) + +#P +P0 = vars.get('P', x=soln[0]) + +#PD +PD0 = vars.get('PD', x=soln[0]) + +#PVA +PVA0 = vars.get('PVA', x=soln[0]) + +#RA +RA0 = vars.get('RA', x=soln[0]) + +#R +R0 = vars.get('R', x=soln[0]) + +#S +S0 = vars.get('S', x=soln[0]) + +#SPI +SPI0 = vars.get('SPI', x=soln[0]) + +#V +V0 = vars.get('V', x=soln[0]) + +#Y +Y0 = vars.get('Y', x=soln[0]) + +#Yd +YD0 = vars.get('YD', x=soln[0]) + +# DIFFERENCES +writer = pd.ExcelWriter('test.xlsx',engine='xlsxwriter') +workbook=writer.book + +emplist = [] +dsrlist = [] +dsclist = [] +hhinclist = [] +miglist = [] +simlist = [] + +for i in range(iNum): + + CGL = vars.get('CG', x=soln[i+1]) + CHL = vars.get('CH', x=soln[i+1]) + CMIL = vars.get('CMI', x=soln[i+1]) + CMOL = vars.get('CMO', x=soln[i+1]) + CNL = vars.get('CN', x=soln[i+1]) + CPIL = vars.get('CPI', x=soln[i+1]) + CXL = vars.get('CX', x=soln[i+1]) + DL = vars.get('D', x=soln[i+1]) + DDL = vars.get('DD', x=soln[i+1]) + DSL = vars.get('DS', x=soln[i+1]) + FDL = vars.get('FD', x=soln[i+1]) + IGTL = vars.get('IGT', x=soln[i+1]) + KSL = vars.get('KS', x=soln[i+1]) + #LASL = vars.get('LAS', x=soln[i+1]) + HHL = vars.get('HH', x=soln[i+1]) + HNL = vars.get('HN', x=soln[i+1]) + HWL = vars.get('HW', x=soln[i+1]) + ML = vars.get('M', x=soln[i+1]) + NL = vars.get('N', x=soln[i+1]) + NKIL = vars.get('NKI', x=soln[i+1]) + #LNFORL = vars.get('LNFOR', x=soln[i+1]) + KPFORL = vars.get('KPFOR', x=soln[i+1]) + GVFORL = vars.get('GVFOR', x=soln[i+1]) + PL = vars.get('P', x=soln[i+1]) + PDL = vars.get('PD', x=soln[i+1]) + PVAL = vars.get('PVA', x=soln[i+1]) + RAL = vars.get('RA', x=soln[i+1]) + RL = vars.get('R', x=soln[i+1]) + SL = vars.get('S', x=soln[i+1]) + SPIL = vars.get('SPI', x=soln[i+1]) + VL = vars.get('V', x=soln[i+1]) + YL = vars.get('Y', x=soln[i+1]) + YDL = vars.get('YD', x=soln[i+1]) + + DFCG = CGL - CG0 + DFFD = FDL - FD0 + DK = KSL - KS0 + DY = (YL/CPIL) - Y0 + DDS = DSL - DS0 + DDD = DDL - DD0 + DCX = CXL - CX0 + DCH = CHL - CH0 + DR = RL - R0 + DCMI = CMIL - CMI0 + DCMO = CMOL - CMO0 + + DM = ML - M0 + + DV = VL - V0 + + DN = NL - N0 + + s_name = 'Simulation ' + str(i+1) + + + emp = DFFD[DFFD.index.isin(['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'])].sum().sum() + dsr = DDS[DDS.index.isin(['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', + 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'])].sum() + dsc = DDS[DDS.index.isin(['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', 'OTHERH'])].sum() + hhinc = DY[DY.index.isin(['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', 'HH5C', + 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', 'HH5F', + 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'])].sum() + hhdiff = HHL-HH0 + mig = hhdiff.sum() + + emplist.append(emp) + dsrlist.append(dsr) + dsclist.append(dsc) + hhinclist.append(hhinc) + miglist.append(mig) + simlist.append(s_name) + + + +cols = {'dsc' : dsclist, + 'dsr' : dsrlist, + 'mig' : miglist, + 'emp' : emplist, + 'hhinc' : hhinclist} + +df = pd.DataFrame.from_dict(cols) +df.to_csv('simulation_outputs.csv') diff --git a/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py b/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py new file mode 100755 index 000000000..dc79834fe --- /dev/null +++ b/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py @@ -0,0 +1,1867 @@ +from shelby.Equationlib import * +from shelby.OutputFunctions import * +import os +import pandas as pd +from pyomo.environ import * +from pyomo.opt import SolverFactory + + +def _(x): + return ExprM(vars, m=x) + + +# ---------------------------------------------------------------- +# set file paths +# ---------------------------------------------------------------- + + +modelPath = os.path.join(os.getcwd(), 'shelby') +filePath = os.path.join(modelPath, 'shelby') + +# filePath = './JOP_small/' + +# ---------------------------------------------------------------- +# define sets +# ---------------------------------------------------------------- + +# ALL ACCOUNTS IN SOCIAL ACCOUNTING MATRIX + +Z = [ + 'GOODSA', + 'TRADEA', + 'OTHERA', + 'GOODSB', + 'TRADEB', + 'OTHERB', + 'GOODSC', + 'TRADEC', + 'OTHERC', + 'GOODSD', + 'TRADED', + 'OTHERD', + 'GOODSE', + 'TRADEE', + 'OTHERE', + 'GOODSF', + 'TRADEF', + 'OTHERF', + 'GOODSG', + 'TRADEG', + 'OTHERG', + 'GOODSH', + 'TRADEH', + 'OTHERH', + 'HS1A', + 'HS2A', + 'HS3A', + 'HS1B', + 'HS2B', + 'HS3B', + 'HS1C', + 'HS2C', + 'HS3C', + 'HS1D', + 'HS2D', + 'HS3D', + 'HS1E', + 'HS2E', + 'HS3E', + 'HS1F', + 'HS2F', + 'HS3F', + 'HS1G', + 'HS2G', + 'HS3G', + 'HS1H', + 'HS2H', + 'HS3H', + 'L1A', + 'L2A', + 'L3A', + 'L1B', + 'L2B', + 'L3B', + 'L1C', + 'L2C', + 'L3C', + 'L1D', + 'L2D', + 'L3D', + 'L1E', + 'L2E', + 'L3E', + 'L1F', + 'L2F', + 'L3F', + 'L1G', + 'L2G', + 'L3G', + 'L1H', + 'L2H', + 'L3H', + 'KAP', + 'HH1A', + 'HH2A', + 'HH3A', + 'HH4A', + 'HH5A', + 'HH1B', + 'HH2B', + 'HH3B', + 'HH4B', + 'HH5B', + 'HH1C', + 'HH2C', + 'HH3C', + 'HH4C', + 'HH5C', + 'HH1D', + 'HH2D', + 'HH3D', + 'HH4D', + 'HH5D', + 'HH1E', + 'HH2E', + 'HH3E', + 'HH4E', + 'HH5E', + 'HH1F', + 'HH2F', + 'HH3F', + 'HH4F', + 'HH5F', + 'HH1G', + 'HH2G', + 'HH3G', + 'HH4G', + 'HH5G', + 'HH1H', + 'HH2H', + 'HH3H', + 'HH4H', + 'HH5H', + 'INVES', + 'USSOCL1A', + 'USSOCL2A', + 'USSOCL3A', + 'USSOCL1B', + 'USSOCL2B', + 'USSOCL3B', + 'USSOCL1C', + 'USSOCL2C', + 'USSOCL3C', + 'USSOCL1D', + 'USSOCL2D', + 'USSOCL3D', + 'USSOCL1E', + 'USSOCL2E', + 'USSOCL3E', + 'USSOCL1F', + 'USSOCL2F', + 'USSOCL3F', + 'USSOCL1G', + 'USSOCL2G', + 'USSOCL3G', + 'USSOCL1H', + 'USSOCL2H', + 'USSOCL3H', + 'MEMPROPTAX', + 'OTHERPROPTAX', + 'MEMSALESTAX', + 'OTHERSALESTAX', + 'MEMFEE', + 'OTHERFEE', + 'TNSTX', + 'TNITAX', + 'USPIT', + 'CYGFM', + 'CYGFO', + 'FED', + 'STATE', + 'MEMPHIS', + 'OTHER', + 'OUTCOM1', + 'OUTCOM2', + 'OUTCOM3', + 'ROW'] + +# FACTORS +F = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', 'KAP'] + +F11 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] + +F21 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] + +F31 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] + +# COMMUTERS OUT +CM = ['OUTCOM1', 'OUTCOM2', 'OUTCOM3'] + +# COMMUTERS OUT 1 +CM1 = ['OUTCOM1'] + +# COMMUTERS OUT 2 +CM2 = ['OUTCOM2'] + +# COMMUTERS OUT 3 +CM3 = ['OUTCOM3'] + +# ALL WORKERS WHO LIVE IN SHELBY +LT = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', + 'OUTCOM1', 'OUTCOM2', 'OUTCOM3'] + +# LABOR +L = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'] + +L1 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] + +L2 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] + +L3 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] + +# LAND +# LA(F) = ['LAND'] + +# CAPITAL +K = ['KAP'] + +# GOVERNMENTS +G = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', + 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', + 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', + 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', + 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT', 'CYGFM', 'CYGFO', 'FED', + 'STATE', 'MEMPHIS', 'OTHER'] + +# ENDOGENOUS GOVERNMENTS +GN = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] + +# LOCAL ENDOGENOUS GOVERNMENTS +GNLM = ['MEMPHIS'] + +# LOCAL ENDOGENOUS GOVERNMENTS +GNLO = ['OTHER'] + +# EXOGENOUS GOVERMENTS +GX = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', + 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', + 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', + 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', + 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT'] + +# SALES OR EXCISE TAXES +GS = ['MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', 'OTHERFEE', 'TNSTX'] + +# LAND TAXES +GL = ['MEMPROPTAX', 'OTHERPROPTAX'] + +# FACTOR TAXES +GF = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', 'MEMPROPTAX', 'OTHERPROPTAX'] + +# SS PAYMENT +GFUS = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] + +# SS PAYMENT +GFUSC = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] + +# INCOME TAX UNITS +GI = ['TNITAX', 'USPIT'] + +# HOUSEHOLD TAX UNITS +GH = ['MEMPROPTAX', 'OTHERPROPTAX', 'MEMFEE', 'OTHERFEE'] + +# ENDOGENOUS TRANSFER PMT +GT = ['CYGFM', 'CYGFO', 'FED', 'STATE'] + +# HOUSEHOLDS +H = ['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', + 'HH5C', + 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', + 'HH5F', + 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'] + +# I+G SECTORS +IG = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', + 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', + 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', + 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H', + 'FED', 'STATE', 'MEMPHIS', 'OTHER'] + +# INDUSTRY SECTORS +I = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', + 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', + 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', + 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H'] + +# ENDOGENOUS GOVERNMENTS +IG2 = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] + +# PRODUCTION SECTORS +IP = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', + 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', + 'OTHERH'] + +# PRODUCTION GOV. +FG = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', + 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', + 'OTHERH'] + +# HOUSING SERV.DEMAND +HSD = ['HS1A', 'HS2A', 'HS3A', 'HS1B', 'HS2B', 'HS3B', 'HS1C', 'HS2C', 'HS3C', 'HS1D', 'HS2D', 'HS3D', + 'HS1E', 'HS2E', 'HS3E', 'HS1F', 'HS2F', 'HS3F', 'HS1G', 'HS2G', 'HS3G', 'HS1H', 'HS2H', 'HS3H'] + +# SIMMLOOP +SM = ['BASE', 'TODAY', 'SIMM'] + +# REPORT 1 FOR SCALARS +R1H = ['GFREV', 'SFREV', 'PIT', + 'DGF', 'DSF', 'DDRE', 'PDRE', 'SPI', 'COMM', 'COMMO', + 'GN', 'NKI', 'HH', 'W', 'W1', 'W2', 'W3', 'R', 'RL', 'L', 'K', 'HN', 'HW', 'GFSAVM', 'GFSAVO', 'LD', + 'CMO', 'CMI', 'HC', 'SSC', 'LAND', 'LAS'] + +# REPORT 2 FOR STATUS +R2H = ['M-STAT', 'S-STAT'] + +# LABELS FOR MODEL STATUS +MS = ['OPTIMAL', 'LOCALOP', 'UNBOUND', + 'INFSBLE', 'INFSLOC', 'INFSINT', + 'NOOPTML', 'MIPSOLN', 'NOINTGR', + 'INFSMIP', 'UNUSED', 'UNKNOWN', + 'NOSOLUT'] + +# LABELS FOR SOLVER STATUS +SS = ['OK', 'ITERATE', 'RESRCE', + 'SOLVER', 'EVALUATE', 'NOTKNWN', + 'NOTUSED', 'PRE-PROC', 'SETUP', + 'SLVFAIL', 'SLVINTER', 'POST-PROC', + 'METSYS'] + +# SETS FOR MISC TABLES ONLY + +# HOUSING SERVICES +HSSET = ['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', + 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] + +# HOUSING SERVICES 2 & 3 +HS23SET = ['HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] + +# HOUSEHOLDS (INCOME 1) +HH1 = ['HH1A', 'HH1B', 'HH1C', 'HH1D', 'HH1E', 'HH1F', 'HH1G', 'HH1H'] + +# HOUSEHOLDS (INCOME 2) +HH2 = ['HH2A', 'HH2B', 'HH2C', 'HH2D', 'HH2E', 'HH2F', 'HH2G', 'HH2H'] + +# HOUSEHOLDS (INCOME 3) +HH3 = ['HH3A', 'HH3B', 'HH3C', 'HH3D', 'HH3E', 'HH3F', 'HH3G', 'HH3H'] + +# HOUSEHOLDS (INCOME 4) +HH4 = ['HH4A', 'HH4B', 'HH4C', 'HH4D', 'HH4E', 'HH4F', 'HH4G', 'HH4H'] + +# HOUSEHOLDS (INCOME 5) +HH5 = ['HH5A', 'HH5B', 'HH5C', 'HH5D', 'HH5E', 'HH5F', 'HH5G', 'HH5H'] + +# ELASTICITIES +ETA = ['ETAL1', 'ETAI1', 'ETALB1', 'ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU', 'ETAM', 'ETAE', 'ETAY', 'ETAOP'] + +# LANDCAP TABLE ELASTICITIES +ETALANDCAP = ['ETAL1', 'ETAI1', 'ETALB1'] + +# MISCH TABLE ELASTICITIES +ETAMISCH = ['ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU'] + +# MISC TABLE ELASTICITIES +ETAMISC = ['ETAM', 'ETAE', 'ETAY', 'ETAOP'] + +# ---------------------------------------------------------------- +# SET ALIASES +# ---------------------------------------------------------------- + +# ALIAS +J = I +I1 = I +Z1 = Z +F1 = F +G1 = G +G2 = G +GI1 = GI +GS1 = GS +GX1 = GX +GN1 = GN +GH1 = GH +GF1 = GF +H1 = H +HSD1 = HSD +JP = IP +JG = IG +GT1 = GT +GNLM1 = GNLM +GNLO1 = GNLO + +# ---------------------------------------------------------------- +# IMPORT ADDITIONAL DATA FILES +# ---------------------------------------------------------------- + +# SAM +SAM = pd.read_csv(os.path.join(filePath, 'SAM Shelby(1202).csv'), index_col=0) + +# CAPITAL COMP +BB = pd.read_csv(os.path.join(filePath, 'capcomshelby.csv'), index_col=0) + +# MISC TABLES + +TPC = pd.DataFrame(index=H, columns=G).fillna(0.0) +IGTD = pd.DataFrame(index=G, columns=G1).fillna(0.0) +TAUFF = pd.DataFrame(index=G, columns=F).fillna(0.0) +IOUT = pd.DataFrame(index=G1, columns=G1).fillna(0.0) +LANDCAP = pd.DataFrame(index=IG, columns=ETALANDCAP).fillna(0.0) +MISC = pd.DataFrame(index=Z, columns=ETAMISC).fillna(0.0) +MISCH = pd.DataFrame(index=H, columns=ETAMISCH).fillna(0.0) + +miscPath = os.path.join(filePath, 'MiscFile') + +# EMPLOY0 = pd.read_csv(os.path.join(miscPath, 'EMPLOY0(Z,F).csv'), index_col=0) +EMPLOY = pd.read_csv(os.path.join(miscPath, 'EMPLOY(Z,F).csv'), index_col=0) +JOBCR = pd.read_csv(os.path.join(miscPath, 'JOBCR(H,L).csv'), index_col=0) +# JOBCR1 = pd.read_csv(os.path.join(miscPath, 'JOBCR1(H,L).csv'), index_col=0) +HHTABLE = pd.read_csv(os.path.join(miscPath, 'HHTABLE(H,).csv'), index_col=0) +# OUTCR = pd.read_csv(os.path.join(miscPath, 'OUTCR(H,CM).csv'), index_col=0) + +# ---------------------------------------------------------------- +# PARAMETER DECLARATION +# ---------------------------------------------------------------- + +# these are data frames with zeros to be filled during calibration +A = pd.DataFrame(index=Z, columns=Z).fillna(0.0) +AD = pd.DataFrame(index=Z, columns=Z).fillna(0.0) +AG = pd.DataFrame(index=Z, columns=G).fillna(0.0) +AGFS = pd.DataFrame(index=Z, columns=G).fillna(0.0) +SIGMA = pd.Series(index=I, dtype=float).fillna(0.0) +ALPHA = pd.DataFrame(index=F, columns=I).fillna(0.0) +ALPHA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) +B = pd.DataFrame(index=I, columns=IG).fillna(0.0) +B1 = pd.DataFrame(index=I, columns=I).fillna(0.0) +CMOWAGE = pd.Series(index=CM, dtype=float).fillna(0.0) +CMIWAGE = pd.Series(index=L, dtype=float).fillna(0.0) +FCONST = pd.DataFrame(index=F, columns=I).fillna(0.0) +GAMMA = pd.Series(index=I, dtype=float).fillna(0.0) +DELTA = pd.Series(index=I, dtype=float).fillna(0.0) +PIT = pd.DataFrame(index=G, columns=H).fillna(0.0) +PIT0 = pd.DataFrame(index=G, columns=H).fillna(0.0) +PRIVRET1 = pd.Series(index=H, dtype=float).fillna(0.0) +PRIVRET = pd.Series(index=H, dtype=float).fillna(0.0) +# LFOR = pd.Series(index=LA, dtype=float).fillna(0.0) +KFOR = pd.Series(index=K, dtype=float).fillna(0.0) +GFOR = pd.Series(index=G, dtype=float).fillna(0.0) +out = pd.DataFrame(index=G, columns=G).fillna(0.0) +TAUFH = pd.DataFrame(index=G, columns=F).fillna(0.0) +TAUFL = pd.DataFrame(index=G, columns=L).fillna(0.0) +# TAUFLA = pd.DataFrame(index=G, columns=LA).fillna(0.0) +TAUFK = pd.DataFrame(index=G, columns=K).fillna(0.0) +TAUH = pd.DataFrame(index=G, columns=H).fillna(0.0) +TAUH0 = pd.DataFrame(index=G, columns=H).fillna(0.0) +TAUM = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUQ = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUC = pd.DataFrame(index=G, columns=I).fillna(0.0) +TAUCH = pd.DataFrame(index=G, columns=HSD).fillna(0.0) +TAUV = pd.DataFrame(index=G, columns=I).fillna(0.0) +TAUN = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUX = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUG = pd.DataFrame(index=G, columns=I).fillna(0.0) +TAXS = pd.DataFrame(index=G, columns=G).fillna(0.0) +TAXS1 = pd.Series(index=GNLM, dtype=float).fillna(0.0) +TAXS2 = pd.Series(index=GNLO, dtype=float).fillna(0.0) + +# ELASTICITIES AND TAX DATA IMPOSED + +BETA = pd.DataFrame(index=I, columns=H).fillna(0.0) +BETAH = pd.DataFrame(index=HSD, columns=H).fillna(0.0) +ETAD = pd.Series(index=I, dtype=float).fillna(0.0) +ETAE = pd.Series(index=I, dtype=float).fillna(0.0) +ETAI = pd.Series(index=IG, dtype=float).fillna(0.0) +ETAIX = pd.DataFrame(index=K, columns=IG).fillna(0.0) +ETAL1 = pd.Series(index=IG, dtype=float).fillna(0.0) +ETALB1 = pd.Series(index=IG, dtype=float).fillna(0.0) +ETALB = pd.DataFrame(index=L, columns=IG).fillna(0.0) +ETAM = pd.Series(index=I, dtype=float).fillna(0.0) +ETARA = pd.Series(index=H, dtype=float).fillna(0.0) +ETAYDO = pd.Series(index=H, dtype=float).fillna(0.0) +ETAUO = pd.Series(index=H, dtype=float).fillna(0.0) +ETAYDI = pd.Series(index=H, dtype=float).fillna(0.0) +ETAUI = pd.Series(index=H, dtype=float).fillna(0.0) +ETAYD = pd.Series(index=H, dtype=float).fillna(0.0) +ETAU = pd.Series(index=H, dtype=float).fillna(0.0) +ETAPT = pd.Series(index=H, dtype=float).fillna(0.0) +ETAPIT = pd.Series(index=H, dtype=float).fillna(0.0) +EXWGEO = pd.Series(index=CM, dtype=float).fillna(0.0) +EXWGEI = pd.Series(index=L, dtype=float).fillna(0.0) +ECOMI = pd.Series(index=L, dtype=float).fillna(0.0) +ECOMO = pd.Series(index=CM, dtype=float).fillna(0.0) +HOUSECOR = pd.DataFrame(index=H, columns=HSD).fillna(0.0) +JOBCOR = pd.DataFrame(index=H, columns=L).fillna(0.0) + +LAMBDA = pd.DataFrame(index=I, columns=I).fillna(0.0) +LAMBDAH = pd.DataFrame(index=HSD, columns=HSD1).fillna(0.0) + +NRPG = pd.Series(index=H, dtype=float).fillna(0.0) +RHO = pd.Series(index=I, dtype=float).fillna(0.0) +TT = pd.DataFrame(index=Z, columns=IG).fillna(0.0) + +depr = pd.Series(index=IG, dtype=float).fillna(0.1) + +# ARRAYS BUILT TO EXPORT RESULTS TO SEPARATE FILE + +R1 = pd.DataFrame(index=R1H, columns=SM).fillna(0.0) +R2 = pd.DataFrame(index=R2H, columns=SM).fillna(0.0) + +# INITIAL VALUES OF ENDOGENOUS VARIABLES + +CG0 = pd.DataFrame(index=I, columns=G).fillna(0.0) +CG0T = pd.DataFrame(index=I, columns=G).fillna(0.0) +CH0 = pd.DataFrame(index=I, columns=H).fillna(0.0) +CH0T = pd.DataFrame(index=I, columns=H).fillna(0.0) +CMI0 = pd.Series(index=L, dtype=float).fillna(0.0) +CMO0 = pd.Series(index=CM, dtype=float).fillna(0.0) +CN0 = pd.Series(index=I, dtype=float).fillna(0.0) +CN0T = pd.Series(index=I, dtype=float).fillna(0.0) +CPI0 = pd.Series(index=H, dtype=float).fillna(0.0) +CPIN0 = pd.Series(index=H, dtype=float).fillna(0.0) +CPIH0 = pd.Series(index=H, dtype=float).fillna(0.0) +CX0 = pd.Series(index=I, dtype=float).fillna(0.0) +D0 = pd.Series(index=I, dtype=float).fillna(0.0) +DD0 = pd.Series(index=Z, dtype=float).fillna(0.0) +DS0 = pd.Series(index=Z, dtype=float).fillna(0.0) +DQ0 = pd.Series(index=Z, dtype=float).fillna(0.0) + +FD0 = pd.DataFrame(index=F, columns=Z).fillna(0.0) +IGT0 = pd.DataFrame(index=G, columns=GX).fillna(0.0) +KS0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) +KSNEW = pd.DataFrame(index=K, columns=IG).fillna(0.0) +KSNEW0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) +HH0 = pd.Series(index=H, dtype=float).fillna(0.0) +HN0 = pd.Series(index=H, dtype=float).fillna(0.0) +HW0 = pd.Series(index=H, dtype=float).fillna(0.0) +M0 = pd.Series(index=I, dtype=float).fillna(0.0) +M01 = pd.Series(index=Z, dtype=float).fillna(0.0) +MI0 = pd.Series(index=H, dtype=float).fillna(0.0) +MO0 = pd.Series(index=H, dtype=float).fillna(0.0) +N0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) + +# NKIO + +KPFOR01 = pd.Series(index=K, dtype=float).fillna(0.0) +KPFOR0 = pd.Series(index=K, dtype=float).fillna(0.0) +GVFOR0 = pd.Series(index=G, dtype=float).fillna(0.0) +P0 = pd.Series(index=IG, dtype=float).fillna(0.0) +PH0 = pd.Series(index=HSD, dtype=float).fillna(0.0) +PD0 = pd.Series(index=I, dtype=float).fillna(0.0) +PVA0 = pd.Series(index=I, dtype=float).fillna(0.0) +PWM0 = pd.Series(index=I, dtype=float).fillna(0.0) +PW0 = pd.Series(index=I, dtype=float).fillna(0.0) +Q0 = pd.Series(index=Z, dtype=float).fillna(0.0) +Q10 = pd.Series(index=Z, dtype=float).fillna(0.0) +R0 = pd.DataFrame(index=F, columns=Z).fillna(1.0) +RA0 = pd.Series(index=F, dtype=float).fillna(0.0) +S0 = pd.Series(index=Z, dtype=float).fillna(0.0) + +# SPIO + +V0 = pd.Series(index=I, dtype=float).fillna(0.0) +V0T = pd.Series(index=I, dtype=float).fillna(0.0) +V10 = pd.DataFrame(index=I, columns=I).fillna(0.0) +TP = pd.DataFrame(index=H, columns=G).fillna(0.0) + +# TAUF0 = Table(G,F,Z) + +YD0 = pd.Series(index=H, dtype=float).fillna(0.0) +Y0 = pd.Series(index=Z, dtype=float).fillna(0.0) +Y01 = pd.Series(index=H, dtype=float).fillna(0.0) +YT0 = pd.Series(index=G, dtype=float).fillna(0.0) +GCP10 = pd.Series(index=I, dtype=float).fillna(0.0) + +# GCP0 + +DDCX = pd.Series(index=I, dtype=float).fillna(0.0) +''' +TEST1 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST2 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST3 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST4 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST5 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST6 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST7 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST8 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST9 = pd.Series(index=H, dtype=float).fillna(0.0) +TEST10 = pd.Series(index=H, dtype=float).fillna(0.0) +''' + +# SIMPLIFYING TABLES AND DOING AWAY WITH MISC FILES + +for label in G1: + out.loc[label, label] = 0 +out.loc['MEMPHIS', 'CYGFM'] = 1 +out.loc['OTHER', 'CYGFO'] = 1 + +IGTD.loc[G, G1] = 0 +IGTD.loc['FED', GFUS] = 1 +IGTD.loc['FED', 'USPIT'] = 1 + +IGTD.loc['CYGFM', 'MEMPROPTAX'] = 1 +IGTD.loc['CYGFM', 'MEMSALESTAX'] = 1 +IGTD.loc['CYGFM', 'MEMFEE'] = 1 + +IGTD.loc['CYGFO', 'OTHERPROPTAX'] = 1 +IGTD.loc['CYGFO', 'OTHERSALESTAX'] = 1 +IGTD.loc['CYGFO', 'OTHERFEE'] = 1 + +IGTD.loc['STATE', 'TNSTX'] = 1 +IGTD.loc['STATE', 'TNITAX'] = 1 + +TPC.loc[H, G] = 0 +TPC.loc[H, GFUS] = 1 + +TAUFF.loc[G, F] = 0 +TAUFF.loc['USSOCL1A', 'L1A'] = 1 +TAUFF.loc['USSOCL2A', 'L2A'] = 1 +TAUFF.loc['USSOCL3A', 'L3A'] = 1 +TAUFF.loc['USSOCL1B', 'L1B'] = 1 +TAUFF.loc['USSOCL2B', 'L2B'] = 1 +TAUFF.loc['USSOCL3B', 'L3B'] = 1 +TAUFF.loc['USSOCL1C', 'L1C'] = 1 +TAUFF.loc['USSOCL2C', 'L2C'] = 1 +TAUFF.loc['USSOCL3C', 'L3C'] = 1 +TAUFF.loc['USSOCL1D', 'L1D'] = 1 +TAUFF.loc['USSOCL2D', 'L2D'] = 1 +TAUFF.loc['USSOCL3D', 'L3D'] = 1 +TAUFF.loc['USSOCL1E', 'L1E'] = 1 +TAUFF.loc['USSOCL2E', 'L2E'] = 1 +TAUFF.loc['USSOCL3E', 'L3E'] = 1 +TAUFF.loc['USSOCL1F', 'L1F'] = 1 +TAUFF.loc['USSOCL2F', 'L2F'] = 1 +TAUFF.loc['USSOCL3F', 'L3F'] = 1 +TAUFF.loc['USSOCL1G', 'L1G'] = 1 +TAUFF.loc['USSOCL2G', 'L2G'] = 1 +TAUFF.loc['USSOCL3G', 'L3G'] = 1 +TAUFF.loc['USSOCL1H', 'L1H'] = 1 +TAUFF.loc['USSOCL2H', 'L2H'] = 1 +TAUFF.loc['USSOCL3H', 'L3H'] = 1 + +TAUFF.loc['MEMPROPTAX', 'KAP'] = 1 +TAUFF.loc['OTHERPROPTAX', 'KAP'] = 1 + +for label in G1: + IOUT.loc[label, label] = 0 +IOUT.loc['MEMPHIS', 'CYGFM'] = 1 +IOUT.loc['OTHER', 'CYGFO'] = 1 + +LANDCAP.loc[IG, ETALANDCAP] = 1 +MISCH.loc[H, ETAMISCH] = 0 +MISCH.loc[HH1, 'ETAPT'] = -0.5 +MISCH.loc[HH2, 'ETAPIT'] = -0.15 +MISCH.loc[HH3, 'ETAPIT'] = -0.2 +MISCH.loc[HH4, 'ETAPIT'] = -0.25 +MISCH.loc[HH5, 'ETAPIT'] = -0.35 + +MISCH.loc[H, 'NRPG'] = 1 +MISC.loc[IG, ETAMISC] = 0 +MISC.loc[IP, 'ETAM'] = 1 +MISC.loc[I, 'ETAY'] = 1 +MISC.loc[I, 'ETAOP'] = -1 + +# PARAMETERS AND ELASTICITIES + +out.loc[G1, G1] = IOUT.loc[G1, G1] +BETA.loc[I, H] = MISC.loc[I, 'ETAY'] +BETAH.loc[HSD, H] = MISC.loc[HSD, 'ETAY'] + +for label in I: + LAMBDA.loc[label, label] = MISC.loc[label, 'ETAOP'] + +ETAE.loc[I] = MISC.loc[I, 'ETAE'] +ETAM.loc[I] = MISC.loc[I, 'ETAM'] +ETARA.loc[H] = MISCH.loc[H, 'ETARA'] + +ETAPIT.loc[H] = MISCH.loc[H, 'ETAPIT'] +ETAPT.loc[H] = MISCH.loc[H, 'ETAPT'] +ETAYD.loc[H] = MISCH.loc[H, 'ETAYD'] +NRPG.loc[H] = MISCH.loc[H, 'NRPG'] +ETAU.loc[H] = MISCH.loc[H, 'ETAU'] +ETAI.loc[IG] = LANDCAP.loc[IG, 'ETAI1'] +ETAIX.loc['KAP', IG] = ETAI.loc[IG] + +# play with elasticities + +# EXPERIMENTAL ELASTICITIES +ECOMI.loc[L] = 1 +ECOMO.loc[CM] = 1 +EXWGEO.loc[CM] = 1 +EXWGEI.loc[L] = 1 +ETAE.loc[IP] = -0.4 +ETAIX.loc['KAP', IG] = 0.1 +ETARA.loc[H] = 1.5 +ETAYDO.loc[H] = 1.0 +ETAYDI.loc[H] = 1.5 +ETAUI.loc[H] = -0.72 +ETAUO.loc[HH1] = -0.8 +ETAUO.loc[HH2] = -0.6 +ETAUO.loc[HH3] = -0.4 +ETAUO.loc[HH4] = -0.2 +ETAUO.loc[HH5] = -0.2 +ETAU.loc[H] = -0.1 +ETAYD.loc[H] = 1 + +# CALIBRATION + +# Column Totals of SAM table +Q10.loc[Z] = SAM.loc[Z, Z].sum(1) + +# Row Totals of SAM table +Q0.loc[Z] = SAM.loc[Z, Z].sum(0) + +# difference of SAM row and coloumn totals +DQ0.loc[Z] = Q10.loc[Z] - Q0.loc[Z] + +# Column Totals of SAM table +Q10.loc[Z] = SAM.loc[Z].sum(0) + +B1.loc[I, I] = SAM.loc[I, I] + +# Calculate tax rates from SAM information +TAUQ_1 = SAM.loc[GS, I] +TAUQ_2 = SAM.loc[I, I].sum(1) +TAUQ_3 = SAM.loc[I, H].sum(1) +TAUQ_4 = SAM.loc[I, ['INVES']].sum(1) +TAUQ_5 = SAM.loc[I, G].sum(1) +TAUQ_6 = SAM.loc[I, ['ROW']].sum(1) +TAUQ_7 = SAM.loc[GS1, I].sum(0) + +TAUQ.loc[GS, I] = TAUQ_1 / (TAUQ_2 + TAUQ_3 + TAUQ_4 + TAUQ_5 + TAUQ_6 - TAUQ_7) + +# NOTE: +# set taxes to average if not specific to model +TAUC.loc[GS, I] = TAUQ.loc[GS, I] +TAUV.loc[GS, I] = TAUQ.loc[GS, I] +TAUN.loc[GS, I] = TAUQ.loc[GS, I] +TAUG.loc[GS, I] = TAUQ.loc[GS, I] +TAUX.loc[GS, I] = TAUQ.loc[GS, I] + +# FACTOR TAX RATES +TAUFarray = [[[0 for k in range(len(Z))] for j in range(len(F))] for i in range(len(G))] +for i in range(len(GF)): + for j in range(len(F)): + for k in range(len(I)): + if SAM.loc[F[j], I[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: + TAUFarray[G.index(GF[i])][j][Z.index(I[k])] = SAM.loc[GF[i], I[k]] / SAM.loc[F[j], I[k]] + +for i in range(len(GF)): + for j in range(len(F)): + for k in range(len(G)): + if SAM.loc[F[j], G[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: + TAUFarray[G.index(GF[i])][j][Z.index(G[k])] = SAM.loc[GF[i], G[k]] / SAM.loc[F[j], G[k]] + +TAUFX_SUM_array = [[0 for j in range(len(Z))] for i in range(len(F))] +for i in range(len(F)): + for j in range(len(Z)): + tmp = 0 + for k in range(len(G)): + tmp += TAUFarray[k][i][j] + TAUFX_SUM_array[i][j] = tmp + +# TAUFX summed over GX +TAUFX_SUM = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) + +TAUFX_GF = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) + +TAUFXgx = {} +for i in range(len(GX)): + TAUFXgx[GX[i]] = pd.DataFrame(TAUFarray[i], index=F, columns=Z).fillna(0.0) + +# SS TAX RATES +for i in GF: + for j in F: + if TAUFF.loc[i, j] != 0: + TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[Z, F].sum(0).at[j] + +for i in GFUS: + for j in L: + if TAUFF.loc[i, j] != 0: + TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[L, IG].sum(1).at[j] + +# EMPLOYEE PORTION OF FACTOR TAXES +TAUFL.loc[GF, L] = SAM.loc[GF, L] / (SAM.loc[Z, L].sum(0) - SAM.loc[L, ['ROW']].sum(1)) + +TAUFK.loc[GF, K] = SAM.loc[GF, K] / SAM.loc[Z, K].sum(0) + +# SHARES OF ENDOGENOUS GOVERNMENTS TRANFERS TO REVENUE +TAXS.loc[G, GX] = SAM.loc[G, GX] / SAM.loc[G, GX].sum(0) + +TAXS1.loc[GNLM] = SAM.loc[GNLM, ['CYGFM']].sum(1) / SAM.loc[GNLM, ['CYGFM']].sum(1).sum(0) + +TAXS2.loc[GNLO] = SAM.loc[GNLO, ['CYGFO']].sum(1) / SAM.loc[GNLO, ['CYGFO']].sum(1).sum(0) + +# SET INITIAL INTER GOVERNMENTAL TRANSFERS +IGT0.loc[G, GX] = SAM.loc[G, GX] + +# SET INITIAL PRICES TO UNITY LESS SALES AND EXCISE TAXES +PW0.loc[I] = 1.0 +PWM0.loc[I] = 1.0 +P0.loc[I] = 1.0 +PD0.loc[I] = 1.0 +CPI0.loc[H] = 1.0 +CPIN0.loc[H] = 1.0 +CPIH0.loc[H] = 1.0 +TT.loc[F, IG] = 1.0 + +# HOUSEHOLD TRANSFER PAYMENTS AND PERSONAL INCOME TAXES +# TOTAL HH IN Shelby +HH0.loc[H] = HHTABLE.loc[H, 'HH0'] + +# TOTAL WORKING HH IN SHELBY (WORK IN SHELBY & OUTSIDE SHELBY) +HW0.loc[H] = HHTABLE.loc[H, 'HW0'] + +# NON WORKING HH IN SHELBY +HN0.loc[H] = HH0.loc[H] - HW0.loc[H] + +# NOMINAL GOVERNMENT SS PAYMENTS +TP.loc[H, G] = SAM.loc[H, G].div(HH0.loc[H], axis='index').fillna(0.0) + +# FACTOR RENTALS +JOBCOR.loc[H, L] = JOBCR.loc[H, L] + +# RENTAL RATE FOR FACTORS +R0.loc[F, Z] = 1.0 + +R0.loc[F, IG] = (SAM.loc[F, IG] / EMPLOY.loc[IG, F].T).fillna(1.0) + +# REAL FACTOR DEMAND +FD0.loc[F, IG] = EMPLOY.loc[IG, F].T + +KS0.loc[K, IG] = FD0.loc[K, IG] + +# SHARES FOUND IN THE SOCIAL ACCOUNTING MATRIX DATA +# A = INPUT OUTPUT COEFICIENTS +A.loc[Z, Z] = SAM.loc[Z, Z].div(Q0.loc[Z], axis='columns') + + +# AGFS: LABOR PAYMENTS BY G SECTOR + USSOC PAYMENTS BY LABOR (GROSS LABOR PAYMENTS) +AGFS.loc['L1A', G] = SAM.loc['L1A', G] + SAM.loc['USSOCL1A', G] +AGFS.loc['L2A', G] = SAM.loc['L2A', G] + SAM.loc['USSOCL2A', G] +AGFS.loc['L3A', G] = SAM.loc['L3A', G] + SAM.loc['USSOCL3A', G] + +AGFS.loc['L1B', G] = SAM.loc['L1B', G] + SAM.loc['USSOCL1B', G] +AGFS.loc['L2B', G] = SAM.loc['L2B', G] + SAM.loc['USSOCL2B', G] +AGFS.loc['L3B', G] = SAM.loc['L3B', G] + SAM.loc['USSOCL3B', G] + +AGFS.loc['L1C', G] = SAM.loc['L1C', G] + SAM.loc['USSOCL1C', G] +AGFS.loc['L2C', G] = SAM.loc['L2C', G] + SAM.loc['USSOCL2C', G] +AGFS.loc['L3C', G] = SAM.loc['L3C', G] + SAM.loc['USSOCL3C', G] + +AGFS.loc['L1D', G] = SAM.loc['L1D', G] + SAM.loc['USSOCL1D', G] +AGFS.loc['L2D', G] = SAM.loc['L2D', G] + SAM.loc['USSOCL2D', G] +AGFS.loc['L3D', G] = SAM.loc['L3D', G] + SAM.loc['USSOCL3D', G] + +AGFS.loc['L1E', G] = SAM.loc['L1E', G] + SAM.loc['USSOCL1E', G] +AGFS.loc['L2E', G] = SAM.loc['L2E', G] + SAM.loc['USSOCL2E', G] +AGFS.loc['L3E', G] = SAM.loc['L3E', G] + SAM.loc['USSOCL3E', G] + +AGFS.loc['L1F', G] = SAM.loc['L1F', G] + SAM.loc['USSOCL1F', G] +AGFS.loc['L2F', G] = SAM.loc['L2F', G] + SAM.loc['USSOCL2F', G] +AGFS.loc['L3F', G] = SAM.loc['L3F', G] + SAM.loc['USSOCL3F', G] + +AGFS.loc['L1G', G] = SAM.loc['L1G', G] + SAM.loc['USSOCL1G', G] +AGFS.loc['L2G', G] = SAM.loc['L2G', G] + SAM.loc['USSOCL2G', G] +AGFS.loc['L3G', G] = SAM.loc['L3G', G] + SAM.loc['USSOCL3G', G] + +AGFS.loc['L1H', G] = SAM.loc['L1H', G] + SAM.loc['USSOCL1H', G] +AGFS.loc['L2H', G] = SAM.loc['L2H', G] + SAM.loc['USSOCL2H', G] +AGFS.loc['L3H', G] = SAM.loc['L3H', G] + SAM.loc['USSOCL3H', G] + +# AG - GOVERNMENT SPENDING SHARES OF NET INCOME +AG_1 = SAM.loc[I, G] +AG_2 = SAM.loc[I, G].sum(0) + SAM.loc[F, G].sum(0) + SAM.loc[GF, G].sum(0) +AG.loc[I, G] = AG_1 / AG_2 + +AG_1 = SAM.loc[F, G] +AG.loc[F, G] = AG_1 / AG_2 + +AG_1 = AGFS.loc[L, G] +AG.loc[L, G] = AG_1 / AG_2 +AG = AG.fillna(0.0) + +# TRADE INTERMEDIATES CONSUMPTION INVESTMENT INITIAL LEVELS + +# REAL EXPORT CONSUMPTION +CX0.loc[I] = SAM.loc[I, ["ROW"]].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index').sum(1) + +# REAL IMPORTS +M01.loc[I] = SAM.loc[["ROW"], I].sum(0) / PWM0[I].T + +M0.loc[IP] = SAM.loc[IP, Z].sum(1) - (B1.loc[I, IP].sum(0) + SAM.loc[F, IP].sum(0) + SAM.loc[G, IP].sum(0)) + +M0.loc[I] = (M0[I] / PWM0[I]) +M0 = M0.fillna(0.0) + +# * REAL INTERMEDIATE DEMAND +V0.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] / (1.0 + TAUQ.loc[GS, I].sum(0)) +V0T.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] + +# REAL PRIVATE CONSUMPTION +CH0.loc[I, H] = SAM.loc[I, H].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') + +CH0T.loc[I, H] = SAM.loc[I, H].div(P0[I], axis='index') + +CG0.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index').div((1.0 + TAUQ.loc[GS, I].sum(0)), axis='index') + +CG0T.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index') + +DEPR = float((SAM.loc[IG, ["INVES"]].sum(0)) / (KS0.loc[K, IG].sum(1).sum(0))) + +N0.loc[K, IG] = KS0.loc[K, IG] * DEPR + +# INVESTMENT BY SECTOR OF SOURCE +CN0.loc[I] = 0.0 + +B.loc[I, IG] = BB.loc[I, IG].fillna(0.0) + +CN0.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index').div( + 1.0 + TAUN.loc[GS, I].sum(0), axis='index').transpose() + +CN0T.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index') + +DD0.loc[I] = CH0.loc[I, H].sum(1) + CG0.loc[I, G].sum(1) + CN0.loc[I] + V0.loc[I] + +D0.loc[I] = 1.0 - M0.loc[I] / DD0.loc[I] + +# CORRECT IMPORT ELASTICITY TO DOMESTIC SHARE ELASTICITY +ETAD.loc[I] = -1.0 * ETAM.loc[I] * M0.loc[I] / (DD0.loc[I] * D0.loc[I]) + +# PRODUCTION DATA +DS0.loc[I] = DD0.loc[I] + CX0.loc[I] - M0.loc[I] + +AD.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') / DS0.loc[I] + +V10.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') + +PVA0.loc[I] = PD0.loc[I] - ( + AD.loc[I, I].mul(P0.loc[I], axis='index').mul(1.0 + TAUQ.loc[GS, I].sum(0).T, axis='index').sum(0).T) + +# AVERAGE RENTAL RATES FOR FACTORS (NORMALIZED) +RA0.loc[F] = 1.0 + +# CALIBRATION OF PRODUCTION EXPONENTS FOR COBB DOUGLAS +a = SAM.loc['MEMPROPTAX', I] + SAM.loc['OTHERPROPTAX', I] +a = SAM.loc[GFUS, I].append(a, ignore_index=True) # labor, capital +a.index = F + +ALPHA.loc[F, I] = (SAM.loc[F, I] + a.loc[F, I]) / (SAM.loc[F, I].sum(0) + SAM.loc[GF, I].sum(0)) +ALPHA.loc[F, I] = ALPHA.loc[F, I] / ALPHA.loc[F, I].sum(0) + +ACK = pd.Series(index=I, dtype=float).fillna(0.0) +ACK.loc[I] = SAM.loc[F, I].sum(0) + +# replace takes care of multiplying by zeros, by changing zeros to ones. +DELTA.loc[I] = DS0.loc[I] / (FD0.loc[F, I] ** ALPHA.loc[F, I]).replace({0: 1}).product(0) + +SIGMA.loc[I] = 0.67 +RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] + +ATEST1 = pd.Series(index=I, dtype=float).fillna(0.0) +ATEST1.loc[I] = ALPHA.loc[F, I].sum(0) + +GAMMA.loc[I] = DS0.loc[I] / (((ALPHA.loc[F, I] * FD0.loc[F, I] ** (RHO.loc[I])).sum(0)) ** (1 / RHO.loc[I])) + +# OTHER DATA +# HH INVESTMENT INCOME FROM ROW +PRIVRET.loc[H] = SAM.loc[Z, H].sum(0) - (SAM.loc[H, F].sum(1) + SAM.loc[H, CM].sum(1) + SAM.loc[H, GX].sum(1)) + +PRIVRET.loc[H] = PRIVRET.loc[H] / HH0.loc[H] + +# TOTAL OUTPUT +Y0.loc[F] = SAM.loc[F, IG].sum(1) + +KPFOR01.loc[K] = SAM.loc[K, ["ROW"]].sum(1) + +# NOMINAL CAPITAL OUTFLOW +KPFOR0[K] = SAM.loc[Z, K].sum(0).T - SAM.loc[K, IG].sum(1) + +# NOMINAL GOVERNMENT OUTFLOWS +GVFOR0.loc[G] = SAM.loc[G, ["ROW"]].sum(1) +''' +GVFOR0.loc[GT] = SAM.loc[Z, GT].sum(0) - ( + SAM.loc[GT, I].sum(1) + + SAM.loc[GT, F].sum(1) + + SAM.loc[GT, H].sum(1) + + SAM.loc[GT, G].sum(1) + ) +''' + +# ORIGINAL EQUATION +A.loc[H, L] = SAM.loc[H, L].div(HW0.loc[H], axis='index') / ( + Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) + SAM.loc[L, ["ROW"]].sum(1)) + +A.loc[H, K] = SAM.loc[H, K].div(HW0.loc[H], axis='index') / ( + Y0.loc[K] + SAM.loc[Z, K].sum(0) - SAM.loc[K, IG].sum(1)) + +# HH TAXES OTHER THAN PIT +TAUH.loc[GH, H] = SAM.loc[GH, H].div(HH0.loc[H], axis='columns') + +S0.loc[H] = SAM.loc[["INVES"], H].T.sum(1) + +YD0.loc[H] = SAM.loc[I, H].sum(0).T + S0.loc[H] + +Y0.loc[G] = SAM.loc[G, Z].sum(1) - SAM.loc[G, ["ROW"]].sum(1) + +S0.loc[G] = SAM.loc[["INVES"], G].sum(0) + +# COMMUTING IN +CMI0.loc[L] = FD0.loc[L, IG].sum(1) - JOBCOR.loc[H, L].mul(HW0.loc[H], axis='index').sum(0) + +# COMMUTING OUT +CMO0.loc[["OUTCOM1"]] = 46206.0 +CMO0.loc[["OUTCOM2"]] = 24294.0 +CMO0.loc[["OUTCOM3"]] = 13514.0 + +# AVERAGE WAGE FLOWING INTO SHELBY +CMOWAGE.loc[CM] = SAM.loc[CM, ["ROW"]].sum(1).div(CMO0.loc[CM], axis='index').fillna(0.0) + +# AVERAGE WAGES FLOWING OUT OF SHELBY +CMIWAGE.loc[L] = (-1) * (SAM.loc[L, ["ROW"]].sum(1).div(CMI0.loc[L], axis='index').fillna(0.0)) + +# PROPORTION OF CAPITAL INCOME OUTFLOW +KFOR.loc[K] = KPFOR0.loc[K] / SAM.loc[["KAP"], IG].sum(1) + +# PROPORTION OF GOVERNMENT INCOME OUTFLOW +GFOR.loc[G] = GVFOR0.loc[G] / Y0.loc[G] + +A.loc[H, CM] = SAM.loc[H, CM].div(SAM.loc[Z, CM].sum(0), axis='columns') + +# NOMINAL NET CAPITAL INFLOW +NKI0 = (M0.loc[I] * PWM0.loc[I]).sum(0) - (CX0.loc[I] * PD0.loc[I]).sum(0) - \ + (PRIVRET.loc[H] * HH0.loc[H]).sum(0) - \ + KPFOR0.loc[K].sum(0) - GVFOR0.loc[G].sum(0) - \ + (CMOWAGE.loc[CM] * CMO0.loc[CM]).sum(0) - \ + (CMIWAGE.loc[L] * CMI0.loc[L]).sum(0) + +# REAL HH NET INCOME +Y0.loc[H] = (A.loc[H, L].mul(HW0[H], axis='index').div(A.loc[H, L].mul(HW0[H], axis='index').sum(0), axis='columns') \ + .mul(Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) - (CMIWAGE.loc[L] * CMI0.loc[L]), axis='columns')).sum(1) \ + + (A.loc[H, CM].mul((CMOWAGE.loc[CM] * CMO0.loc[CM]), axis='columns')).sum(1) \ + + (A.loc[H, K].mul(HW0[H], axis='index') / A.loc[H, K].mul(HW0[H], axis='index').sum(0) \ + * (Y0[K] * (1.0 - TAUFK.loc[G, K].sum(0)) + KPFOR0.loc[K])).sum(1) + +# PERSONAL INCOME OBJECTIVE FUNCTION +SPI0 = (Y0.loc[H].sum(0) + + TP.loc[H, G].mul(HH0.loc[H], axis='index').sum(1).sum(0) + + (PRIVRET[H] * HH0[H]).sum(0)) + +# PERSONAL INCOME TAX +PIT.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') + +PIT0.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') + +MI0.loc[H] = HH0.loc[H] * 0.04 + +MO0.loc[H] = HH0.loc[H] * 0.04 + +GCP0 = CH0.loc[I, H].sum(1).sum(0) + CN0.loc[I].sum(0) + CG0.loc[I, GN].sum(1).sum(0) + CX0.loc[I].sum(0) - M0.loc[ + I].sum(0) + +GCP10.loc[I] = CH0.loc[I, H].sum(1) + CN0.loc[I] + CG0.loc[I, GN].sum(1) + CX0.loc[I] + M0.loc[I] + +########################################### +# VARIABLE DECLARATION +########################################### + +vars = VarContainer() + +# PUBLIC CONSUMPTION +CG = vars.add('CG', rows=I, cols=G) + +# PRIVATE CONSUMPTION +CH = vars.add('CH', rows=I, cols=H) + +# COMMUTING IN +CMI = vars.add('CMI', rows=L) + +# COMMUTING OUT JASPER +CMO = vars.add('CMO', rows=CM) + +# GROSS INVESTMENT BY SECTOR OF SOURCE +CN = vars.add('CN', rows=I) + +# CONSUMER PRICE INDEX +CPI = vars.add('CPI', rows=H) + +# NONHOUSING CONSUMER PRICE INDEX +CPIN = vars.add('CPIN', rows=H) + +# HOUSING CONSUMER PRICE INDEX +CPIH = vars.add('CPIH', rows=H) + +# EXPORT DEMAND +CX = vars.add('CX', rows=I) + +# DOMESTIC SHARE OF DOMESTIC DEMAND +D = vars.add('D', rows=I) + +# DOMESTIC DEMAND +DD = vars.add('DD', rows=I) + +# DOMESTIC SUPPLY +DS = vars.add('DS', rows=I) + +# SECTORAL FACTOR DEMAND +# FD = vars.add('FD', rows=F, cols=Z) +FD = vars.add('FD', rows=F, cols=Z) + +# GROSS AGGREGATE CITY PRODUCT +GCP = vars.add('GCP') + +# GROSS CITY PRODUCT BY SECTOR +GCP1 = vars.add('GCP1', rows=I) + +# NUMBER OF HOUSEHOLDS +HH = vars.add('HH', rows=H) + +# NUMBER OF NONWORKING HOUSEHOLDS +HN = vars.add('HN', rows=H) + +# NUMBER OF WORKING HOUSEHOLDS +HW = vars.add('HW', rows=H) + +# INTER GOVERNMENTAL TRANSFERS +IGT = vars.add('IGT', rows=G, cols=GX) + +# CAPITAL FLOW +KS = vars.add('KS', rows=K, cols=IG) + +# IMPORTS +M = vars.add('M', rows=I) + +# GROSS INVESTMENT BY SECTOR OF DESTINATION +N = vars.add('N', rows=K, cols=IG) + +# NET CAPITAL INFLOW +NKI = vars.add('NKI') + +# CAPITAL OUTFLOW +KPFOR = vars.add('KPFOR', rows=K) + +# GOVT OUTFLOW +GVFOR = vars.add('GVFOR', rows=G) + +# AGGREGATE DOMESTIC PRICE PAID BY PURCHASERS +P = vars.add('P', rows=I) + +# DOMESTIC PRICE RECEIVED BY SUPPLIERS +PD = vars.add('PD', rows=I) + +# VALUE ADDED PRICE +PVA = vars.add('PVA', rows=I) + +# ECONOMY WIDE SCALAR RENTAL RATES OF FACTORS +RA = vars.add('RA', rows=F) + +# SECTORAL RENTAL RATES +R = vars.add('R', rows=F, cols=Z) + +# SAVINGS +S = vars.add('S', rows=Z) + +# PERSONAL INCOME (OBJECTIVE FUNCTION) +SPI = vars.add('SPI') + +# INTERMEDIATE GOODS +V = vars.add('V', rows=I) + +# additional variable +V1 = vars.add('V1', rows=I, cols=I) + +# GROSS INCOMES +Y = vars.add('Y', rows=Z) + +# AFTER TAX TOTAL HOUSEHOLD INCOMES +YD = vars.add('YD', rows=H) + +# INITIALIZE VARIABLES FOR SOLVER + +vars.init('CG', CG0.loc[I, G]) +vars.init('CH', CH0.loc[I, H]) +vars.init('CMI', CMI0.loc[L]) +vars.init('CMO', CMO0.loc[CM]) +vars.init('CN', CN0.loc[I]) +vars.init('CPI', CPI0.loc[H]) +vars.init('CPIN', CPIN0.loc[H]) +vars.init('CPIH', CPIH0.loc[H]) +vars.init('CX', CX0.loc[I]) +vars.init('D', D0.loc[I]) +vars.init('DD', DD0.loc[I]) +vars.init('DS', DS0.loc[I]) +vars.init('FD', FD0.loc[F, Z]) +vars.init('GCP', GCP0) +vars.init('GCP1', GCP10.loc[I]) +vars.init('HH', HH0.loc[H]) +vars.init('HN', HN0.loc[H]) +vars.init('HW', HW0.loc[H]) +vars.init('IGT', IGT0.loc[G, GX]) +vars.init('KS', KS0.loc[K, IG]) +# vars.init('LAS', LAS0.loc[LA, IG]) +vars.init('M', M0.loc[I]) +vars.init('N', N0.loc[K, IG]) +vars.init('NKI', NKI0) +# vars.init('LNFOR', LNFOR0.loc[LA]) +vars.init('KPFOR', KPFOR0.loc[K]) +vars.init('GVFOR', GVFOR0.loc[G]) +vars.init('P', P0.loc[I]) +vars.init('PD', PD0.loc[I]) +vars.init('PVA', PVA0.loc[I]) +vars.init('RA', RA0.loc[F]) +vars.init('R', R0.loc[F, Z]) +vars.init('S', S0.loc[Z]) +vars.init('SPI', SPI0) +vars.init('V', V0.loc[I]) +vars.init('V1', V10.loc[I, I]) +vars.init('Y', Y0.loc[Z]) +vars.init('YD', YD0.loc[H]) + +# DEFINE BOUNDS FOR VARIABLES + +vars.lo('P', vars.get('P') / 1000) +vars.up('P', vars.get('P') * 1000) +vars.lo('PD', vars.get('PD') / 1000) +vars.up('PD', vars.get('PD') * 1000) +vars.lo('PVA', vars.get('PVA') / 1000) +vars.up('PVA', vars.get('PVA') * 1000) +vars.lo('RA', vars.get('RA') / 1000) +vars.up('RA', vars.get('RA') * 1000) +vars.lo('CPI', vars.get('CPI') / 1000) +vars.up('CPI', vars.get('CPI') * 1000) +vars.lo('CMI', vars.get('CMI') / 1000) +vars.up('CMI', vars.get('CMI') * 1000) +vars.lo('CMO', vars.get('CMO') / 1000) +vars.up('CMO', vars.get('CMO') * 1000) +vars.lo('DS', vars.get('DS') / 1000) +vars.up('DS', vars.get('DS') * 1000) +vars.lo('DD', vars.get('DD') / 1000) +vars.up('DD', vars.get('DD') * 1000) +vars.lo('D', vars.get('D') / 1000) +vars.up('D', vars.get('D') * 1000) +vars.lo('V', vars.get('V') / 1000) +vars.up('V', vars.get('V') * 1000) +vars.lo('FD', vars.get('FD') / 1000) +vars.up('FD', vars.get('FD') * 1000) +vars.lo('HH', vars.get('HH') / 1000) +vars.up('HH', vars.get('HH') * 1000) +vars.lo('HW', vars.get('HW') / 1000) +vars.up('HW', vars.get('HW') * 1000) +vars.lo('HN', vars.get('HN') / 1000) +vars.up('HN', vars.get('HN') * 1000) +vars.lo('KS', vars.get('KS') / 1000) +vars.up('KS', vars.get('KS') * 1000) +vars.lo('M', vars.get('M') / 1000) +vars.up('M', vars.get('M') * 1000) +vars.lo('Y', vars.get('Y') / 1000) +vars.up('Y', vars.get('Y') * 1000) +vars.lo('YD', vars.get('YD') / 1000) +vars.up('YD', vars.get('YD') * 1000) +vars.lo('CH', vars.get('CH') / 1000) +vars.up('CH', vars.get('CH') * 1000) +vars.lo('CG', vars.get('CG') / 1000) +vars.up('CG', vars.get('CG') * 1000) +vars.lo('CX', vars.get('CX') / 1000) +vars.up('CX', vars.get('CX') * 1000) +vars.lo('R', vars.get('R') / 1000) +vars.up('R', vars.get('R') * 1000) +vars.lo('N', 0) +vars.lo('CN', 0) + + +def set_variable(filname): + # clear the file before write the variables + with open(filename, 'w') as f: + f.write("") + + vars.write(filename) + + +# DEFINE EQUATIONS AND SET CONDITIONS + +def set_equation(filename): + count = [0] + + print('CPIEQ(H)') + line1 = (P.loc(I) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0)) * CH.loc(I, H)).sum(I) + line2 = (ExprM(vars, m=P0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0))) * CH.loc(I, H)).sum(I) + + CPIEQ = (line1 / line2 - ~CPI.loc(H)) + print(CPIEQ.test(vars.initialVals)) + CPIEQ.write(count, filename) + + print('YEQ(H)') + line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * ( + Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * ExprM(vars, + m=CMIWAGE.loc[L]) * CMI.loc( + L))).sum(L) + line2 = (ExprM(vars, m=A.loc[H, CM]) * (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM))).sum(CM) + # line3 = (ExprM(vars, m= A.loc[H,LA]) * HW.loc(H) / (ExprM(vars, m= A.loc[H1,LA]) * HW.loc(H1)).sum(H1) * (Y.loc(LA) + LNFOR.loc(LA) ) * ExprM(vars, m= 1 - TAUFLA.loc[G,LA].sum(0))).sum(LA) + line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * ( + Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) + + YEQ = ((line1 + line2 + line4) - Y.loc(H)) + print(YEQ.test(vars.initialVals)) + YEQ.write(count, filename) + + print('YDEQ(H)') + line1 = Y.loc(H) + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)) + line2 = (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum(G) + line3 = ~(ExprM(vars, m=PIT0.loc[GI, H]) * Y.loc(H)).sum(GI) + line4 = ~(ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum(G) + + YDEQ = ((line1 + line2 - line3 - line4) - YD.loc(H)) + YDEQ.write(count, filename) + print(YDEQ.test(vars.initialVals)) + + print('CHEQ(I,H)') + line1 = ExprM(vars, m=CH0.loc[I, H]) * ( + (YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m= + BETA.loc[I, H]) + line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / ( + ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** ExprM(vars, m=LAMBDA.loc[ + J, I])).prod(0) + + CHEQ = ((line1 * line2) - CH.loc(I, H)) + CHEQ.write(count, filename) + print(CHEQ.test(vars.initialVals)) + # print(CHEQ) + + print('SHEQ(H)') + line = YD.loc(H) - ~((P.loc(I) * CH.loc(I, H) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0))).sum(I)) + + SHEQ = (line - S.loc(H)) + SHEQ.write(count, filename) + print(SHEQ.test(vars.initialVals)) + # print(SHEQ) + + print('PVAEQ(I)') + line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) + + PVAEQ = (line - PVA.loc(I)) + PVAEQ.write(count, filename) + print(PVAEQ.test(vars.initialVals)) + # print(PVAEQ) + + print('PFEQ(I)') + line = ExprM(vars, m=DELTA.loc[I]) * ( + (ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) ** ExprM(vars, m=ALPHA.loc[F, I])).prod(F) + + PFEQ = (line - DS.loc(I)) + PFEQ.write(count, filename) + print(PFEQ.test(vars.initialVals)) + # print(PFEQ) + + print('FDEQ(F,I)') + left = R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I]) * ( + ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) + right = ~(PVA.loc(I) * DS.loc(I) * ExprM(vars, m=ALPHA.loc[F, I])) + + FDEQ = (right - left) + + # FDEQ.test(vars.initialVals) + FDEQ.write(count, filename) + print(FDEQ.test(vars.initialVals)) + # print(FDEQ) + + print('VEQ(I)') + line = (ExprM(vars, m=AD.loc[I, J]) * ~DS.loc(J)).sum(1) + + VEQ = (line - V.loc(I)) + VEQ.write(count, filename) + print(VEQ.test(vars.initialVals)) + # print(VEQ) + + print('YFEQL(L)') + line = (R.loc(F, IG) * RA.loc(F) * FD.loc(F, IG)).sum(IG) + + YFEQL = (line - Y.loc(F)) + YFEQL.write(count, filename) + print(YFEQL.test(vars.initialVals)) + # print(YFEQL) + + print('KAPFOR(K)') + line = ExprM(vars, m=KFOR.loc[K]) * Y.loc(K) + + KAPFOR = (line - KPFOR.loc(K)) + KAPFOR.write(count, filename) + print(KAPFOR.test(vars.initialVals)) + # print(KAPFOR) + + # XEQ(I).. CX(I) =E= CX0(I)*( (PD(I)*(1+SUM(GS,TAUX(GS,I)))) + print('XEQ(I)') + line = ExprM(vars, m=CX0.loc[I]) * ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / ExprM(vars, + m=PW0.loc[I] * ( + 1 + + TAUQ.loc[ + GS, I].sum( + 0)))) ** ExprM( + vars, m=ETAE.loc[I]) + + XEQ = (line - CX.loc(I)) + XEQ.write(count, filename) + print(XEQ.test(vars.initialVals)) + # print(XEQ) + + print('DEQ(I)$PWM0(I)') + line = ExprM(vars, m=D0.loc[I]) * (PD.loc(I) / ExprM(vars, m=PWM0.loc[I])) ** ExprM(vars, m=ETAD.loc[I]) + + DEQ = (line - D.loc(I)) + # DEQ.setCondition(PWM0.loc[I]) + DEQ.write(count, filename) + print(DEQ.test(vars.initialVals)) + # print(DEQ) + + print('MEQ(I)') + line = (1 - D.loc(I)) * DD.loc(I) + + MEQ = (line - M.loc(I)) + MEQ.write(count, filename) + print(MEQ.test(vars.initialVals)) + # print(MEQ) + + print('PEQ(I)') + line = (D.loc(I) * PD.loc(I) + (1 - D.loc(I)) * ExprM(vars, m=PWM0.loc[I])) + + PEQ = (line - P.loc(I)) + PEQ.write(count, filename) + print(PEQ.test(vars.initialVals)) + + print('NKIEQ') + line1 = (M.loc(I) * ExprM(vars, m=PWM0.loc[I])).sum(I) + line2 = (CX.loc(I) * PD.loc(I)).sum(I) + line3 = (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + line5 = KPFOR.loc(K).sum(K) + line6 = GVFOR.loc(G).sum(G) + line7 = (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM)).sum(CM) + line8 = (ExprM(vars, m=CMIWAGE.loc[L]) * CMI.loc(L)).sum(L) + + NKIEQ = ((line1 - line2 - line3 - line5 - line6 - line7 - line8) - NKI) + NKIEQ.write(count, filename) + print(NKIEQ.test(vars.initialVals)) + # print(NKIEQ) + + print('NEQ(K,I)') + line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** ExprM(vars, m=ETAIX.loc[K, I]) + + NEQ = (line - N.loc(K, I)) + NEQ.write(count, filename) + print(NEQ.test(vars.initialVals)) + # print(NEQ) + + print('CNEQ(I)') + left = P.loc(I) * ExprM(vars, m=1 + TAUN.loc[GS, I].sum(0)) * CN.loc(I) + right = (ExprM(vars, m=B.loc[I, IG]) * N.loc(K, IG).sum(K)).sum(IG) + + CNEQ = (right - left) + CNEQ.write(count, filename) + print(CNEQ.test(vars.initialVals)) + # print(CNEQ) + + print('KSEQ(K,IG)') + line = ExprM(vars, m=KS0.loc[K, IG] * (1 - DEPR)) + N.loc(K, IG) + + KSEQ = (line - KS.loc(K, IG)) + KSEQ.write(count, filename) + print(KSEQ.test(vars.initialVals)) + + print('LSEQ1(H)') + line1 = ExprM(vars, m=HW0.loc[H] / HH0.loc[H]) + LSEQ1line2pre = FD.loc(L, Z).sum(1) + line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) \ + * (LSEQ1line2pre.sum(0) / ( + (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum(CM) + CMI.loc( + L).sum(L))) \ + + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) \ + * (CMO.loc(CM).sum(CM) / ( + (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum( + CM) + CMI.loc(L).sum(L))))) \ + ** ExprM(vars, m=ETARA.loc[H]) + line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / ( + ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) + line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + ( + ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) \ + / ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum( + G))) ** ExprM(vars, m=ETAPIT.loc[H]) + + LSEQ1 = ((line1 * line2 * line3 * line4) - HW.loc(H) / HH.loc(H)) + LSEQ1.write(count, filename) + print(LSEQ1.test(vars.initialVals)) + + print('LSEQ2A') + line = ExprM(vars, m=CMO0.loc[CM1]) * ( + FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM1])) + + LSEQ2A = (line - CMO.loc(CM1)) + LSEQ2A.write(count, filename) + print(LSEQ2A.test(vars.initialVals)) + + print('LSEQ2B') + line = ExprM(vars, m=CMO0.loc[CM2]) * ( + FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM2])) + + LSEQ2B = (line - CMO.loc(CM2)) + LSEQ2B.write(count, filename) + print(LSEQ2B.test(vars.initialVals)) + # print(LSEQ2B) + + print('LSEQ2C') + line = ExprM(vars, m=CMO0.loc[CM3]) * ( + FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM3])) + + LSEQ2C = (line - CMO.loc(CM3)) + LSEQ2C.write(count, filename) + print(LSEQ2C.test(vars.initialVals)) + + print('LSEQ3') + line = ExprM(vars, m=CMI0.loc[L]) * ( + (FD.loc(L, FG).sum(FG) / ExprM(vars, m=FD0.loc[L, FG].sum(1))) ** (ExprM(vars, m=ECOMI.loc[L]))) + + LSEQ3 = (line - CMI.loc(L)) + LSEQ3.write(count, filename) + print(LSEQ3.test(vars.initialVals)) + + print('POPEQ(H)') + line1 = ExprM(vars, m=HH0.loc[H] * NRPG.loc[H]) + line2 = ExprM(vars, m=MI0.loc[H]) * ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / ( + CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) + line3 = ((HN.loc(H) / HH.loc(H)) / ExprM(vars, m=HN0.loc[H] / HH0.loc[H])) ** ExprM(vars, m=ETAU.loc[H]) + line4 = (CH.loc(HSD, H).sum(HSD) / ExprM(vars, m=CH0.loc[HSD, H].sum(0))) ** (1) + line5 = ExprM(vars, m=MO0.loc[H]) * (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / ( + ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) + line6 = (ExprM(vars, m=HN0.loc[H] / HH0.loc[H]) / (HN.loc(H) / HH.loc(H))) ** ExprM(vars, m=ETAU.loc[H]) + line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** (1) + + POPEQ = (line1 + line2 * line3 * line4 - line5 * line6 * line7 - HH.loc(H)) + POPEQ.write(count, filename) + print(POPEQ.test(vars.initialVals)) + # print(POPEQ) + + print('ANEQ(H)') + line = HH.loc(H) - HW.loc(H) + + ANEQ = (line - HN.loc(H)) + ANEQ.write(count, filename) + print(ANEQ.test(vars.initialVals)) + + print('YGEQ') + line1 = (ExprM(vars, m=TAUV.loc[GX, I]) * V.loc(I) * P.loc(I)).sum(I) + line2 = (ExprM(vars, m=TAUX.loc[GX, I]) * CX.loc(I) * PD.loc(I)).sum(I) + + YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) # first just set it to correct size + for label in GX: + for hlabel in H: + YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = Expr( + (ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) + + line3 = YGEQline3pre.sum(1) + line4 = (ExprM(vars, m=TAUN.loc[GX, I]) * CN.loc(I) * P.loc(I)).sum(I) + + YGEQline5pre = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) # first just set it to correct size + for label in GX: + YGEQline5pre.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) + line5 = YGEQline5pre + + line6 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) + for label in GX: + line6.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) + + line7 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) + for label in GX: + line7.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) + + line8 = (ExprM(vars, m=TAUFH.loc[GX, F]) * Y.loc(F)).sum(F) + line9 = (ExprM(vars, m=PIT0.loc[GX, H]) * Y.loc(H)).sum(H) + line10 = (ExprM(vars, m=TAUH.loc[GX, H]) * HH.loc(H)).sum(H) + line11 = IGT.loc(GX, GX1).sum(1) + + YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - Y.loc(GX)) + YGEQ.write(count, filename) + print(YGEQ.test(vars.initialVals)) + # print(YGEQ) + + print('YGEQ2(GT)') + line = IGT.loc(GT, GX).sum(GX) + + YGEQ2 = (line - Y.loc(GT)) + YGEQ2.write(count, filename) + print(YGEQ2.test(vars.initialVals)) + # print(YGEQ2) + + print('YGEQM(GNLM)') + line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) + + YGEQM = (line - Y.loc(GNLM)) + YGEQM.write(count, filename) + print(YGEQM.test(vars.initialVals)) + # print(YGEQM) + + print('YGEQO(GNLO)') + line = ExprM(vars, m=TAXS2.loc[GNLO]) * Y.loc(['CYGFO']) + + YGEQO = (line - Y.loc(GNLO)) + YGEQO.write(count, filename) + print(YGEQO.test(vars.initialVals)) + # print(YGEQ1) + + print('GOVFOR(G)') + line = ExprM(vars, m=GFOR.loc[G]) * Y.loc(G) + + GOVFOR = (line - GVFOR.loc(G)) + GOVFOR.write(count, filename) + print(GOVFOR.test(vars.initialVals)) + # print(GOVFOR) + + print('CGEQ(I,GN)') + left = P.loc(I) * ExprM(vars, m=1 + TAUG.loc[GS, I].sum(0)) * CG.loc(I, GN) + right = ExprM(vars, m=AG.loc[I, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) + + CGEQ = (right - left) + CGEQ.write(count, filename) + print(CGEQ.test(vars.initialVals)) + # print(CGEQ) + + print('GFEQ(F,GN)') + left = FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN])) + right = ExprM(vars, m=AG.loc[F, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) + + GFEQ = left - right + GFEQ.write(count, filename) + print(GFEQ.test(vars.initialVals)) + # print(GFEQ) + + print('GSEQL(GN)') + line1 = Y.loc(GN) + GVFOR.loc(GN) + line2 = (CG.loc(I, GN) * P.loc(I) * (1 + ExprM(vars, m=TAUG.loc[GS, I]).sum(GS))).sum(I) + line3 = (FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN]))).sum(F) + + GSEQL = ((line1 - ~line2 - ~line3) - S.loc(GN)) + GSEQL.write(count, filename) + print(GSEQL.test(vars.initialVals)) + # print(GSEQL) + + print('GSEQ(GX)') + line1 = (Y.loc(GX) + ExprM(vars, m=GFOR.loc[GX]) * Y.loc(GX)) + line2 = (ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H) + line3 = IGT.loc(G, GX).sum(G) + + GSEQ = ((line1 - ~line2 - ~line3) - S.loc(GX)) + GSEQ.write(count, filename) + print(GSEQ.test(vars.initialVals)) + # print(GSEQ) + + print('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') + line = ExprM(vars, m=TAXS.loc[G, GX]) * ( + Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) + + TDEQ = line - IGT.loc(G, GX) + TDEQ.setCondition(IGTD.loc[G, GX], 'EQ', 1) + TDEQ.write(count, filename) + print(TDEQ.test(vars.initialVals)) + # print(TDEQ) + + print('SPIEQ') + line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + ( + ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + + SPIEQ = (line - SPI) + SPIEQ.write(count, filename) + print(SPIEQ.test(vars.initialVals)) + # print(SPIEQ) + + print('LMEQ1(L)') + left = (ExprM(vars, m=JOBCOR.loc[H, L]) * HW.loc(H)).sum(H) + CMI.loc(L) + right = FD.loc(L, Z).sum(Z) + + LMEQ1 = (right - left) + LMEQ1.write(count, filename) + print(LMEQ1.test(vars.initialVals)) + # print(LMEQ1) + + print('KMEQ(K,IG)') + KMEQ = ((ExprM(vars, m=TT.loc[K, IG]) * FD.loc(K, IG)) - KS.loc(K, IG)) + KMEQ.write(count, filename) + print(KMEQ.test(vars.initialVals)) + # print(KMEQ) + + print('GMEQ(I)') + GMEQ = (DD.loc(I) + CX.loc(I) - M.loc(I) - DS.loc(I)) + GMEQ.write(count, filename) + print(GMEQ.test(vars.initialVals)) + # print(GMEQ) + + print('DDEQ(I)') + DDEQ = (V.loc(I) + CH.loc(I, H).sum(H) + CG.loc(I, G).sum(G) + CN.loc(I) - DD.loc(I)) + DDEQ.write(count, filename) + print(DDEQ.test(vars.initialVals)) + # print(DDEQ) + + # ------------------------------------------------------------------------------------------------------------- + # MODEL CLOSURE + # ------------------------------------------------------------------------------------------------------------- + + # FIX INTER GOVERNMENTAL TRANSFERS TO ZERO IF NOT IN ORIGINAL SAM + print('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') + FX1 = IGT.loc(G, GX) + FX1.setCondition(IGT0.loc[G, GX], 'EQ', 0) + FX1.write(count, filename) + # print(FX1) + + # FIX EXOGENOUS INTERGOVERNMENTAL TRANSFERS + print('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') + FX2 = IGT.loc(G, GX) - ExprM(vars, m=IGT0.loc[G, GX]) + FX2.setCondition(IGTD.loc[G, GX], 'EQ', 2) + FX2.write(count, filename) + # print(FX2) + + # FIX INTER SECTORAL WAGE DIFFERENTIALS + print('R.FX(L,Z)=R0(L,Z)') + FX3 = R.loc(L, Z) - ExprM(vars, m=R0.loc[L, Z]) + FX3.write(count, filename) + # print(FX3) + + # FIX ECONOMY WIDE SCALAR + print('RA.FX(K)=RA0(K)') + FX4 = RA.loc(K) - ExprM(vars, m=RA0.loc[K]) + FX4.write(count, filename) + + print("Objective") + obj = vars.getIndex('SPI') + + with open(filename, 'a') as f: + f.write('model.obj = Objective(expr=-1*model.x' + str(obj) + ')') + + +def run_solver(cons_filename, temp_file_name="tmp.py"): + solver = 'ipopt' + solver_io = 'nl' + stream_solver = True # True prints solver output to screen + keepfiles = False # True prints intermediate file names (.nl,.sol,...) + opt = SolverFactory(solver, solver_io=solver_io) + + if opt is None: + print("") + print("ERROR: Unable to create solver plugin for %s " \ + "using the %s interface" % (solver, solver_io)) + print("") + exit(1) + + ### Create the model + model = ConcreteModel() + set_variable(cons_filename) + set_equation(cons_filename) + ### + + exec(open(cons_filename).read()) + + ### Declare all suffixes + + # Ipopt bound multipliers (obtained from solution) + model.ipopt_zL_out = Suffix(direction=Suffix.IMPORT) + model.ipopt_zU_out = Suffix(direction=Suffix.IMPORT) + + # Ipopt bound multipliers (sent to solver) + model.ipopt_zL_in = Suffix(direction=Suffix.EXPORT) + model.ipopt_zU_in = Suffix(direction=Suffix.EXPORT) + + # Obtain dual solutions from first solve and send to warm start + model.dual = Suffix(direction=Suffix.IMPORT_EXPORT) + + ### Set Ipopt options for warm-start + # The current values on the ipopt_zU_out and + # ipopt_zL_out suffixes will be used as initial + # conditions for the bound multipliers to solve + # the new problem + model.ipopt_zL_in.update(model.ipopt_zL_out) + model.ipopt_zU_in.update(model.ipopt_zU_out) + opt.options['warm_start_init_point'] = 'yes' + opt.options['warm_start_bound_push'] = 1e-6 + opt.options['warm_start_mult_bound_push'] = 1e-6 + opt.options['mu_init'] = 1e-6 + + ### Send the model and suffix information to ipopt and collect the solution + # The solver plugin will scan the model for all active suffixes + # valid for importing, which it will store into the results object + + results = opt.solve(model, keepfiles=keepfiles, tee=stream_solver) + + x = [None for i in range(vars.nvars)] + + with open(temp_file_name, 'w') as f: + for i in range(vars.nvars): + f.write('x[' + str(i) + ']=value(model.x' + str(i) + ')\n') + + exec(open(temp_file_name).read()) + + soln.append(x[:]) + + return None + + +''' +Calibrate the model +''' + +soln = [] +filename = os.path.join(filePath, "ipopt_cons.py") +tmp = os.path.join(filePath, "tmp.py") +print("Calibration: ") +run_solver(filename, tmp) + +''' +Simulation code below: +In each simulation: + +1. Apply simulation code (for instance PI(I) = 1.02). +2. Rewrite all equations +3. Solve the new model with the result from last run as initial guess. + +''' + +############ begin shock by using tables + +# iNum = 1 # dynamic model itterations + +sims = pd.read_csv(os.path.join(filePath, 'SIMS 500.csv'), index_col=0) +iNum = 1 +# iNum = len(sims.columns) +KS00 = KS0.copy() + +for num in range(iNum): + # print("Simulation: ", num+1) + KS0.loc[K, I] = KS00.loc[K, I].mul(sims.iloc[:, num]) + run_solver(filename, tmp) + +############ end shock by using tables + +exec(open(os.path.join(modelPath, "shelby_output.py")).read()) diff --git a/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py b/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py new file mode 100755 index 000000000..9f4136047 --- /dev/null +++ b/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py @@ -0,0 +1,1908 @@ +from shelby.Equationlib import * +from shelby.OutputFunctions import * +import os +import pandas as pd +from pyomo.environ import * +from pyomo.opt import SolverFactory + + +def _(x): + return ExprM(vars, m=x) + +# set file paths + +modelPath = os.path.join(os.getcwd(), 'shelby') +filePath = os.path.join(modelPath, 'shelby') + +# define sets + +# ALL ACCOUNTS IN SOCIAL ACCOUNTING MATRIX + +Z = [ + 'GOODSA', + 'TRADEA', + 'OTHERA', + 'GOODSB', + 'TRADEB', + 'OTHERB', + 'GOODSC', + 'TRADEC', + 'OTHERC', + 'GOODSD', + 'TRADED', + 'OTHERD', + 'GOODSE', + 'TRADEE', + 'OTHERE', + 'GOODSF', + 'TRADEF', + 'OTHERF', + 'GOODSG', + 'TRADEG', + 'OTHERG', + 'GOODSH', + 'TRADEH', + 'OTHERH', + 'HS1A', + 'HS2A', + 'HS3A', + 'HS1B', + 'HS2B', + 'HS3B', + 'HS1C', + 'HS2C', + 'HS3C', + 'HS1D', + 'HS2D', + 'HS3D', + 'HS1E', + 'HS2E', + 'HS3E', + 'HS1F', + 'HS2F', + 'HS3F', + 'HS1G', + 'HS2G', + 'HS3G', + 'HS1H', + 'HS2H', + 'HS3H', + 'L1A', + 'L2A', + 'L3A', + 'L1B', + 'L2B', + 'L3B', + 'L1C', + 'L2C', + 'L3C', + 'L1D', + 'L2D', + 'L3D', + 'L1E', + 'L2E', + 'L3E', + 'L1F', + 'L2F', + 'L3F', + 'L1G', + 'L2G', + 'L3G', + 'L1H', + 'L2H', + 'L3H', + 'KAP', + 'HH1A', + 'HH2A', + 'HH3A', + 'HH4A', + 'HH5A', + 'HH1B', + 'HH2B', + 'HH3B', + 'HH4B', + 'HH5B', + 'HH1C', + 'HH2C', + 'HH3C', + 'HH4C', + 'HH5C', + 'HH1D', + 'HH2D', + 'HH3D', + 'HH4D', + 'HH5D', + 'HH1E', + 'HH2E', + 'HH3E', + 'HH4E', + 'HH5E', + 'HH1F', + 'HH2F', + 'HH3F', + 'HH4F', + 'HH5F', + 'HH1G', + 'HH2G', + 'HH3G', + 'HH4G', + 'HH5G', + 'HH1H', + 'HH2H', + 'HH3H', + 'HH4H', + 'HH5H', + 'INVES', + 'USSOCL1A', + 'USSOCL2A', + 'USSOCL3A', + 'USSOCL1B', + 'USSOCL2B', + 'USSOCL3B', + 'USSOCL1C', + 'USSOCL2C', + 'USSOCL3C', + 'USSOCL1D', + 'USSOCL2D', + 'USSOCL3D', + 'USSOCL1E', + 'USSOCL2E', + 'USSOCL3E', + 'USSOCL1F', + 'USSOCL2F', + 'USSOCL3F', + 'USSOCL1G', + 'USSOCL2G', + 'USSOCL3G', + 'USSOCL1H', + 'USSOCL2H', + 'USSOCL3H', + 'MEMPROPTAX', + 'OTHERPROPTAX', + 'MEMSALESTAX', + 'OTHERSALESTAX', + 'MEMFEE', + 'OTHERFEE', + 'TNSTX', + 'TNITAX', + 'USPIT', + 'CYGFM', + 'CYGFO', + 'FED', + 'STATE', + 'MEMPHIS', + 'OTHER', + 'OUTCOM1', + 'OUTCOM2', + 'OUTCOM3', + 'ROW'] + +# FACTORS +F = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', 'KAP'] + +F11 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] + +F21 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] + +F31 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] + +# COMMUTERS OUT +CM = ['OUTCOM1', 'OUTCOM2', 'OUTCOM3'] + +# COMMUTERS OUT 1 +CM1 = ['OUTCOM1'] + +# COMMUTERS OUT 2 +CM2 = ['OUTCOM2'] + +# COMMUTERS OUT 3 +CM3 = ['OUTCOM3'] + +# ALL WORKERS WHO LIVE IN SHELBY +LT = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', + 'OUTCOM1', 'OUTCOM2', 'OUTCOM3'] + +# LABOR +L = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'] + +L1 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] + +L2 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] + +L3 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] + +# CAPITAL +K = ['KAP'] + +# GOVERNMENTS +G = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', + 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', + 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', + 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', + 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT', 'CYGFM', 'CYGFO', 'FED', + 'STATE', 'MEMPHIS', 'OTHER'] + +# ENDOGENOUS GOVERNMENTS +GN = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] + +# LOCAL ENDOGENOUS GOVERNMENTS +GNLM = ['MEMPHIS'] + +# LOCAL ENDOGENOUS GOVERNMENTS +GNLO = ['OTHER'] + +# EXOGENOUS GOVERMENTS +GX = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', + 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', + 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', + 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', + 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT'] + +# SALES OR EXCISE TAXES +GS = ['MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', 'OTHERFEE', 'TNSTX'] + +# LAND TAXES +GL = ['MEMPROPTAX', 'OTHERPROPTAX'] + +# FACTOR TAXES +GF = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', 'MEMPROPTAX', 'OTHERPROPTAX'] + +# SS PAYMENT +GFUS = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] + +# SS PAYMENT +GFUSC = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] + +# INCOME TAX UNITS +GI = ['TNITAX', 'USPIT'] + +# HOUSEHOLD TAX UNITS +GH = ['MEMPROPTAX', 'OTHERPROPTAX', 'MEMFEE', 'OTHERFEE'] + +# ENDOGENOUS TRANSFER PMT +GT = ['CYGFM', 'CYGFO', 'FED', 'STATE'] + +# HOUSEHOLDS +H = ['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', + 'HH5C', + 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', + 'HH5F', + 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'] + +# I+G SECTORS +IG = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', + 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', + 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', + 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H', + 'FED', 'STATE', 'MEMPHIS', 'OTHER'] + +# INDUSTRY SECTORS +I = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', + 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', + 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', + 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H'] + +# ENDOGENOUS GOVERNMENTS +IG2 = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] + +# PRODUCTION SECTORS +IP = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', + 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', + 'OTHERH'] + +# PRODUCTION GOV. +FG = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', + 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', + 'OTHERH'] + +# HOUSING SERV.DEMAND +HSD = ['HS1A', 'HS2A', 'HS3A', 'HS1B', 'HS2B', 'HS3B', 'HS1C', 'HS2C', 'HS3C', 'HS1D', 'HS2D', 'HS3D', + 'HS1E', 'HS2E', 'HS3E', 'HS1F', 'HS2F', 'HS3F', 'HS1G', 'HS2G', 'HS3G', 'HS1H', 'HS2H', 'HS3H'] + +# SIMMLOOP +SM = ['BASE', 'TODAY', 'SIMM'] + +# REPORT 1 FOR SCALARS +R1H = ['GFREV', 'SFREV', 'PIT', + 'DGF', 'DSF', 'DDRE', 'PDRE', 'SPI', 'COMM', 'COMMO', + 'GN', 'NKI', 'HH', 'W', 'W1', 'W2', 'W3', 'R', 'RL', 'L', 'K', 'HN', 'HW', 'GFSAVM', 'GFSAVO', 'LD', + 'CMO', 'CMI', 'HC', 'SSC', 'LAND', 'LAS'] + +# REPORT 2 FOR STATUS +R2H = ['M-STAT', 'S-STAT'] + +# LABELS FOR MODEL STATUS +MS = ['OPTIMAL', 'LOCALOP', 'UNBOUND', + 'INFSBLE', 'INFSLOC', 'INFSINT', + 'NOOPTML', 'MIPSOLN', 'NOINTGR', + 'INFSMIP', 'UNUSED', 'UNKNOWN', + 'NOSOLUT'] + +# LABELS FOR SOLVER STATUS +SS = ['OK', 'ITERATE', 'RESRCE', + 'SOLVER', 'EVALUATE', 'NOTKNWN', + 'NOTUSED', 'PRE-PROC', 'SETUP', + 'SLVFAIL', 'SLVINTER', 'POST-PROC', + 'METSYS'] + +# SETS FOR MISC TABLES ONLY + +# HOUSING SERVICES +HSSET = ['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', + 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] + +# HOUSING SERVICES 2 & 3 +HS23SET = ['HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] + +# HOUSEHOLDS (INCOME 1) +HH1 = ['HH1A', 'HH1B', 'HH1C', 'HH1D', 'HH1E', 'HH1F', 'HH1G', 'HH1H'] + +# HOUSEHOLDS (INCOME 2) +HH2 = ['HH2A', 'HH2B', 'HH2C', 'HH2D', 'HH2E', 'HH2F', 'HH2G', 'HH2H'] + +# HOUSEHOLDS (INCOME 3) +HH3 = ['HH3A', 'HH3B', 'HH3C', 'HH3D', 'HH3E', 'HH3F', 'HH3G', 'HH3H'] + +# HOUSEHOLDS (INCOME 4) +HH4 = ['HH4A', 'HH4B', 'HH4C', 'HH4D', 'HH4E', 'HH4F', 'HH4G', 'HH4H'] + +# HOUSEHOLDS (INCOME 5) +HH5 = ['HH5A', 'HH5B', 'HH5C', 'HH5D', 'HH5E', 'HH5F', 'HH5G', 'HH5H'] + +# ELASTICITIES +ETA = ['ETAL1', 'ETAI1', 'ETALB1', 'ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU', 'ETAM', 'ETAE', 'ETAY', 'ETAOP'] + +# LANDCAP TABLE ELASTICITIES +ETALANDCAP = ['ETAL1', 'ETAI1', 'ETALB1'] + +# MISCH TABLE ELASTICITIES +ETAMISCH = ['ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU'] + +# MISC TABLE ELASTICITIES +ETAMISC = ['ETAM', 'ETAE', 'ETAY', 'ETAOP'] + +# SET ALIASES + +# ALIAS +J = I +I1 = I +Z1 = Z +F1 = F +G1 = G +G2 = G +GI1 = GI +GS1 = GS +GX1 = GX +GN1 = GN +GH1 = GH +GF1 = GF +H1 = H +HSD1 = HSD +JP = IP +JG = IG +GT1 = GT +GNLM1 = GNLM +GNLO1 = GNLO + +# IMPORT ADDITIONAL DATA FILES + +# SAM +SAM = pd.read_csv(os.path.join(filePath, 'SAM Shelby(1202).csv'), index_col=0) + +# CAPITAL COMP +BB = pd.read_csv(os.path.join(filePath, 'capcomshelby.csv'), index_col=0) + +# MISC TABLES + +TPC = pd.DataFrame(index=H, columns=G).fillna(0.0) +IGTD = pd.DataFrame(index=G, columns=G1).fillna(0.0) +TAUFF = pd.DataFrame(index=G, columns=F).fillna(0.0) +IOUT = pd.DataFrame(index=G1, columns=G1).fillna(0.0) +LANDCAP = pd.DataFrame(index=IG, columns=ETALANDCAP).fillna(0.0) +MISC = pd.DataFrame(index=Z, columns=ETAMISC).fillna(0.0) +MISCH = pd.DataFrame(index=H, columns=ETAMISCH).fillna(0.0) + +miscPath = os.path.join(filePath, 'MiscFile') + +# EMPLOY0 = pd.read_csv(os.path.join(miscPath, 'EMPLOY0(Z,F).csv'), index_col=0) +EMPLOY = pd.read_csv(os.path.join(miscPath, 'EMPLOY(Z,F).csv'), index_col=0) +JOBCR = pd.read_csv(os.path.join(miscPath, 'JOBCR(H,L).csv'), index_col=0) +# JOBCR1 = pd.read_csv(os.path.join(miscPath, 'JOBCR1(H,L).csv'), index_col=0) +HHTABLE = pd.read_csv(os.path.join(miscPath, 'HHTABLE(H,).csv'), index_col=0) +# OUTCR = pd.read_csv(os.path.join(miscPath, 'OUTCR(H,CM).csv'), index_col=0) + +# PARAMETER DECLARATION + +# these are data frames with zeros to be filled during calibration +A = pd.DataFrame(index=Z, columns=Z).fillna(0.0) +AD = pd.DataFrame(index=Z, columns=Z).fillna(0.0) +AG = pd.DataFrame(index=Z, columns=G).fillna(0.0) +AGFS = pd.DataFrame(index=Z, columns=G).fillna(0.0) +SIGMA = pd.Series(index=I, dtype=float).fillna(0.0) +ALPHA = pd.DataFrame(index=F, columns=I).fillna(0.0) +ALPHA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) +B = pd.DataFrame(index=I, columns=IG).fillna(0.0) +B1 = pd.DataFrame(index=I, columns=I).fillna(0.0) +CMOWAGE = pd.Series(index=CM, dtype=float).fillna(0.0) +CMIWAGE = pd.Series(index=L, dtype=float).fillna(0.0) +FCONST = pd.DataFrame(index=F, columns=I).fillna(0.0) +GAMMA = pd.Series(index=I, dtype=float).fillna(0.0) +DELTA = pd.Series(index=I, dtype=float).fillna(0.0) +PIT = pd.DataFrame(index=G, columns=H).fillna(0.0) +PIT0 = pd.DataFrame(index=G, columns=H).fillna(0.0) +PRIVRET1 = pd.Series(index=H, dtype=float).fillna(0.0) +PRIVRET = pd.Series(index=H, dtype=float).fillna(0.0) +# LFOR = pd.Series(index=LA, dtype=float).fillna(0.0) +KFOR = pd.Series(index=K, dtype=float).fillna(0.0) +GFOR = pd.Series(index=G, dtype=float).fillna(0.0) +out = pd.DataFrame(index=G, columns=G).fillna(0.0) +TAUFH = pd.DataFrame(index=G, columns=F).fillna(0.0) +TAUFL = pd.DataFrame(index=G, columns=L).fillna(0.0) +# TAUFLA = pd.DataFrame(index=G, columns=LA).fillna(0.0) +TAUFK = pd.DataFrame(index=G, columns=K).fillna(0.0) +TAUH = pd.DataFrame(index=G, columns=H).fillna(0.0) +TAUH0 = pd.DataFrame(index=G, columns=H).fillna(0.0) +TAUM = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUQ = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUC = pd.DataFrame(index=G, columns=I).fillna(0.0) +TAUCH = pd.DataFrame(index=G, columns=HSD).fillna(0.0) +TAUV = pd.DataFrame(index=G, columns=I).fillna(0.0) +TAUN = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUX = pd.DataFrame(index=G, columns=IG).fillna(0.0) +TAUG = pd.DataFrame(index=G, columns=I).fillna(0.0) +TAXS = pd.DataFrame(index=G, columns=G).fillna(0.0) +TAXS1 = pd.Series(index=GNLM, dtype=float).fillna(0.0) +TAXS2 = pd.Series(index=GNLO, dtype=float).fillna(0.0) + +# ELASTICITIES AND TAX DATA IMPOSED + +BETA = pd.DataFrame(index=I, columns=H).fillna(0.0) +BETAH = pd.DataFrame(index=HSD, columns=H).fillna(0.0) +ETAD = pd.Series(index=I, dtype=float).fillna(0.0) +ETAE = pd.Series(index=I, dtype=float).fillna(0.0) +ETAI = pd.Series(index=IG, dtype=float).fillna(0.0) +ETAIX = pd.DataFrame(index=K, columns=IG).fillna(0.0) +# ETAL = pd.DataFrame(index=LA, columns=IG).fillna(0.0) +ETAL1 = pd.Series(index=IG, dtype=float).fillna(0.0) +ETALB1 = pd.Series(index=IG, dtype=float).fillna(0.0) +ETALB = pd.DataFrame(index=L, columns=IG).fillna(0.0) +ETAM = pd.Series(index=I, dtype=float).fillna(0.0) +ETARA = pd.Series(index=H, dtype=float).fillna(0.0) +ETAYDO = pd.Series(index=H, dtype=float).fillna(0.0) +ETAUO = pd.Series(index=H, dtype=float).fillna(0.0) +ETAYDI = pd.Series(index=H, dtype=float).fillna(0.0) +ETAUI = pd.Series(index=H, dtype=float).fillna(0.0) +ETAYD = pd.Series(index=H, dtype=float).fillna(0.0) +ETAU = pd.Series(index=H, dtype=float).fillna(0.0) +ETAPT = pd.Series(index=H, dtype=float).fillna(0.0) +ETAPIT = pd.Series(index=H, dtype=float).fillna(0.0) +EXWGEO = pd.Series(index=CM, dtype=float).fillna(0.0) +EXWGEI = pd.Series(index=L, dtype=float).fillna(0.0) +ECOMI = pd.Series(index=L, dtype=float).fillna(0.0) +ECOMO = pd.Series(index=CM, dtype=float).fillna(0.0) +HOUSECOR = pd.DataFrame(index=H, columns=HSD).fillna(0.0) +JOBCOR = pd.DataFrame(index=H, columns=L).fillna(0.0) + +LAMBDA = pd.DataFrame(index=I, columns=I).fillna(0.0) +LAMBDAH = pd.DataFrame(index=HSD, columns=HSD1).fillna(0.0) + +NRPG = pd.Series(index=H, dtype=float).fillna(0.0) +RHO = pd.Series(index=I, dtype=float).fillna(0.0) +TT = pd.DataFrame(index=Z, columns=IG).fillna(0.0) + +depr = pd.Series(index=IG, dtype=float).fillna(0.1) + +# ARRAYS BUILT TO EXPORT RESULTS TO SEPARATE FILE + +R1 = pd.DataFrame(index=R1H, columns=SM).fillna(0.0) +R2 = pd.DataFrame(index=R2H, columns=SM).fillna(0.0) + +# INITIAL VALUES OF ENDOGENOUS VARIABLES + +CG0 = pd.DataFrame(index=I, columns=G).fillna(0.0) +CG0T = pd.DataFrame(index=I, columns=G).fillna(0.0) +CH0 = pd.DataFrame(index=I, columns=H).fillna(0.0) +CH0T = pd.DataFrame(index=I, columns=H).fillna(0.0) +CMI0 = pd.Series(index=L, dtype=float).fillna(0.0) +CMO0 = pd.Series(index=CM, dtype=float).fillna(0.0) +CN0 = pd.Series(index=I, dtype=float).fillna(0.0) +CN0T = pd.Series(index=I, dtype=float).fillna(0.0) +CPI0 = pd.Series(index=H, dtype=float).fillna(0.0) +CPIN0 = pd.Series(index=H, dtype=float).fillna(0.0) +CPIH0 = pd.Series(index=H, dtype=float).fillna(0.0) +CX0 = pd.Series(index=I, dtype=float).fillna(0.0) +D0 = pd.Series(index=I, dtype=float).fillna(0.0) +DD0 = pd.Series(index=Z, dtype=float).fillna(0.0) +DS0 = pd.Series(index=Z, dtype=float).fillna(0.0) +DQ0 = pd.Series(index=Z, dtype=float).fillna(0.0) + +FD0 = pd.DataFrame(index=F, columns=Z).fillna(0.0) +IGT0 = pd.DataFrame(index=G, columns=GX).fillna(0.0) +KS0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) +KSNEW = pd.DataFrame(index=K, columns=IG).fillna(0.0) +KSNEW0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) +# LAS0 = pd.DataFrame(index=LA, columns=IG).fillna(0.0) +HH0 = pd.Series(index=H, dtype=float).fillna(0.0) +HN0 = pd.Series(index=H, dtype=float).fillna(0.0) +HW0 = pd.Series(index=H, dtype=float).fillna(0.0) +M0 = pd.Series(index=I, dtype=float).fillna(0.0) +M01 = pd.Series(index=Z, dtype=float).fillna(0.0) +MI0 = pd.Series(index=H, dtype=float).fillna(0.0) +MO0 = pd.Series(index=H, dtype=float).fillna(0.0) +N0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) + +# NKIO + +KPFOR01 = pd.Series(index=K, dtype=float).fillna(0.0) +KPFOR0 = pd.Series(index=K, dtype=float).fillna(0.0) +# LNFOR0 = pd.Series(index=LA, dtype=float).fillna(0.0) +# LNFOR01 = pd.Series(index=LA, dtype=float).fillna(0.0) +GVFOR0 = pd.Series(index=G, dtype=float).fillna(0.0) +P0 = pd.Series(index=IG, dtype=float).fillna(0.0) +PH0 = pd.Series(index=HSD, dtype=float).fillna(0.0) +PD0 = pd.Series(index=I, dtype=float).fillna(0.0) +PVA0 = pd.Series(index=I, dtype=float).fillna(0.0) +PWM0 = pd.Series(index=I, dtype=float).fillna(0.0) +PW0 = pd.Series(index=I, dtype=float).fillna(0.0) +Q0 = pd.Series(index=Z, dtype=float).fillna(0.0) +Q10 = pd.Series(index=Z, dtype=float).fillna(0.0) +R0 = pd.DataFrame(index=F, columns=Z).fillna(1.0) +RA0 = pd.Series(index=F, dtype=float).fillna(0.0) +S0 = pd.Series(index=Z, dtype=float).fillna(0.0) + +# SPIO + +V0 = pd.Series(index=I, dtype=float).fillna(0.0) +V0T = pd.Series(index=I, dtype=float).fillna(0.0) +V10 = pd.DataFrame(index=I, columns=I).fillna(0.0) +TP = pd.DataFrame(index=H, columns=G).fillna(0.0) + +# TAUF0 = Table(G,F,Z) + +YD0 = pd.Series(index=H, dtype=float).fillna(0.0) +Y0 = pd.Series(index=Z, dtype=float).fillna(0.0) +Y01 = pd.Series(index=H, dtype=float).fillna(0.0) +YT0 = pd.Series(index=G, dtype=float).fillna(0.0) +GCP10 = pd.Series(index=I, dtype=float).fillna(0.0) + +# GCP0 + +DDCX = pd.Series(index=I, dtype=float).fillna(0.0) + +TESTA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) +TESTA2 = pd.DataFrame(index=F, columns=I).fillna(0.0) +TESTA3 = pd.DataFrame(index=F, columns=I).fillna(0.0) + +# SIMPLIFYING TABLES AND DOING AWAY WITH MISC FILES + +for label in G1: + out.loc[label, label] = 0 +out.loc['MEMPHIS', 'CYGFM'] = 1 +out.loc['OTHER', 'CYGFO'] = 1 + +IGTD.loc[G, G1] = 0 +IGTD.loc['FED', GFUS] = 1 +IGTD.loc['FED', 'USPIT'] = 1 + +IGTD.loc['CYGFM', 'MEMPROPTAX'] = 1 +IGTD.loc['CYGFM', 'MEMSALESTAX'] = 1 +IGTD.loc['CYGFM', 'MEMFEE'] = 1 + +IGTD.loc['CYGFO', 'OTHERPROPTAX'] = 1 +IGTD.loc['CYGFO', 'OTHERSALESTAX'] = 1 +IGTD.loc['CYGFO', 'OTHERFEE'] = 1 + +IGTD.loc['STATE', 'TNSTX'] = 1 +IGTD.loc['STATE', 'TNITAX'] = 1 + +TPC.loc[H, G] = 0 +TPC.loc[H, GFUS] = 1 + +TAUFF.loc[G, F] = 0 +TAUFF.loc['USSOCL1A', 'L1A'] = 1 +TAUFF.loc['USSOCL2A', 'L2A'] = 1 +TAUFF.loc['USSOCL3A', 'L3A'] = 1 +TAUFF.loc['USSOCL1B', 'L1B'] = 1 +TAUFF.loc['USSOCL2B', 'L2B'] = 1 +TAUFF.loc['USSOCL3B', 'L3B'] = 1 +TAUFF.loc['USSOCL1C', 'L1C'] = 1 +TAUFF.loc['USSOCL2C', 'L2C'] = 1 +TAUFF.loc['USSOCL3C', 'L3C'] = 1 +TAUFF.loc['USSOCL1D', 'L1D'] = 1 +TAUFF.loc['USSOCL2D', 'L2D'] = 1 +TAUFF.loc['USSOCL3D', 'L3D'] = 1 +TAUFF.loc['USSOCL1E', 'L1E'] = 1 +TAUFF.loc['USSOCL2E', 'L2E'] = 1 +TAUFF.loc['USSOCL3E', 'L3E'] = 1 +TAUFF.loc['USSOCL1F', 'L1F'] = 1 +TAUFF.loc['USSOCL2F', 'L2F'] = 1 +TAUFF.loc['USSOCL3F', 'L3F'] = 1 +TAUFF.loc['USSOCL1G', 'L1G'] = 1 +TAUFF.loc['USSOCL2G', 'L2G'] = 1 +TAUFF.loc['USSOCL3G', 'L3G'] = 1 +TAUFF.loc['USSOCL1H', 'L1H'] = 1 +TAUFF.loc['USSOCL2H', 'L2H'] = 1 +TAUFF.loc['USSOCL3H', 'L3H'] = 1 + +TAUFF.loc['MEMPROPTAX', 'KAP'] = 1 +TAUFF.loc['OTHERPROPTAX', 'KAP'] = 1 + +for label in G1: + IOUT.loc[label, label] = 0 +IOUT.loc['MEMPHIS', 'CYGFM'] = 1 +IOUT.loc['OTHER', 'CYGFO'] = 1 + +LANDCAP.loc[IG, ETALANDCAP] = 1 + +MISCH.loc[H, ETAMISCH] = 0 +MISCH.loc[HH1, 'ETAPT'] = -0.5 +MISCH.loc[HH2, 'ETAPIT'] = -0.15 +MISCH.loc[HH3, 'ETAPIT'] = -0.2 +MISCH.loc[HH4, 'ETAPIT'] = -0.25 +MISCH.loc[HH5, 'ETAPIT'] = -0.35 + +MISCH.loc[H, 'NRPG'] = 1 + +MISC.loc[IG, ETAMISC] = 0 +MISC.loc[IP, 'ETAM'] = 1 +# MISC.loc[IP, 'ETAE'] = -3.65 +MISC.loc[I, 'ETAY'] = 1 +MISC.loc[I, 'ETAOP'] = -1 + +# PARAMETERS AND ELASTICITIES + + +out.loc[G1, G1] = IOUT.loc[G1, G1] +BETA.loc[I, H] = MISC.loc[I, 'ETAY'] +BETAH.loc[HSD, H] = MISC.loc[HSD, 'ETAY'] + +for label in I: + LAMBDA.loc[label, label] = MISC.loc[label, 'ETAOP'] + +ETAE.loc[I] = MISC.loc[I, 'ETAE'] +ETAM.loc[I] = MISC.loc[I, 'ETAM'] +ETARA.loc[H] = MISCH.loc[H, 'ETARA'] + +ETAPIT.loc[H] = MISCH.loc[H, 'ETAPIT'] +ETAPT.loc[H] = MISCH.loc[H, 'ETAPT'] +ETAYD.loc[H] = MISCH.loc[H, 'ETAYD'] +NRPG.loc[H] = MISCH.loc[H, 'NRPG'] +ETAU.loc[H] = MISCH.loc[H, 'ETAU'] +ETAI.loc[IG] = LANDCAP.loc[IG, 'ETAI1'] +ETAIX.loc['KAP', IG] = ETAI.loc[IG] + +# play with elasticities + +# EXPERIMENTAL ELASTICITIES +ECOMI.loc[L] = 1 +ECOMO.loc[CM] = 1 +EXWGEO.loc[CM] = 1 +EXWGEI.loc[L] = 1 +ETAE.loc[IP] = -0.4 +ETAIX.loc['KAP', IG] = 0.1 +ETARA.loc[H] = 1.5 +ETAYDO.loc[H] = 1.0 +ETAYDI.loc[H] = 1.5 +ETAUI.loc[H] = -0.72 +ETAUO.loc[HH1] = -0.8 +ETAUO.loc[HH2] = -0.6 +ETAUO.loc[HH3] = -0.4 +ETAUO.loc[HH4] = -0.2 +ETAUO.loc[HH5] = -0.2 +ETAU.loc[H] = -0.1 +ETAYD.loc[H] = 1 + +# CALIBRATION + +# Column Totals of SAM table +Q10.loc[Z] = SAM.loc[Z, Z].sum(1) + +# Row Totals of SAM table +Q0.loc[Z] = SAM.loc[Z, Z].sum(0) + +# difference of SAM row and coloumn totals +DQ0.loc[Z] = Q10.loc[Z] - Q0.loc[Z] + +# Column Totals of SAM table +Q10.loc[Z] = SAM.loc[Z].sum(0) + +B1.loc[I, I] = SAM.loc[I, I] + +# Calculate tax rates from SAM information +TAUQ_1 = SAM.loc[GS, I] +TAUQ_2 = SAM.loc[I, I].sum(1) +TAUQ_3 = SAM.loc[I, H].sum(1) +TAUQ_4 = SAM.loc[I, ['INVES']].sum(1) +TAUQ_5 = SAM.loc[I, G].sum(1) +TAUQ_6 = SAM.loc[I, ['ROW']].sum(1) +TAUQ_7 = SAM.loc[GS1, I].sum(0) + +TAUQ.loc[GS, I] = TAUQ_1 / (TAUQ_2 + TAUQ_3 + TAUQ_4 + TAUQ_5 + TAUQ_6 - TAUQ_7) + +# NOTE: +# set taxes to average if not specific to model +TAUC.loc[GS, I] = TAUQ.loc[GS, I] +TAUV.loc[GS, I] = TAUQ.loc[GS, I] +TAUN.loc[GS, I] = TAUQ.loc[GS, I] +TAUG.loc[GS, I] = TAUQ.loc[GS, I] +TAUX.loc[GS, I] = TAUQ.loc[GS, I] + +# FACTOR TAX RATES +TAUFarray = [[[0 for k in range(len(Z))] for j in range(len(F))] for i in range(len(G))] +for i in range(len(GF)): + for j in range(len(F)): + for k in range(len(I)): + if SAM.loc[F[j], I[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: + TAUFarray[G.index(GF[i])][j][Z.index(I[k])] = SAM.loc[GF[i], I[k]] / SAM.loc[F[j], I[k]] + +for i in range(len(GF)): + for j in range(len(F)): + for k in range(len(G)): + if SAM.loc[F[j], G[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: + TAUFarray[G.index(GF[i])][j][Z.index(G[k])] = SAM.loc[GF[i], G[k]] / SAM.loc[F[j], G[k]] + +TAUFX_SUM_array = [[0 for j in range(len(Z))] for i in range(len(F))] +for i in range(len(F)): + for j in range(len(Z)): + tmp = 0 + for k in range(len(G)): + tmp += TAUFarray[k][i][j] + TAUFX_SUM_array[i][j] = tmp + +# TAUFX summed over GX +TAUFX_SUM = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) + +TAUFX_GF = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) + +TAUFXgx = {} +for i in range(len(GX)): + TAUFXgx[GX[i]] = pd.DataFrame(TAUFarray[i], index=F, columns=Z).fillna(0.0) + +# SS TAX RATES +for i in GF: + for j in F: + if TAUFF.loc[i, j] != 0: + # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[Z, F].sum(0).loc[j]) + TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[Z, F].sum(0).at[j] + +for i in GFUS: + for j in L: + if TAUFF.loc[i, j] != 0: + # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[L, IG].sum(1).loc[j]) + TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[L, IG].sum(1).at[j] + +# EMPLOYEE PORTION OF FACTOR TAXES +TAUFL.loc[GF, L] = SAM.loc[GF, L] / (SAM.loc[Z, L].sum(0) - SAM.loc[L, ['ROW']].sum(1)) + +TAUFK.loc[GF, K] = SAM.loc[GF, K] / SAM.loc[Z, K].sum(0) + +# SHARES OF ENDOGENOUS GOVERNMENTS TRANFERS TO REVENUE +TAXS.loc[G, GX] = SAM.loc[G, GX] / SAM.loc[G, GX].sum(0) + +TAXS1.loc[GNLM] = SAM.loc[GNLM, ['CYGFM']].sum(1) / SAM.loc[GNLM, ['CYGFM']].sum(1).sum(0) + +TAXS2.loc[GNLO] = SAM.loc[GNLO, ['CYGFO']].sum(1) / SAM.loc[GNLO, ['CYGFO']].sum(1).sum(0) + +# SET INITIAL INTER GOVERNMENTAL TRANSFERS +IGT0.loc[G, GX] = SAM.loc[G, GX] + +# SET INITIAL PRICES TO UNITY LESS SALES AND EXCISE TAXES +PW0.loc[I] = 1.0 +PWM0.loc[I] = 1.0 +P0.loc[I] = 1.0 +PD0.loc[I] = 1.0 +CPI0.loc[H] = 1.0 +CPIN0.loc[H] = 1.0 +CPIH0.loc[H] = 1.0 +TT.loc[F, IG] = 1.0 + +# HOUSEHOLD TRANSFER PAYMENTS AND PERSONAL INCOME TAXES +# TOTAL HH IN Shelby +HH0.loc[H] = HHTABLE.loc[H, 'HH0'] + +# TOTAL WORKING HH IN SHELBY (WORK IN SHELBY & OUTSIDE SHELBY) +HW0.loc[H] = HHTABLE.loc[H, 'HW0'] + +# NON WORKING HH IN SHELBY +HN0.loc[H] = HH0.loc[H] - HW0.loc[H] + +# NOMINAL GOVERNMENT SS PAYMENTS +TP.loc[H, G] = SAM.loc[H, G].div(HH0.loc[H], axis='index').fillna(0.0) + +# FACTOR RENTALS +JOBCOR.loc[H, L] = JOBCR.loc[H, L] + +# RENTAL RATE FOR FACTORS +R0.loc[F, Z] = 1.0 + +R0.loc[F, IG] = (SAM.loc[F, IG] / EMPLOY.loc[IG, F].T).fillna(1.0) + +# REAL FACTOR DEMAND +FD0.loc[F, IG] = EMPLOY.loc[IG, F].T + +KS0.loc[K, IG] = FD0.loc[K, IG] + +# SHARES FOUND IN THE SOCIAL ACCOUNTING MATRIX DATA +# A = INPUT OUTPUT COEFICIENTS +A.loc[Z, Z] = SAM.loc[Z, Z].div(Q0.loc[Z], axis='columns') + +# SS PAYMENTS FROM IN-COMMUTERS + +# AGFS: LABOR PAYMENTS BY G SECTOR + USSOC PAYMENTS BY LABOR (GROSS LABOR PAYMENTS) +AGFS.loc['L1A', G] = SAM.loc['L1A', G] + SAM.loc['USSOCL1A', G] +AGFS.loc['L2A', G] = SAM.loc['L2A', G] + SAM.loc['USSOCL2A', G] +AGFS.loc['L3A', G] = SAM.loc['L3A', G] + SAM.loc['USSOCL3A', G] + +AGFS.loc['L1B', G] = SAM.loc['L1B', G] + SAM.loc['USSOCL1B', G] +AGFS.loc['L2B', G] = SAM.loc['L2B', G] + SAM.loc['USSOCL2B', G] +AGFS.loc['L3B', G] = SAM.loc['L3B', G] + SAM.loc['USSOCL3B', G] + +AGFS.loc['L1C', G] = SAM.loc['L1C', G] + SAM.loc['USSOCL1C', G] +AGFS.loc['L2C', G] = SAM.loc['L2C', G] + SAM.loc['USSOCL2C', G] +AGFS.loc['L3C', G] = SAM.loc['L3C', G] + SAM.loc['USSOCL3C', G] + +AGFS.loc['L1D', G] = SAM.loc['L1D', G] + SAM.loc['USSOCL1D', G] +AGFS.loc['L2D', G] = SAM.loc['L2D', G] + SAM.loc['USSOCL2D', G] +AGFS.loc['L3D', G] = SAM.loc['L3D', G] + SAM.loc['USSOCL3D', G] + +AGFS.loc['L1E', G] = SAM.loc['L1E', G] + SAM.loc['USSOCL1E', G] +AGFS.loc['L2E', G] = SAM.loc['L2E', G] + SAM.loc['USSOCL2E', G] +AGFS.loc['L3E', G] = SAM.loc['L3E', G] + SAM.loc['USSOCL3E', G] + +AGFS.loc['L1F', G] = SAM.loc['L1F', G] + SAM.loc['USSOCL1F', G] +AGFS.loc['L2F', G] = SAM.loc['L2F', G] + SAM.loc['USSOCL2F', G] +AGFS.loc['L3F', G] = SAM.loc['L3F', G] + SAM.loc['USSOCL3F', G] + +AGFS.loc['L1G', G] = SAM.loc['L1G', G] + SAM.loc['USSOCL1G', G] +AGFS.loc['L2G', G] = SAM.loc['L2G', G] + SAM.loc['USSOCL2G', G] +AGFS.loc['L3G', G] = SAM.loc['L3G', G] + SAM.loc['USSOCL3G', G] + +AGFS.loc['L1H', G] = SAM.loc['L1H', G] + SAM.loc['USSOCL1H', G] +AGFS.loc['L2H', G] = SAM.loc['L2H', G] + SAM.loc['USSOCL2H', G] +AGFS.loc['L3H', G] = SAM.loc['L3H', G] + SAM.loc['USSOCL3H', G] + +# AG - GOVERNMENT SPENDING SHARES OF NET INCOME +AG_1 = SAM.loc[I, G] +AG_2 = SAM.loc[I, G].sum(0) + SAM.loc[F, G].sum(0) + SAM.loc[GF, G].sum(0) +AG.loc[I, G] = AG_1 / AG_2 + +AG_1 = SAM.loc[F, G] +AG.loc[F, G] = AG_1 / AG_2 + +AG_1 = AGFS.loc[L, G] +AG.loc[L, G] = AG_1 / AG_2 +AG = AG.fillna(0.0) + +# TRADE INTERMEDIATES CONSUMPTION INVESTMENT INITIAL LEVELS + +# REAL EXPORT CONSUMPTION +CX0.loc[I] = SAM.loc[I, ["ROW"]].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index').sum(1) + +# REAL IMPORTS +M01.loc[I] = SAM.loc[["ROW"], I].sum(0) / PWM0[I].T + +M0.loc[IP] = SAM.loc[IP, Z].sum(1) - (B1.loc[I, IP].sum(0) + SAM.loc[F, IP].sum(0) + SAM.loc[G, IP].sum(0)) + +M0.loc[I] = (M0[I] / PWM0[I]) +M0 = M0.fillna(0.0) + +# * REAL INTERMEDIATE DEMAND +V0.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] / (1.0 + TAUQ.loc[GS, I].sum(0)) +V0T.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] + +# REAL PRIVATE CONSUMPTION +CH0.loc[I, H] = SAM.loc[I, H].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') + +CH0T.loc[I, H] = SAM.loc[I, H].div(P0[I], axis='index') + +CG0.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index').div((1.0 + TAUQ.loc[GS, I].sum(0)), axis='index') + +CG0T.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index') + +DEPR = float((SAM.loc[IG, ["INVES"]].sum(0)) / (KS0.loc[K, IG].sum(1).sum(0))) + +N0.loc[K, IG] = KS0.loc[K, IG] * DEPR + +# INVESTMENT BY SECTOR OF SOURCE +CN0.loc[I] = 0.0 + +B.loc[I, IG] = BB.loc[I, IG].fillna(0.0) + +CN0.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index').div( + 1.0 + TAUN.loc[GS, I].sum(0), axis='index').transpose() + +CN0T.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index') + +DD0.loc[I] = CH0.loc[I, H].sum(1) + CG0.loc[I, G].sum(1) + CN0.loc[I] + V0.loc[I] + +D0.loc[I] = 1.0 - M0.loc[I] / DD0.loc[I] + +# CORRECT IMPORT ELASTICITY TO DOMESTIC SHARE ELASTICITY +ETAD.loc[I] = -1.0 * ETAM.loc[I] * M0.loc[I] / (DD0.loc[I] * D0.loc[I]) + +# PRODUCTION DATA +DS0.loc[I] = DD0.loc[I] + CX0.loc[I] - M0.loc[I] + +AD.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') / DS0.loc[I] + +V10.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') + +PVA0.loc[I] = PD0.loc[I] - ( + AD.loc[I, I].mul(P0.loc[I], axis='index').mul(1.0 + TAUQ.loc[GS, I].sum(0).T, axis='index').sum(0).T) + +# AVERAGE RENTAL RATES FOR FACTORS (NORMALIZED) +RA0.loc[F] = 1.0 + +# CALIBRATION OF PRODUCTION EXPONENTS FOR COBB DOUGLAS +# a = pd.Series(index=I, dtype=float).fillna(0.0) +# a = SAM.loc[GFUS, I].append(a, ignore_index=True).append(SAM.loc[GL, I]) # labor, capital +a = SAM.loc['MEMPROPTAX', I] + SAM.loc['OTHERPROPTAX', I] +a = SAM.loc[GFUS, I].append(a, ignore_index=True) # labor, capital +a.index = F + +ALPHA.loc[F, I] = (SAM.loc[F, I] + a.loc[F, I]) / (SAM.loc[F, I].sum(0) + SAM.loc[GF, I].sum(0)) +ALPHA.loc[F, I] = ALPHA.loc[F, I] / ALPHA.loc[F, I].sum(0) + +ACK = pd.Series(index=I, dtype=float).fillna(0.0) +ACK.loc[I] = SAM.loc[F, I].sum(0) + +# Cobb-Douglas Technology Parameter; replace takes care of multiplying by zeros, by changing zeros to ones. +# DELTA.loc[I] = DS0.loc[I] / (FD0.loc[F, I] ** ALPHA.loc[F, I]).replace({0: 1}).product(0) + +# CES Production Function +SIGMA.loc[I] = 0.67 +RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] + +TESTA1.loc[F, I] = 0.0 + +TESTA1.loc[F, I] = R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( + FD0.loc[F, I] ** (1 - RHO.loc[I])) + +TESTA2_pre = (R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( + FD0.loc[F, I] ** (1 - RHO.loc[I]))).sum(0) +TESTA2.loc[F, I] = 1 +TESTA2.loc[F, I] = TESTA2.loc[F, I] * TESTA2_pre + +TESTA3.loc[F, I] = TESTA1.loc[F, I] / TESTA2.loc[F, I] + +ALPHA.loc[F, I] = TESTA3.loc[F, I] + +# add THETA to make FDEQ work +THETA = ALPHA.where(ALPHA == 0, 1) + +ATEST1 = pd.Series(index=I, dtype=float).fillna(0.0) +ATEST1.loc[I] = ALPHA.loc[F, I].sum(0) + +GAMMA.loc[I] = DS0.loc[I] / (((ALPHA.loc[F, I] * FD0.loc[F, I] ** (RHO.loc[I])).sum(0)) ** (1 / RHO.loc[I])) + +# OTHER DATA +# HH INVESTMENT INCOME FROM ROW +PRIVRET.loc[H] = SAM.loc[Z, H].sum(0) - (SAM.loc[H, F].sum(1) + SAM.loc[H, CM].sum(1) + SAM.loc[H, GX].sum(1)) + +PRIVRET.loc[H] = PRIVRET.loc[H] / HH0.loc[H] + +# TOTAL OUTPUT +Y0.loc[F] = SAM.loc[F, IG].sum(1) + +KPFOR01.loc[K] = SAM.loc[K, ["ROW"]].sum(1) + +# NOMINAL CAPITAL OUTFLOW +KPFOR0[K] = SAM.loc[Z, K].sum(0).T - SAM.loc[K, IG].sum(1) + +# NOMINAL GOVERNMENT OUTFLOWS +GVFOR0.loc[G] = SAM.loc[G, ["ROW"]].sum(1) +''' +GVFOR0.loc[GT] = SAM.loc[Z, GT].sum(0) - ( + SAM.loc[GT, I].sum(1) + + SAM.loc[GT, F].sum(1) + + SAM.loc[GT, H].sum(1) + + SAM.loc[GT, G].sum(1) + ) +''' + +# ORIGINAL EQUATION +A.loc[H, L] = SAM.loc[H, L].div(HW0.loc[H], axis='index') / ( + Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) + SAM.loc[L, ["ROW"]].sum(1)) + +A.loc[H, K] = SAM.loc[H, K].div(HW0.loc[H], axis='index') / ( + Y0.loc[K] + SAM.loc[Z, K].sum(0) - SAM.loc[K, IG].sum(1)) + +# HH TAXES OTHER THAN PIT +TAUH.loc[GH, H] = SAM.loc[GH, H].div(HH0.loc[H], axis='columns') + +S0.loc[H] = SAM.loc[["INVES"], H].T.sum(1) + +YD0.loc[H] = SAM.loc[I, H].sum(0).T + S0.loc[H] + +Y0.loc[G] = SAM.loc[G, Z].sum(1) - SAM.loc[G, ["ROW"]].sum(1) + +S0.loc[G] = SAM.loc[["INVES"], G].sum(0) + +# COMMUTING IN +CMI0.loc[L] = FD0.loc[L, IG].sum(1) - JOBCOR.loc[H, L].mul(HW0.loc[H], axis='index').sum(0) + +# COMMUTING OUT +CMO0.loc[["OUTCOM1"]] = 46206.0 +CMO0.loc[["OUTCOM2"]] = 24294.0 +CMO0.loc[["OUTCOM3"]] = 13514.0 + +# AVERAGE WAGE FLOWING INTO SHELBY +CMOWAGE.loc[CM] = SAM.loc[CM, ["ROW"]].sum(1).div(CMO0.loc[CM], axis='index').fillna(0.0) + +# AVERAGE WAGES FLOWING OUT OF SHELBY +CMIWAGE.loc[L] = (-1) * (SAM.loc[L, ["ROW"]].sum(1).div(CMI0.loc[L], axis='index').fillna(0.0)) + +# PROPORTION OF CAPITAL INCOME OUTFLOW +KFOR.loc[K] = KPFOR0.loc[K] / SAM.loc[["KAP"], IG].sum(1) + +# PROPORTION OF GOVERNMENT INCOME OUTFLOW +GFOR.loc[G] = GVFOR0.loc[G] / Y0.loc[G] + +A.loc[H, CM] = SAM.loc[H, CM].div(SAM.loc[Z, CM].sum(0), axis='columns') + +# NOMINAL NET CAPITAL INFLOW +NKI0 = (M0.loc[I] * PWM0.loc[I]).sum(0) - (CX0.loc[I] * PD0.loc[I]).sum(0) - \ + (PRIVRET.loc[H] * HH0.loc[H]).sum(0) - \ + KPFOR0.loc[K].sum(0) - GVFOR0.loc[G].sum(0) - \ + (CMOWAGE.loc[CM] * CMO0.loc[CM]).sum(0) - \ + (CMIWAGE.loc[L] * CMI0.loc[L]).sum(0) + +# REAL HH NET INCOME +Y0.loc[H] = (A.loc[H, L].mul(HW0[H], axis='index').div(A.loc[H, L].mul(HW0[H], axis='index').sum(0), axis='columns') \ + .mul(Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) - (CMIWAGE.loc[L] * CMI0.loc[L]), axis='columns')).sum(1) \ + + (A.loc[H, CM].mul((CMOWAGE.loc[CM] * CMO0.loc[CM]), axis='columns')).sum(1) \ + + (A.loc[H, K].mul(HW0[H], axis='index') / A.loc[H, K].mul(HW0[H], axis='index').sum(0) \ + * (Y0[K] * (1.0 - TAUFK.loc[G, K].sum(0)) + KPFOR0.loc[K])).sum(1) + +# PERSONAL INCOME OBJECTIVE FUNCTION +SPI0 = (Y0.loc[H].sum(0) + + TP.loc[H, G].mul(HH0.loc[H], axis='index').sum(1).sum(0) + + (PRIVRET[H] * HH0[H]).sum(0)) + +# PERSONAL INCOME TAX +PIT.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') + +PIT0.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') + +MI0.loc[H] = HH0.loc[H] * 0.04 + +MO0.loc[H] = HH0.loc[H] * 0.04 + +GCP0 = CH0.loc[I, H].sum(1).sum(0) + CN0.loc[I].sum(0) + CG0.loc[I, GN].sum(1).sum(0) + CX0.loc[I].sum(0) - M0.loc[ + I].sum(0) + +GCP10.loc[I] = CH0.loc[I, H].sum(1) + CN0.loc[I] + CG0.loc[I, GN].sum(1) + CX0.loc[I] + M0.loc[I] + +########################################### +# VARIABLE DECLARATION +########################################### + +vars = VarContainer() + +# PUBLIC CONSUMPTION +CG = vars.add('CG', rows=I, cols=G) + +# PRIVATE CONSUMPTION +CH = vars.add('CH', rows=I, cols=H) + +# COMMUTING IN +CMI = vars.add('CMI', rows=L) + +# COMMUTING OUT JASPER +CMO = vars.add('CMO', rows=CM) + +# GROSS INVESTMENT BY SECTOR OF SOURCE +CN = vars.add('CN', rows=I) + +# CONSUMER PRICE INDEX +CPI = vars.add('CPI', rows=H) + +# NONHOUSING CONSUMER PRICE INDEX +CPIN = vars.add('CPIN', rows=H) + +# HOUSING CONSUMER PRICE INDEX +CPIH = vars.add('CPIH', rows=H) + +# EXPORT DEMAND +CX = vars.add('CX', rows=I) + +# DOMESTIC SHARE OF DOMESTIC DEMAND +D = vars.add('D', rows=I) + +# DOMESTIC DEMAND +DD = vars.add('DD', rows=I) + +# DOMESTIC SUPPLY +DS = vars.add('DS', rows=I) + +# SECTORAL FACTOR DEMAND +# FD = vars.add('FD', rows=F, cols=Z) +FD = vars.add('FD', rows=F, cols=Z) + +# GROSS AGGREGATE CITY PRODUCT +GCP = vars.add('GCP') + +# GROSS CITY PRODUCT BY SECTOR +GCP1 = vars.add('GCP1', rows=I) + +# NUMBER OF HOUSEHOLDS +HH = vars.add('HH', rows=H) + +# NUMBER OF NONWORKING HOUSEHOLDS +HN = vars.add('HN', rows=H) + +# NUMBER OF WORKING HOUSEHOLDS +HW = vars.add('HW', rows=H) + +# INTER GOVERNMENTAL TRANSFERS +IGT = vars.add('IGT', rows=G, cols=GX) + +# CAPITAL FLOW +KS = vars.add('KS', rows=K, cols=IG) + +# IMPORTS +M = vars.add('M', rows=I) + +# GROSS INVESTMENT BY SECTOR OF DESTINATION +N = vars.add('N', rows=K, cols=IG) + +# NET CAPITAL INFLOW +NKI = vars.add('NKI') + +# CAPITAL OUTFLOW +KPFOR = vars.add('KPFOR', rows=K) + +# GOVT OUTFLOW +GVFOR = vars.add('GVFOR', rows=G) + +# AGGREGATE DOMESTIC PRICE PAID BY PURCHASERS +P = vars.add('P', rows=I) + +# DOMESTIC PRICE RECEIVED BY SUPPLIERS +PD = vars.add('PD', rows=I) + +# VALUE ADDED PRICE +PVA = vars.add('PVA', rows=I) + +# ECONOMY WIDE SCALAR RENTAL RATES OF FACTORS +RA = vars.add('RA', rows=F) + +# SECTORAL RENTAL RATES +R = vars.add('R', rows=F, cols=Z) + +# SAVINGS +S = vars.add('S', rows=Z) + +# PERSONAL INCOME (OBJECTIVE FUNCTION) +SPI = vars.add('SPI') + +# INTERMEDIATE GOODS +V = vars.add('V', rows=I) + +# additional variable +V1 = vars.add('V1', rows=I, cols=I) + +# GROSS INCOMES +Y = vars.add('Y', rows=Z) + +# additional variables +# Y1 = vars.add('Y1', rows=H) +# Y2 = vars.add('Y2', rows=H) +# Y3 = vars.add('Y3', rows=H) + +# AFTER TAX TOTAL HOUSEHOLD INCOMES +YD = vars.add('YD', rows=H) + +# GOV INCOME +# YT = vars.add('YT', rows=G, cols=G) + +# INITIALIZE VARIABLES FOR SOLVER + + +vars.init('CG', CG0.loc[I, G]) +vars.init('CH', CH0.loc[I, H]) +vars.init('CMI', CMI0.loc[L]) +vars.init('CMO', CMO0.loc[CM]) +vars.init('CN', CN0.loc[I]) +vars.init('CPI', CPI0.loc[H]) +vars.init('CPIN', CPIN0.loc[H]) +vars.init('CPIH', CPIH0.loc[H]) +vars.init('CX', CX0.loc[I]) +vars.init('D', D0.loc[I]) +vars.init('DD', DD0.loc[I]) +vars.init('DS', DS0.loc[I]) +vars.init('FD', FD0.loc[F, Z]) +vars.init('GCP', GCP0) +vars.init('GCP1', GCP10.loc[I]) +vars.init('HH', HH0.loc[H]) +vars.init('HN', HN0.loc[H]) +vars.init('HW', HW0.loc[H]) +vars.init('IGT', IGT0.loc[G, GX]) +vars.init('KS', KS0.loc[K, IG]) +# vars.init('LAS', LAS0.loc[LA, IG]) +vars.init('M', M0.loc[I]) +vars.init('N', N0.loc[K, IG]) +vars.init('NKI', NKI0) +# vars.init('LNFOR', LNFOR0.loc[LA]) +vars.init('KPFOR', KPFOR0.loc[K]) +vars.init('GVFOR', GVFOR0.loc[G]) +vars.init('P', P0.loc[I]) +vars.init('PD', PD0.loc[I]) +vars.init('PVA', PVA0.loc[I]) +vars.init('RA', RA0.loc[F]) +vars.init('R', R0.loc[F, Z]) +vars.init('S', S0.loc[Z]) +vars.init('SPI', SPI0) +vars.init('V', V0.loc[I]) +vars.init('V1', V10.loc[I, I]) +vars.init('Y', Y0.loc[Z]) +vars.init('YD', YD0.loc[H]) +# vars.init('YT') + + +# ------------------------------------------------------------------------------------------------------------- +# DEFINE BOUNDS FOR VARIABLES +# ------------------------------------------------------------------------------------------------------------- + +vars.lo('P', vars.get('P') / 1000) +vars.up('P', vars.get('P') * 1000) +vars.lo('PD', vars.get('PD') / 1000) +vars.up('PD', vars.get('PD') * 1000) +vars.lo('PVA', vars.get('PVA') / 1000) +vars.up('PVA', vars.get('PVA') * 1000) +vars.lo('RA', vars.get('RA') / 1000) +vars.up('RA', vars.get('RA') * 1000) +vars.lo('CPI', vars.get('CPI') / 1000) +vars.up('CPI', vars.get('CPI') * 1000) +vars.lo('CMI', vars.get('CMI') / 1000) +vars.up('CMI', vars.get('CMI') * 1000) +vars.lo('CMO', vars.get('CMO') / 1000) +vars.up('CMO', vars.get('CMO') * 1000) +vars.lo('DS', vars.get('DS') / 1000) +vars.up('DS', vars.get('DS') * 1000) +vars.lo('DD', vars.get('DD') / 1000) +vars.up('DD', vars.get('DD') * 1000) +vars.lo('D', vars.get('D') / 1000) +vars.up('D', vars.get('D') * 1000) +vars.lo('V', vars.get('V') / 1000) +vars.up('V', vars.get('V') * 1000) +vars.lo('FD', vars.get('FD') / 1000) +vars.up('FD', vars.get('FD') * 1000) +vars.lo('HH', vars.get('HH') / 1000) +vars.up('HH', vars.get('HH') * 1000) +vars.lo('HW', vars.get('HW') / 1000) +vars.up('HW', vars.get('HW') * 1000) +vars.lo('HN', vars.get('HN') / 1000) +vars.up('HN', vars.get('HN') * 1000) +vars.lo('KS', vars.get('KS') / 1000) +vars.up('KS', vars.get('KS') * 1000) +vars.lo('M', vars.get('M') / 1000) +vars.up('M', vars.get('M') * 1000) +vars.lo('Y', vars.get('Y') / 1000) +vars.up('Y', vars.get('Y') * 1000) +vars.lo('YD', vars.get('YD') / 1000) +vars.up('YD', vars.get('YD') * 1000) +vars.lo('CH', vars.get('CH') / 1000) +vars.up('CH', vars.get('CH') * 1000) +vars.lo('CG', vars.get('CG') / 1000) +vars.up('CG', vars.get('CG') * 1000) +vars.lo('CX', vars.get('CX') / 1000) +vars.up('CX', vars.get('CX') * 1000) +vars.lo('R', vars.get('R') / 1000) +vars.up('R', vars.get('R') * 1000) +vars.lo('N', 0) +vars.lo('CN', 0) + + +def set_variable(filname): + # clear the file before write the variables + with open(filename, 'w') as f: + f.write("") + + vars.write(filename) + + +# ------------------------------------------------------------------------------------------------------------- +# DEFINE EQUATIONS AND SET CONDITIONS +# ------------------------------------------------------------------------------------------------------------- + +def set_equation(filename): + count = [0] + + print('CPIEQ(H)') + line1 = (P.loc(I) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0)) * CH.loc(I, H)).sum(I) + line2 = (ExprM(vars, m=P0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0))) * CH.loc(I, H)).sum(I) + + CPIEQ = (line1 / line2 - ~CPI.loc(H)) + print(CPIEQ.test(vars.initialVals)) + CPIEQ.write(count, filename) + + + print('YEQ(H)') + line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * ( + Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * ExprM(vars, + m=CMIWAGE.loc[L]) * CMI.loc( + L))).sum(L) + line2 = (ExprM(vars, m=A.loc[H, CM]) * (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM))).sum(CM) + # line3 = (ExprM(vars, m= A.loc[H,LA]) * HW.loc(H) / (ExprM(vars, m= A.loc[H1,LA]) * HW.loc(H1)).sum(H1) * (Y.loc(LA) + LNFOR.loc(LA) ) * ExprM(vars, m= 1 - TAUFLA.loc[G,LA].sum(0))).sum(LA) + line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * ( + Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) + + YEQ = ((line1 + line2 + line4) - Y.loc(H)) + print(YEQ.test(vars.initialVals)) + YEQ.write(count, filename) + + print('YDEQ(H)') + line1 = Y.loc(H) + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)) + line2 = (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum(G) + line3 = ~(ExprM(vars, m=PIT0.loc[GI, H]) * Y.loc(H)).sum(GI) + line4 = ~(ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum(G) + + YDEQ = ((line1 + line2 - line3 - line4) - YD.loc(H)) + YDEQ.write(count, filename) + print(YDEQ.test(vars.initialVals)) + # print(YDEQ) + + print('CHEQ(I,H)') + line1 = ExprM(vars, m=CH0.loc[I, H]) * ( + (YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m= + BETA.loc[I, H]) + line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / ( + ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** ExprM(vars, m=LAMBDA.loc[ + J, I])).prod(0) + + CHEQ = ((line1 * line2) - CH.loc(I, H)) + CHEQ.write(count, filename) + print(CHEQ.test(vars.initialVals)) + # print(CHEQ) + print('SHEQ(H)') + line = YD.loc(H) - ~((P.loc(I) * CH.loc(I, H) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0))).sum(I)) + + SHEQ = (line - S.loc(H)) + SHEQ.write(count, filename) + print(SHEQ.test(vars.initialVals)) + # print(SHEQ) + + print('PVAEQ(I)') + line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) + + PVAEQ = (line - PVA.loc(I)) + PVAEQ.write(count, filename) + print(PVAEQ.test(vars.initialVals)) + # print(PVAEQ) + + # Cobb-Douglas + # PFEQ(I)..DS(I) =E= DELTA(I)*PROD(F$ALPHA(F,I),(TT(F,I)*FD(F,I))**ALPHA(F,I)) + # CES + # PFEQ(I)..DS(I) =E= GAMMA(I)*(SUM(F, ALPHA(F,I)*(FD(F,I)**(RHO(I)))))**(1/RHO(I)) + + print('PFEQ(I)') + line = ExprM(vars, m=GAMMA.loc[I]) * ( + (ExprM(vars, m=ALPHA.loc[F, I]) * (FD.loc(F, I) ** ExprM(vars, m=RHO.loc[I]))).sum(F)) ** ExprM(vars, + m=1 / RHO.loc[ + I]) + + PFEQ = (line - DS.loc(I)) + PFEQ.write(count, filename) + print(PFEQ.test(vars.initialVals)) + + # FD of CES + # FDEQ(F,I).. (R(F,I) * RA(F)*(1 + SUM(GF,TAUFX(GF,F,I))))* (FD(F,I)**(1-RHO(I))) + # =E= PVA(I)* ALPHA(F,I)*(GAMMA(I)**RHO(I))*(DS(I)**(1-RHO(I))) + print('FDEQ(F,I)') + left = (R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I])) * ( + FD.loc(F, I) ** ExprM(vars, m=1 - RHO.loc[I])) + right = ~(PVA.loc(I) * (ExprM(vars, m=ALPHA.loc[F, I] * (GAMMA.loc[I] ** RHO.loc[I])) * ( + DS.loc(I) ** ExprM(vars, m=1 - RHO.loc[I])))) + FDEQ = (right - left) + FDEQ.setCondition(FD0.loc[F, I], 'INEQ', 0) + + # FDEQ.test(vars.initialVals) + FDEQ.write(count, filename) + print(FDEQ.test(vars.initialVals)) + # print(FDEQ) + + # VEQ(I).. V(I) =E= SUM(J, AD(I,J) * DS(J) ) + print('VEQ(I)') + line = (ExprM(vars, m=AD.loc[I, J]) * ~DS.loc(J)).sum(1) + + VEQ = (line - V.loc(I)) + VEQ.write(count, filename) + print(VEQ.test(vars.initialVals)) + # print(VEQ) + + # YFEQL(F).. Y(F) =E= SUM(IG, R(F,IG) * RA(F)*FD(F,IG)) + print('YFEQL(L)') + line = (R.loc(F, IG) * RA.loc(F) * FD.loc(F, IG)).sum(IG) + + YFEQL = (line - Y.loc(F)) + YFEQL.write(count, filename) + print(YFEQL.test(vars.initialVals)) + # print(YFEQL) + + # KAPFOR(K).. KPFOR(K) =E= KFOR(K) * Y(K) + print('KAPFOR(K)') + line = ExprM(vars, m=KFOR.loc[K]) * Y.loc(K) + + KAPFOR = (line - KPFOR.loc(K)) + KAPFOR.write(count, filename) + print(KAPFOR.test(vars.initialVals)) + # print(KAPFOR) + + print('XEQ(I)') + line = ExprM(vars, m=CX0.loc[I]) * ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / ExprM(vars, + m=PW0.loc[I] * ( + 1 + + TAUQ.loc[ + GS, I].sum( + 0)))) ** ExprM( + vars, m=ETAE.loc[I]) + + XEQ = (line - CX.loc(I)) + XEQ.write(count, filename) + print(XEQ.test(vars.initialVals)) + # print(XEQ) + + # DEQ(I)$PWM0(I).. D(I) =E= D0(I) *(PD(I)/PWM0(I))**(ETAD(I)) + print('DEQ(I)$PWM0(I)') + line = ExprM(vars, m=D0.loc[I]) * (PD.loc(I) / ExprM(vars, m=PWM0.loc[I])) ** ExprM(vars, m=ETAD.loc[I]) + + DEQ = (line - D.loc(I)) + # DEQ.setCondition(PWM0.loc[I]) + DEQ.write(count, filename) + print(DEQ.test(vars.initialVals)) + # print(DEQ) + + # MEQ(I).. M(I) =E= ( 1 - D(I) ) * DD(I) + print('MEQ(I)') + line = (1 - D.loc(I)) * DD.loc(I) + + MEQ = (line - M.loc(I)) + MEQ.write(count, filename) + print(MEQ.test(vars.initialVals)) + # print(MEQ) + + # PEQ(I).. P(I) =E= D(I) * PD(I) + ( 1 - D(I) ) * PWM0(I) + print('PEQ(I)') + line = (D.loc(I) * PD.loc(I) + (1 - D.loc(I)) * ExprM(vars, m=PWM0.loc[I])) + + PEQ = (line - P.loc(I)) + PEQ.write(count, filename) + print(PEQ.test(vars.initialVals)) + + print('NKIEQ') + line1 = (M.loc(I) * ExprM(vars, m=PWM0.loc[I])).sum(I) + line2 = (CX.loc(I) * PD.loc(I)).sum(I) + line3 = (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + line5 = KPFOR.loc(K).sum(K) + line6 = GVFOR.loc(G).sum(G) + line7 = (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM)).sum(CM) + line8 = (ExprM(vars, m=CMIWAGE.loc[L]) * CMI.loc(L)).sum(L) + + NKIEQ = ((line1 - line2 - line3 - line5 - line6 - line7 - line8) - NKI) + NKIEQ.write(count, filename) + print(NKIEQ.test(vars.initialVals)) + # print(NKIEQ) + + # NEQ(K,I).. N(K,I) =E= N0(K,I)*(R(K,I)/R0(K,I))**(ETAIX(K,I)) + print('NEQ(K,I)') + line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** ExprM(vars, m=ETAIX.loc[K, I]) + + NEQ = (line - N.loc(K, I)) + NEQ.write(count, filename) + print(NEQ.test(vars.initialVals)) + # print(NEQ) + + # CNEQ(I).. P(I)*(1 + SUM(GS, TAUN(GS,I)))*CN(I) + # =E= SUM(IG, B(I,IG)*(SUM(K, N(K,IG)))) + print('CNEQ(I)') + left = P.loc(I) * ExprM(vars, m=1 + TAUN.loc[GS, I].sum(0)) * CN.loc(I) + right = (ExprM(vars, m=B.loc[I, IG]) * N.loc(K, IG).sum(K)).sum(IG) + + CNEQ = (right - left) + CNEQ.write(count, filename) + print(CNEQ.test(vars.initialVals)) + # print(CNEQ) + + # KSEQ(K,IG).. KS(K,IG) =E= KS0(K,IG) * ( 1 - DEPR) + N(K,IG) + print('KSEQ(K,IG)') + line = ExprM(vars, m=KS0.loc[K, IG] * (1 - DEPR)) + N.loc(K, IG) + + KSEQ = (line - KS.loc(K, IG)) + KSEQ.write(count, filename) + print(KSEQ.test(vars.initialVals)) + + print('LSEQ1(H)') + line1 = ExprM(vars, m=HW0.loc[H] / HH0.loc[H]) + LSEQ1line2pre = FD.loc(L, Z).sum(1) + line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) + * (LSEQ1line2pre.sum(0) / ( + (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum(CM) + CMI.loc( + L).sum(L))) + + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) + * (CMO.loc(CM).sum(CM) / ( + (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum( + CM) + CMI.loc(L).sum(L))))) ** ExprM(vars, m=ETARA.loc[H]) + line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / ( + ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) + line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + ( + ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) + / ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum( + G))) ** ExprM(vars, m=ETAPIT.loc[H]) + + LSEQ1 = ((line1 * line2 * line3 * line4) - HW.loc(H) / HH.loc(H)) + LSEQ1.write(count, filename) + print(LSEQ1.test(vars.initialVals)) + # print(LSEQ1) + + print('LSEQ2A') + line = ExprM(vars, m=CMO0.loc[CM1]) * ( + FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM1])) + + LSEQ2A = (line - CMO.loc(CM1)) + LSEQ2A.write(count, filename) + print(LSEQ2A.test(vars.initialVals)) + # print(LSEQ2A) + + print('LSEQ2B') + line = ExprM(vars, m=CMO0.loc[CM2]) * ( + FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM2])) + + LSEQ2B = (line - CMO.loc(CM2)) + LSEQ2B.write(count, filename) + print(LSEQ2B.test(vars.initialVals)) + + print('LSEQ2C') + line = ExprM(vars, m=CMO0.loc[CM3]) * ( + FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM3])) + + LSEQ2C = (line - CMO.loc(CM3)) + LSEQ2C.write(count, filename) + print(LSEQ2C.test(vars.initialVals)) + + print('LSEQ3') + line = ExprM(vars, m=CMI0.loc[L]) * ( + (FD.loc(L, FG).sum(FG) / ExprM(vars, m=FD0.loc[L, FG].sum(1))) ** (ExprM(vars, m=ECOMI.loc[L]))) + + LSEQ3 = (line - CMI.loc(L)) + LSEQ3.write(count, filename) + print(LSEQ3.test(vars.initialVals)) + + print('POPEQ(H)') + line1 = ExprM(vars, m=HH0.loc[H] * NRPG.loc[H]) + line2 = ExprM(vars, m=MI0.loc[H]) * ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / ( + CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) + line3 = ((HN.loc(H) / HH.loc(H)) / ExprM(vars, m=HN0.loc[H] / HH0.loc[H])) ** ExprM(vars, m=ETAU.loc[H]) + line4 = (CH.loc(HSD, H).sum(HSD) / ExprM(vars, m=CH0.loc[HSD, H].sum(0))) ** (1) + line5 = ExprM(vars, m=MO0.loc[H]) * (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / ( + ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) + line6 = (ExprM(vars, m=HN0.loc[H] / HH0.loc[H]) / (HN.loc(H) / HH.loc(H))) ** ExprM(vars, m=ETAU.loc[H]) + line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** (1) + + POPEQ = (line1 + line2 * line3 * line4 - line5 * line6 * line7 - HH.loc(H)) + POPEQ.write(count, filename) + print(POPEQ.test(vars.initialVals)) + + print('ANEQ(H)') + line = HH.loc(H) - HW.loc(H) + + ANEQ = (line - HN.loc(H)) + ANEQ.write(count, filename) + print(ANEQ.test(vars.initialVals)) + + print('YGEQ') + line1 = (ExprM(vars, m=TAUV.loc[GX, I]) * V.loc(I) * P.loc(I)).sum(I) + line2 = (ExprM(vars, m=TAUX.loc[GX, I]) * CX.loc(I) * PD.loc(I)).sum(I) + + YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) # first just set it to correct size + for label in GX: + for hlabel in H: + YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = Expr( + (ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) + + line3 = YGEQline3pre.sum(1) + line4 = (ExprM(vars, m=TAUN.loc[GX, I]) * CN.loc(I) * P.loc(I)).sum(I) + + YGEQline5pre = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) # first just set it to correct size + for label in GX: + YGEQline5pre.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) + line5 = YGEQline5pre + + line6 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) + for label in GX: + line6.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) + + line7 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) + for label in GX: + line7.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) + + line8 = (ExprM(vars, m=TAUFH.loc[GX, F]) * Y.loc(F)).sum(F) + line9 = (ExprM(vars, m=PIT0.loc[GX, H]) * Y.loc(H)).sum(H) + line10 = (ExprM(vars, m=TAUH.loc[GX, H]) * HH.loc(H)).sum(H) + line11 = IGT.loc(GX, GX1).sum(1) + + YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - Y.loc(GX)) + YGEQ.write(count, filename) + print(YGEQ.test(vars.initialVals)) + # print(YGEQ) + + print('YGEQ2(GT)') + line = IGT.loc(GT, GX).sum(GX) + + YGEQ2 = (line - Y.loc(GT)) + YGEQ2.write(count, filename) + print(YGEQ2.test(vars.initialVals)) + # print(YGEQ2) + + print('YGEQM(GNLM)') + line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) + + YGEQM = (line - Y.loc(GNLM)) + YGEQM.write(count, filename) + print(YGEQM.test(vars.initialVals)) + + print('YGEQO(GNLO)') + line = ExprM(vars, m=TAXS2.loc[GNLO]) * Y.loc(['CYGFO']) + + YGEQO = (line - Y.loc(GNLO)) + YGEQO.write(count, filename) + print(YGEQO.test(vars.initialVals)) + + print('GOVFOR(G)') + line = ExprM(vars, m=GFOR.loc[G]) * Y.loc(G) + + GOVFOR = (line - GVFOR.loc(G)) + GOVFOR.write(count, filename) + print(GOVFOR.test(vars.initialVals)) + + print('CGEQ(I,GN)') + left = P.loc(I) * ExprM(vars, m=1 + TAUG.loc[GS, I].sum(0)) * CG.loc(I, GN) + right = ExprM(vars, m=AG.loc[I, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) + + CGEQ = (right - left) + CGEQ.write(count, filename) + print(CGEQ.test(vars.initialVals)) + print('GFEQ(F,GN)') + + left = FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN])) + right = ExprM(vars, m=AG.loc[F, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) + + GFEQ = left - right + GFEQ.write(count, filename) + print(GFEQ.test(vars.initialVals)) + + print('GSEQL(GN)') + line1 = Y.loc(GN) + GVFOR.loc(GN) + line2 = (CG.loc(I, GN) * P.loc(I) * (1 + ExprM(vars, m=TAUG.loc[GS, I]).sum(GS))).sum(I) + line3 = (FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN]))).sum(F) + + GSEQL = ((line1 - ~line2 - ~line3) - S.loc(GN)) + GSEQL.write(count, filename) + print(GSEQL.test(vars.initialVals)) + + print('GSEQ(GX)') + line1 = (Y.loc(GX) + ExprM(vars, m=GFOR.loc[GX]) * Y.loc(GX)) + line2 = (ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H) + line3 = IGT.loc(G, GX).sum(G) + + GSEQ = ((line1 - ~line2 - ~line3) - S.loc(GX)) + GSEQ.write(count, filename) + print(GSEQ.test(vars.initialVals)) + + print('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') + line = ExprM(vars, m=TAXS.loc[G, GX]) * ( + Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) + + TDEQ = line - IGT.loc(G, GX) + TDEQ.setCondition(IGTD.loc[G, GX], 'EQ', 1) + TDEQ.write(count, filename) + print(TDEQ.test(vars.initialVals)) + print('SPIEQ') + line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + ( + ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + + SPIEQ = (line - SPI) + SPIEQ.write(count, filename) + print(SPIEQ.test(vars.initialVals)) + + print('LMEQ1(L)') + left = (ExprM(vars, m=JOBCOR.loc[H, L]) * HW.loc(H)).sum(H) + CMI.loc(L) + right = FD.loc(L, Z).sum(Z) + + LMEQ1 = (right - left) + LMEQ1.write(count, filename) + print(LMEQ1.test(vars.initialVals)) + + print('KMEQ(K,IG)') + KMEQ = ((ExprM(vars, m=TT.loc[K, IG]) * FD.loc(K, IG)) - KS.loc(K, IG)) + KMEQ.write(count, filename) + print(KMEQ.test(vars.initialVals)) + + print('GMEQ(I)') + GMEQ = (DD.loc(I) + CX.loc(I) - M.loc(I) - DS.loc(I)) + GMEQ.write(count, filename) + print(GMEQ.test(vars.initialVals)) + + print('DDEQ(I)') + DDEQ = (V.loc(I) + CH.loc(I, H).sum(H) + CG.loc(I, G).sum(G) + CN.loc(I) - DD.loc(I)) + DDEQ.write(count, filename) + print(DDEQ.test(vars.initialVals)) + + # MODEL CLOSURE + + # FIX INTER GOVERNMENTAL TRANSFERS TO ZERO IF NOT IN ORIGINAL SAM + print('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') + FX1 = IGT.loc(G, GX) + FX1.setCondition(IGT0.loc[G, GX], 'EQ', 0) + FX1.write(count, filename) + # print(FX1) + + # FIX EXOGENOUS INTERGOVERNMENTAL TRANSFERS + print('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') + FX2 = IGT.loc(G, GX) - ExprM(vars, m=IGT0.loc[G, GX]) + FX2.setCondition(IGTD.loc[G, GX], 'EQ', 2) + FX2.write(count, filename) + + # FIX INTER SECTORAL WAGE DIFFERENTIALS + print('R.FX(L,Z)=R0(L,Z)') + FX3 = R.loc(L, Z) - ExprM(vars, m=R0.loc[L, Z]) + FX3.write(count, filename) + + # FIX ECONOMY WIDE SCALAR + print('RA.FX(K)=RA0(K)') + FX4 = RA.loc(K) - ExprM(vars, m=RA0.loc[K]) + FX4.write(count, filename) + # print(FX5) + + print("Objective") + obj = vars.getIndex('SPI') + + with open(filename, 'a') as f: + f.write('model.obj = Objective(expr=-1*model.x' + str(obj) + ')') + + +def run_solver(cons_filename, temp_file_name="tmp.py"): + solver = 'ipopt' + solver_io = 'nl' + stream_solver = True # True prints solver output to screen + keepfiles = False # True prints intermediate file names (.nl,.sol,...) + opt = SolverFactory(solver, solver_io=solver_io) + + if opt is None: + print("") + print("ERROR: Unable to create solver plugin for %s " + "using the %s interface" % (solver, solver_io)) + print("") + exit(1) + + # Create the model + model = ConcreteModel() + set_variable(cons_filename) + set_equation(cons_filename) + + # read the model + exec(open(cons_filename).read()) + + # Declare all suffixes + + # Ipopt bound multipliers (obtained from solution) + model.ipopt_zL_out = Suffix(direction=Suffix.IMPORT) + model.ipopt_zU_out = Suffix(direction=Suffix.IMPORT) + + # Ipopt bound multipliers (sent to solver) + model.ipopt_zL_in = Suffix(direction=Suffix.EXPORT) + model.ipopt_zU_in = Suffix(direction=Suffix.EXPORT) + + # Obtain dual solutions from first solve and send to warm start + model.dual = Suffix(direction=Suffix.IMPORT_EXPORT) + + # opt.options['halt_on_ampl_error'] = 'yes' + # opt.options['acceptable_tol'] = '1e-3' + ### Send the model to ipopt and collect the solution + # results = opt.solve(model,keepfiles=keepfiles,tee=stream_solver) + + # IMPORT / IMPORT_EXPORT Suffix components) + # model.solutions.load_from(results) + + ### Set Ipopt options for warm-start + # The current values on the ipopt_zU_out and + # ipopt_zL_out suffixes will be used as initial + # conditions for the bound multipliers to solve + # the new problem + model.ipopt_zL_in.update(model.ipopt_zL_out) + model.ipopt_zU_in.update(model.ipopt_zU_out) + opt.options['warm_start_init_point'] = 'yes' + opt.options['warm_start_bound_push'] = 1e-6 + opt.options['warm_start_mult_bound_push'] = 1e-6 + opt.options['mu_init'] = 1e-6 + # opt.options['acceptable_tol'] = 10 + # opt.options['max_iter'] = 15 + # opt.options['compl_inf_tol'] = 1e-3 + # opt.options['bound_relax_factor'] = 0 + # opt.options['start_with_resto'] = 'yes' + # opt.options['acceptable_iter'] = 15 + # opt.options['halt_on_ampl_error'] = 'yes' + # opt.options['fixed_variable_treatment'] = 'relax_bounds' + # opt.options['print_options_documentation'] = 'yes' + + # Send the model and suffix information to ipopt and collect the solution + # The solver plugin will scan the model for all active suffixes + # valid for importing, which it will store into the results object + + results = opt.solve(model, keepfiles=keepfiles, tee=stream_solver) + + x = [None for i in range(vars.nvars)] + + with open(temp_file_name, 'w') as f: + for i in range(vars.nvars): + f.write('x[' + str(i) + ']=value(model.x' + str(i) + ')\n') + + exec(open(temp_file_name).read()) + + soln.append(x[:]) + + return None + + +''' +Calibrate the model +''' + +soln = [] +filename = os.path.join(filePath, "ipopt_cons.py") +tmp = os.path.join(filePath, "tmp.py") +print("Calibration: ") +run_solver(filename, tmp) + +''' +Simulation code below: +In each simulation: + +1. Apply simulation code (for instance PI(I) = 1.02). +2. Rewrite all equations +3. Solve the new model with the result from last run as initial guess. + +''' + +# begin shock on specific industries or household groups + +# begin shock by using tables + +# iNum = 1 # dynamic model itterations + +sims = pd.read_csv(os.path.join(filePath, 'SIMS 500.csv'), index_col=0) +iNum = 1 +KS00 = KS0.copy() + +for num in range(iNum): + # print("Simulation: ", num+1) + KS0.loc[K, I] = KS00.loc[K, I].mul(sims.iloc[:, num]) + run_solver(filename, tmp) + +# end shock by using tables + +exec(open(os.path.join(modelPath, "shelby_output.py")).read()) From 140e584db65331f93ca67ec56810cc032550cf68 Mon Sep 17 00:00:00 2001 From: Diego Calderon Date: Mon, 21 Feb 2022 16:48:27 -0600 Subject: [PATCH 2/8] second pass --- pyincore/analyses/shelbycge/{shelby => }/Equationlib.py | 0 .../analyses/shelbycge/{shelby => }/OutputFunctions.py | 0 pyincore/analyses/shelbycge/shelby/shelby/__init__.py | 0 pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py | 7 +++---- .../analyses/shelbycge/shelby_CES_September_21_2020.py | 7 +++---- pyincore/analyses/shelbycge/{shelby => }/shelby_output.py | 0 .../pipelinerestoration/test_pipelinerestoration.py | 2 +- 7 files changed, 7 insertions(+), 9 deletions(-) rename pyincore/analyses/shelbycge/{shelby => }/Equationlib.py (100%) rename pyincore/analyses/shelbycge/{shelby => }/OutputFunctions.py (100%) delete mode 100644 pyincore/analyses/shelbycge/shelby/shelby/__init__.py rename pyincore/analyses/shelbycge/{shelby => }/shelby_output.py (100%) diff --git a/pyincore/analyses/shelbycge/shelby/Equationlib.py b/pyincore/analyses/shelbycge/Equationlib.py similarity index 100% rename from pyincore/analyses/shelbycge/shelby/Equationlib.py rename to pyincore/analyses/shelbycge/Equationlib.py diff --git a/pyincore/analyses/shelbycge/shelby/OutputFunctions.py b/pyincore/analyses/shelbycge/OutputFunctions.py similarity index 100% rename from pyincore/analyses/shelbycge/shelby/OutputFunctions.py rename to pyincore/analyses/shelbycge/OutputFunctions.py diff --git a/pyincore/analyses/shelbycge/shelby/shelby/__init__.py b/pyincore/analyses/shelbycge/shelby/shelby/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py b/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py index dc79834fe..6a3652663 100755 --- a/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py +++ b/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py @@ -1,5 +1,4 @@ -from shelby.Equationlib import * -from shelby.OutputFunctions import * +from pyincore.analyses.shelbycge.Equationlib import * import os import pandas as pd from pyomo.environ import * @@ -15,8 +14,8 @@ def _(x): # ---------------------------------------------------------------- -modelPath = os.path.join(os.getcwd(), 'shelby') -filePath = os.path.join(modelPath, 'shelby') +modelPath = os.path.join(os.getcwd(), 'old') +filePath = os.path.join(modelPath, 'old') # filePath = './JOP_small/' diff --git a/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py b/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py index 9f4136047..74b01e06a 100755 --- a/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py +++ b/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py @@ -1,5 +1,4 @@ -from shelby.Equationlib import * -from shelby.OutputFunctions import * +from pyincore.analyses.shelbycge.Equationlib import * import os import pandas as pd from pyomo.environ import * @@ -11,8 +10,8 @@ def _(x): # set file paths -modelPath = os.path.join(os.getcwd(), 'shelby') -filePath = os.path.join(modelPath, 'shelby') +modelPath = os.path.join(os.getcwd(), 'old') +filePath = os.path.join(modelPath, 'old') # define sets diff --git a/pyincore/analyses/shelbycge/shelby/shelby_output.py b/pyincore/analyses/shelbycge/shelby_output.py similarity index 100% rename from pyincore/analyses/shelbycge/shelby/shelby_output.py rename to pyincore/analyses/shelbycge/shelby_output.py diff --git a/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py b/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py index a317c55e3..4d7f018b6 100644 --- a/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py +++ b/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py @@ -13,7 +13,7 @@ def run_with_base_class(): client.clear_cache() pipeline_restoration = PipelineRestoration(client) - # shelby county pipelines + # old county pipelines pipeline_restoration.load_remote_input_dataset("pipeline", "5a284f28c7d30d13bc081d14") pipeline_restoration.load_remote_input_dataset("pipeline_damage", "61f36023c53b3620b6b614c6") From 14354fc1aae680cfe641380990c11809a23cae96 Mon Sep 17 00:00:00 2001 From: Yong Wook Kim Date: Mon, 29 Aug 2022 09:17:04 -0500 Subject: [PATCH 3/8] merged develop --- .../analyses/pipelinerestoration/test_pipelinerestoration.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py b/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py index 4d7f018b6..a317c55e3 100644 --- a/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py +++ b/tests/pyincore/analyses/pipelinerestoration/test_pipelinerestoration.py @@ -13,7 +13,7 @@ def run_with_base_class(): client.clear_cache() pipeline_restoration = PipelineRestoration(client) - # old county pipelines + # shelby county pipelines pipeline_restoration.load_remote_input_dataset("pipeline", "5a284f28c7d30d13bc081d14") pipeline_restoration.load_remote_input_dataset("pipeline_damage", "61f36023c53b3620b6b614c6") From 50f759496cdcac5712da1c6703871cacb5ddfdb1 Mon Sep 17 00:00:00 2001 From: Yong Wook Kim Date: Tue, 30 Aug 2022 15:07:05 -0500 Subject: [PATCH 4/8] saving purpose --- .gitignore | 3 + pyincore/analyses/shelbycge/Equationlib.py | 806 ------ .../analyses/shelbycge/OutputFunctions.py | 73 - pyincore/analyses/shelbycge/README.md | 29 - pyincore/analyses/shelbycge/__init__.py | 8 + pyincore/analyses/shelbycge/environment.yaml | 388 --- pyincore/analyses/shelbycge/equationlib.py | 833 ++++++ .../shelbycge/files/data_insertion.txt | 0 .../shelbycge/shelby_CD_September_21_2020.py | 1866 ------------- .../shelbycge/shelby_CES_September_21_2020.py | 1907 ------------- pyincore/analyses/shelbycge/shelby_output.py | 211 -- pyincore/analyses/shelbycge/shelbycge.py | 2385 +++++++++++++++++ .../analyses/shelbycge/test_shelbycge.py | 37 + 13 files changed, 3266 insertions(+), 5280 deletions(-) delete mode 100755 pyincore/analyses/shelbycge/Equationlib.py delete mode 100755 pyincore/analyses/shelbycge/OutputFunctions.py delete mode 100755 pyincore/analyses/shelbycge/README.md delete mode 100644 pyincore/analyses/shelbycge/environment.yaml create mode 100755 pyincore/analyses/shelbycge/equationlib.py create mode 100644 pyincore/analyses/shelbycge/files/data_insertion.txt delete mode 100755 pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py delete mode 100755 pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py delete mode 100755 pyincore/analyses/shelbycge/shelby_output.py create mode 100644 pyincore/analyses/shelbycge/shelbycge.py create mode 100644 tests/pyincore/analyses/shelbycge/test_shelbycge.py diff --git a/.gitignore b/.gitignore index 73ca6886f..d570334ba 100644 --- a/.gitignore +++ b/.gitignore @@ -59,3 +59,6 @@ pyincore/analyses/seasidecge/solverconstants/tmp.py # credential *.incorepw +# test file +*_test.py + diff --git a/pyincore/analyses/shelbycge/Equationlib.py b/pyincore/analyses/shelbycge/Equationlib.py deleted file mode 100755 index 42fb37a12..000000000 --- a/pyincore/analyses/shelbycge/Equationlib.py +++ /dev/null @@ -1,806 +0,0 @@ -from copy import deepcopy -import pandas as pd -import operator as op -import math - - -class VarContainer: - """ - All matrix variable(tables) in the GAMS model is flatten to a array to make a better - interface to the solver. - - AllVarList stores all initial values of varibles used in the GAMS model in an array. - It also has a indexing system for looking up. - - Attributes: - namelist: A dictionary with all stored GAMS variables and its information. - nvars: The length of the array, i.e. the size of all matrix variables summed up. - initialVals: Stored initial values of all variables - - """ - - def __init__(self): - """ - Initialize to an empty list - """ - self.namelist = {} - self.initialVals = [] - self.nvars = 0 - self.LO = [] - self.UP = [] - - def add(self, name, rows=None, cols=None): - """ - :param name: - :param rows: - :param cols: - :return: - """ - if rows is not None and cols is not None: - size = len(rows) * len(cols) - self.namelist[name] = { - 'nrows': len(rows), - 'ncols': len(cols), - 'rows': rows, - 'cols': cols, - 'start': self.nvars, - 'size': size - } - elif rows is not None and cols is None: - size = len(rows) - self.namelist[name] = { - 'nrows': len(rows), - 'rows': rows, - 'start': self.nvars, - 'size': size - } - else: - size = 1 - self.namelist[name] = {'start': self.nvars, 'size': 1} - - self.initialVals.extend([None] * size) - self.LO.extend([None] * size) - self.UP.extend([None] * size) - self.nvars += size - - return ExprM(self, name=name, rows=rows, cols=cols) - - def set_value(self, name, values, target): - """ - An internal method for setting the initial values or UPs and LOs for variables - - :param name: Name of the variable in GAMS - :param value: a pandas DataFrame, pandas Series, int or float with initial values - :param target: target array to be set - - :return: None - """ - if type(values) == int or type(values) == float: - info = self.namelist[name] - if 'nrows' in info and 'ncols' in info: - values = pd.DataFrame(index=info['rows'], columns=info['cols']).fillna(values) - elif 'nrows' in info and 'ncols' not in info: - values = pd.Series(index=info['rows']).fillna(values) - - if type(values) == pd.DataFrame: - rows = values.index.tolist() - cols = values.columns.tolist() - for i in rows: - for j in cols: - target[self.getIndex(name, row=i, col=j)] = float(values.loc[i][j]) - elif type(values) == pd.Series: - rows = values.index.tolist() - for i in rows: - target[self.getIndex(name, row=i)] = float(values.loc[i]) - else: - target[self.getIndex(name)] = values - - def init(self, name, initialValue): - """ - Flatten the table variable and add to the list. - Also set the initial variable values array. - - :param name: Name of the variable in GAMS - :param initialValue: a pandas DataFrame or pandas Series with initial values - - :return: None. - """ - self.set_value(name, initialValue, self.initialVals) - - def inList(self, name): - """ - Check if a GAMS varible is added to the container - - :param name(str): name of GAMS variable you want to look up - :return: Boolean, whether the variable is added. - """ - return name in self.namelist - - def getInfo(self, name): - """ - Get the information about a GAMS variable - - :param name(str): name of GAMS variable you want to look up - :return: a dictionary with all information - """ - return self.namelist[name] - - def getIndex(self, name, row=None, col=None): - """ - Look up the index by providing the variable name and label information - - :param name: name of GAMS variable you want to look up - :param row: row label of the position you want to look up index for(if it has row labels) - :param col: column label of the position you want to look up index for(if it has column labels) - :return: the index of the position in the array - """ - info = self.namelist[name] - result = info['start'] - if row is not None and col is not None: - result += info['rows'].index(row) * info['ncols'] + info['cols'].index(col) - elif row is not None: - result += info['rows'].index(row) - return result - - def getLabel(self, index): - """ - Look up variable name and label information by providing the index - - :param index: the index in the array - :return: its information including the variable name, row label and column label if applicable - """ - result = [] - for i in self.namelist.keys(): - if index >= self.namelist[i]['start'] and index < self.namelist[i]['start'] + self.namelist[i]['size']: - result.append(i) - if self.namelist[i]['size'] > 1: - diff = index - self.namelist[i]['start'] - if 'ncols' in self.namelist[i]: - result.append(self.namelist[i]['rows'][int(diff / self.namelist[i]['ncols'])]) - result.append(self.namelist[i]['cols'][diff % self.namelist[i]['ncols']]) - else: - result.append(self.namelist[i]['rows'][diff]) - return result - - def get_all_variable_printed(self, output=None): - if output is None: - output = self.initialVals - for i in range(len(output)): - label = self.getLabel(i) - if len(label) == 1: - print(label[0] + '=' + '{0:.7f}'.format(output[i]) + ';') - elif len(label) == 2: - print(label[0] + '(\'' + label[1] + '\')' + '=' + '{0:.7f}'.format(output[i]) + ';') - elif len(label) == 3: - print( - label[0] + '(\'' + label[1] + '\',\'' + label[2] + '\')' + '=' + '{0:.7f}'.format(output[i]) + ';') - - def get(self, name, x=None): - """ - Returns a Dataframe, Series, or a variable based on the given name and the result array returned from the solver - - :param name: GAMS variable name - :return: if x is not given, it returns the initial values - if x is set to the result, returns the result variable value - """ - if x is None: - x = self.initialVals - - info = self.namelist[name] - if 'nrows' in info and 'ncols' in info: - ret = pd.DataFrame(index=info['rows'], columns=info['cols']).fillna(0.0) - for i in info['rows']: - for j in info['cols']: - ret.at[i, j] = x[self.getIndex(name, row=i, col=j)] - elif 'nrows' in info and 'ncols' not in info: - ret = pd.Series(index=info['rows']).fillna(0.0) - for i in info['rows']: - ret.at[i] = x[self.getIndex(name, row=i)] - elif 'nrows' not in info and 'ncols' not in info: - ret = x[self.getIndex(name)] - - return ret - - def lo(self, name, value): - """ - Set the LOs of a GAMS variable providing the LOs with a Dataframe, Series, int or float - - :param name: GAMS variable name - :param value: The lower bound to be set - :return: None - """ - self.set_value(name, value, self.LO) - - def up(self, name, value): - """ - Set the UPs of a GAMS variable providing the LOs with a Dataframe, Series, int or float - - :param name: GAMS variable name - :param value: The upper bound to be set - :return: None - """ - self.set_value(name, value, self.UP) - - def write(self, filename): - """ - Write(append) the variables to a file, in the format of setting ipopt model variables - - :param filename: the output filename - :return: None - """ - with open(filename, 'a') as f: - for i in range(self.nvars): - lower = -1e20 if self.LO[i] == None else self.LO[i] - upper = 1e20 if self.UP[i] == None else self.UP[i] - value = 0 if math.isnan(self.initialVals[i]) else self.initialVals[i] - - f.write('model.x' + str(i) + ' = Var(bounds=(' + str(lower) + ',' + str(upper) + '),initialize=' + str( - value) + ')' + '\n') - - -class variable: - """ - A GMAS variable, initialized by given the GAMS variable value and its label - """ - - def __init__(self, vars, name, row=None, col=None): - """ - Initialize it with a variable container, the GAMS name, the labels - - :param vars: the variable container that already added the GAMS variable - :param name: GAMS variable name - :param row: GAMS row label if there is - :param col: GAMS col label if there is - :return: None - """ - try: - self.index = vars.getIndex(name, row, col) - except Exception as e: - print(e) - - def __str__(self): - """ - returns the variable in the format of "model.x#" if gets printed, - with # being the index in the array in the container - - :return: String - """ - return 'model.x' + str(self.index) + '' - - def debug_test_str(self): - return 'x[' + str(self.index) + ']' - - -class ExprItem: - """ - You can construct it with a variable, a constant or a deepcopy of another ExprItem - """ - - def __init__(self, v, const=1): - self.varList = [] - self.const = const - if type(v) == variable: - self.varList.append(v) - elif type(v) == int or type(v) == float: - self.const = v - elif type(v) == ExprItem: - self.const = deepcopy(v.const) - self.varList = deepcopy(v.varList) - else: - print("invalid parameter to create a item") - - ''' - You could multiply it with a number, a variable, a ExprItem or Expression - ''' - - def __mul__(self, rhs): - copy = ExprItem(self) - if type(rhs) == int or type(rhs) == float: - copy.const = copy.const * rhs - elif type(rhs) == variable: - copy.varList.append(rhs) - elif type(rhs) == ExprItem: - copy.const *= rhs.const - copy.varList.extend(deepcopy(rhs.varList)) - elif type(rhs) == Expr: - if rhs.isComposite: - if rhs.operator == '/': - return rhs * copy - else: - copy.varList.append(Expr(rhs)) - else: - copyrhs = Expr(rhs) - copyrhs.itemList = [i * copy for i in copyrhs.itemList] - return copyrhs - return copy - - def __str__(self): - result = '' + str(self.const) - for i in range(len(self.varList)): - result += "*" + self.varList[i].__str__() - return result - - def debug_test_str(self): - result = '' + str(self.const) - for i in range(len(self.varList)): - result += "*" + self.varList[i].debug_test_str() - return result - - def is_empty(self): - if abs(self.const) < 0.00000001: - return True - else: - return False - - def is_one(self): - if abs(self.const - 1) < 0.0000001 and len(self.varList) == 0: - return True - else: - return False - - -class Expr: - - def __init__(self, item): - self.itemList = [] - self.isComposite = False - if type(item) == ExprItem or type(item) == variable or type(item) == int or type(item) == float: - self.itemList.append(ExprItem(item)) - elif type(item) == Expr: - self.itemList = [ - ExprItem(item.itemList[i]) if type(item.itemList[i]) == ExprItem else Expr(item.itemList[i]) for i in - range(len(item.itemList))] - try: - self.isComposite = deepcopy(item.isComposite) - except Exception as e: - pass - try: - self.operator = deepcopy(item.operator) - except Exception as e: - pass - try: - self.first = Expr(item.first) - except Exception as e: - pass - try: - self.second = Expr(item.second) - except Exception as e: - pass - else: - print("invalid parameter for creating a Expr") - - self.clear_empty() - - def __add__(self, rhs): - copy = Expr(self) - if self.isComposite: - tmp = Expr(self) - copy.itemList = [tmp] - copy.isComposite = False - if type(rhs) == Expr: - if rhs.isComposite: - rhscopy = Expr(rhs) - copy.itemList.append(rhscopy) - else: - rhscopy = Expr(rhs) - copy.itemList = copy.itemList + rhscopy.itemList - elif type(rhs) == ExprItem or type(rhs) == int or type(rhs) == float or type(rhs) == variable: - copy.itemList.append(ExprItem(rhs)) - return copy - - def __sub__(self, rhs): - copy = Expr(self) - return copy + rhs * -1 - - def __mul__(self, rhs): - copy = Expr(self) - if type(rhs) == int or type(rhs) == float or type(rhs) == ExprItem: - if copy.isComposite: - if copy.operator == '/': - copy.first = copy.first * rhs - elif copy.opeartor == '**': - return ExprItem(rhs) * copy - else: - result = [] - for i in copy.itemList: - result.append(i * rhs) - copy.itemList = result - - elif type(rhs) == Expr: - if copy.isComposite and not rhs.isComposite: - if copy.operator == '/': - copy.first = copy.first * rhs - else: - copy.itemList = [i * copy for i in rhs.itemList] - copy.isComposite = False - elif not copy.isComposite and not rhs.isComposite: - if len(copy.itemList) * len(rhs.itemList) > 10: - - tmpItem = ExprItem(1) - tmpItem.varList.append(Expr(copy)) - tmpItem.varList.append(Expr(rhs)) - copy.itemList = [tmpItem] - else: - - # The expanding way is super slow for long equations - result = [] - for i in copy.itemList: - for j in rhs.itemList: - if type(i) == Expr: - tmp = Expr(i) - elif type(i) == ExprItem: - tmp = ExprItem(i) - result.append(tmp * j) - copy.itemList = result - - elif not self.isComposite and rhs.isComposite: - return rhs * copy - else: - # both are composite - if copy.operator == '/' and rhs.operator == '/': - copy.first = copy.first * rhs.first - copy.second = copy.second * rhs.second - elif copy.operator == '**' and rhs.operator == '**': - copy.first = copy.first * rhs.first - copy.second = copy.second + rhs.second - elif copy.operator == '/' and rhs.operator == '**': - copy.first = copy.first * rhs - elif copy.operator == '**' and rhs.operator == '/': - copyrhs = Expr(rhs) - copyrhs.first = copyrhs.first * copy - return copy - - def __truediv__(self, rhs): - copy = Expr(self) - tmp = Expr(copy) - copy.isComposite = True - copy.operator = '/' - copy.first = tmp - copy.second = Expr(rhs) - return copy - - def __pow__(self, rhs): - copy = Expr(self) - tmp = Expr(copy) - copy.isComposite = True - copy.operator = '**' - copy.first = tmp - copy.second = Expr(rhs) - return copy - - def __str__(self): - if self.isComposite: - result = "(" + self.first.__str__() + self.operator + self.second.__str__() + ")" - else: - if len(self.itemList) == 0: - return '0' - result = '' - for i in self.itemList[0:-1]: - result += "(" + i.__str__() + ")" + "+" - result += "(" + self.itemList[-1].__str__() + ")" - if len(self.itemList) > 1: - result = "(" + result + ")" - return result - - def debug_test_str(self): - if self.isComposite: - result = "(" + self.first.debug_test_str() + self.operator + self.second.debug_test_str() + ")" - else: - if len(self.itemList) == 0: - return '0' - result = '' - for i in self.itemList[0:-1]: - result += "(" + i.debug_test_str() + ")" + "+" - result += "(" + self.itemList[-1].debug_test_str() + ")" - if len(self.itemList) > 1: - result = "(" + result + ")" - return result - - def is_empty(self): - if not self.isComposite and len(self.itemList) == 0: - return True - else: - return False - - def clear_empty(self): - result = [] - if self.isComposite == False: - for i in range(len(self.itemList)): - if type(self.itemList[i]) == ExprItem: - if not self.itemList[i].is_empty(): - result.append(self.itemList[i]) - if type(self.itemList[i]) == Expr: - self.itemList[i].clear_empty() - if not self.itemList[i].is_empty(): - result.append(self.itemList[i]) - self.itemList = result - - -class ExprM: - """ - Three ways to create a ExprMatrix: - 1. Give it the variable name, selected rows and cols(could be empty), - The constructor will create a Expression matrix from the variable matrix - 2. Give it a pandas Series or DataFrame, it will create the Expression matrix - with the content in the Series or DataFrame as constants - 3. Give it a ExprMatrix, will return a deep copy of it - """ - - def __init__(self, vars, name=None, rows=None, cols=None, m=None, em=None): - self.vars = vars - self.hasCondition = False - if em is None: - # if these are the variables, we need to create an Expression by the variable name - if name is not None: - if self.vars.inList(name): - self.info = deepcopy(self.vars.getInfo(name)) - else: - print("Can't find this variable in the all variable list") - - self.info['height'] = 1 - self.info['width'] = 1 - self.info['rows'] = deepcopy(rows) - self.info['cols'] = deepcopy(cols) - if cols is not None: - self.info['width'] = len(cols) - if rows is not None: - self.info['height'] = len(rows) - - if cols is not None: # if it is a DataFrame - self.m = [[Expr(variable(self.vars, name, i, j)) for j in cols] for i in rows] - elif rows is not None: # if it is a Series - self.m = [[Expr(variable(self.vars, name, i))] for i in rows] - else: # if it is a variable - self.m = [[Expr(variable(self.vars, name))]] - - # otherwise these are just constants - else: - self.info = {} - self.info['height'] = 1 - self.info['width'] = 1 - self.info['rows'] = None - self.info['cols'] = None - if type(m) == pd.DataFrame: - self.info['rows'] = m.index.tolist() - self.info['height'] = len(self.info['rows']) - self.info['cols'] = m.columns.tolist() - self.info['width'] = len(self.info['cols']) - self.m = [[Expr(float(m.loc[i, j])) for j in self.info['cols']] for i in self.info['rows']] - elif type(m) == pd.Series: - self.info['rows'] = m.index.tolist() - self.info['height'] = len(self.info['rows']) - self.m = [[Expr(float(m.loc[i]))] for i in self.info['rows']] - else: - self.m = [[Expr(float(m))]] - else: - # make deep copy - self.info = deepcopy(em.info) - self.m = [[Expr(em.m[i][j]) for j in range(em.info['width'])] for i in range(em.info['height'])] - - def operation(self, rhs, oper): - copy = ExprM(self.vars, em=self) - - if type(rhs) == int or type(rhs) == float: - for i in range(self.info['height']): - for j in range(self.info['width']): - copy.m[i][j] = oper(copy.m[i][j], Expr(rhs)) - - elif type(rhs) == pd.DataFrame or type(rhs) == pd.Series: - return self.operation(ExprM(self.vars, m=rhs), oper) - - elif type(rhs) == ExprM: - if copy.info['rows'] == rhs.info['rows'] and copy.info['cols'] == rhs.info['cols']: - # same size, apply operation element-wise - for i in range(self.info['height']): - for j in range(self.info['width']): - copy.m[i][j] = oper(copy.m[i][j], rhs.m[i][j]) - elif copy.info['rows'] == rhs.info['rows'] and copy.info['width'] == 1: - # for each column in rhs - result = [[Expr(0) for j in range(rhs.info['width'])] for i in range(self.info['height'])] - for i in range(self.info['height']): - for j in range(rhs.info['width']): - result[i][j] = oper(copy.m[i][0], rhs.m[i][j]) - copy.m = result - copy.info['width'] = rhs.info['width'] - copy.info['cols'] = deepcopy(rhs.info['cols']) - elif copy.info['rows'] == rhs.info['rows'] and rhs.info['width'] == 1: - # for each column in lhs - for i in range(self.info['height']): - for j in range(self.info['width']): - copy.m[i][j] = oper(copy.m[i][j], rhs.m[i][0]) - elif copy.info['height'] == 1 and copy.info['cols'] == rhs.info['cols']: - # for each row in rhs - result = [[Expr(0) for j in range(rhs.info['width'])] for i in range(rhs.info['height'])] - for i in range(rhs.info['height']): - for j in range(rhs.info['width']): - result[i][j] = oper(copy.m[0][j], rhs.m[i][j]) - copy.m = result - copy.info['height'] = rhs.info['height'] - copy.info['rows'] = deepcopy(rhs.info['rows']) - elif rhs.info['height'] == 1 and copy.info['cols'] == rhs.info['cols']: - # for each row in lhs - for i in range(self.info['height']): - for j in range(self.info['width']): - copy.m[i][j] = oper(copy.m[i][j], rhs.m[0][j]) - elif (self.info['width'] == rhs.info['height'] and self.info['cols'] == rhs.info['rows']) or \ - (self.info['height'] == rhs.info['width'] and self.info['rows'] == rhs.info['cols']): - # flip the matrix - return oper(self, ~rhs) - - else: - print(copy.info['rows'], copy.info['cols'], rhs.info['rows'], rhs.info['cols']) - print(copy.info['height'], copy.info['width'], rhs.info['height'], rhs.info['width']) - print("Invalid size for ", str(oper)) - return copy - - def __add__(self, rhs): - return self.operation(rhs, op.add) - - def __radd__(self, lhs): - return self + lhs - - def __sub__(self, rhs): - return self.operation(rhs, op.sub) - - def __rsub__(self, lhs): - return self * -1 + lhs - - def __mul__(self, rhs): - return self.operation(rhs, op.mul) - - def __truediv__(self, rhs): - return self.operation(rhs, op.truediv) - - def __pow__(self, rhs): - return self.operation(rhs, op.pow) - - def __xor__(self, rhs): - """ - create 2d list out of 2 single lists - """ - # has to be 2 single lists - if self.info['width'] != 1 or rhs.info['width'] != 1: - print("Invalid size for creating a 2-D matrix") - else: - copy = ExprM(self.vars, em=self) - copy.m = [[copy.m[i][0] * rhs.m[j][0] for j in range(rhs.info['height'])] for i in - range(copy.info['height'])] - copy.info['cols'] = deepcopy(rhs.info['rows']) - copy.info['width'] = deepcopy(rhs.info['height']) - return copy - - def __invert__(self): - """ - Return the transpose of a Expression matrix - """ - copy = ExprM(self.vars, em=self) - result = [[copy.m[i][j] for i in range(copy.info['height'])] for j in range(copy.info['width'])] - copy.info['height'], copy.info['width'] = copy.info['width'], copy.info['height'] - copy.info['rows'], copy.info['cols'] = copy.info['cols'], copy.info['rows'] - copy.m = result - return copy - - def __str__(self): - result = '' - for i in self.m: - for j in i: - result += j.__str__() + '\n' - result += '///////////////////\n' - return result - - def loc(self, rows=None, cols=None): - """ - get a subset of the matrix by labels - """ - copy = ExprM(self.vars, em=self) - if cols is not None: - result = [[Expr(copy.m[self.info['rows'].index(i)][self.info['cols'].index(j)]) for j in cols] for i in - rows] - copy.m = result - copy.info['rows'] = deepcopy(rows) - copy.info['height'] = len(copy.info['rows']) - copy.info['cols'] = deepcopy(cols) - copy.info['width'] = len(copy.info['cols']) - return copy - elif rows is not None: - result = [[Expr(copy.m[self.info['rows'].index(i)][0])] for i in rows] - copy.m = result - copy.info['rows'] = deepcopy(rows) - copy.info['height'] = len(copy.info['rows']) - return copy - else: - return copy - - def sum(self, label=None): - copy = ExprM(self.vars, em=self) - if label is None: - result = Expr(0) - for i in range(self.info['height']): - for j in range(self.info['width']): - result = result + copy.m[i][j] - copy.m = [[result]] - copy.info['width'] = 1 - copy.info['height'] = 1 - copy.info['rows'] = None - copy.info['cols'] = None - - elif label == self.info['rows'] or label == 0: - result = [[Expr(0) for j in range(self.info['width'])]] - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - result[0][j] = result[0][j] + copy.m[i][j] - copy.m = result - copy.info['height'] = 1 - copy.info['rows'] = None - - elif label == self.info['cols'] or label == 1: - result = [[Expr(0)] for i in range(self.info['height'])] - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - result[i][0] = result[i][0] + copy.m[i][j] - copy.m = result - copy.info['width'] = 1 - copy.info['cols'] = None - return copy - - def prod(self, label): - copy = ExprM(self.vars, em=self) - if label == self.info['rows'] or label == 0: - result = [[Expr(1) for j in range(self.info['width'])]] - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - result[0][j] = result[0][j] * copy.m[i][j] - copy.m = result - copy.info['height'] = 1 - copy.info['rows'] = None - elif label == self.info['cols'] or label == 1: - result = [[Expr(1)] for i in range(self.info['height'])] - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - result[i][0] = result[i][0] * copy.m[i][j] - copy.m = result - copy.info['width'] = 1 - copy.info['cols'] = None - return copy - - def setCondition(self, matrix, operator=None, value=None): - self.hasCondition = True - mappings = {'LT': op.lt, 'LE': op.le, 'EQ': op.eq, 'INEQ': op.ne} # not complete list - if type(matrix) == pd.DataFrame: - self.mark = [[False for j in range(self.info['width'])] for i in range(self.info['height'])] - for i in range(self.info['height']): - for j in range(self.info['width']): - if operator == None: - self.mark[i][j] = op.ne(matrix.loc[self.info['rows'][i]][self.info['cols'][j]], 0) - else: - self.mark[i][j] = mappings[operator](matrix.loc[self.info['rows'][i]][self.info['cols'][j]], - value) - - if type(matrix) == pd.Series: - self.mark = [[False] for i in range(self.info['height'])] - for i in range(self.info['height']): - if operator == None: - self.mark[i][0] = op.ne(matrix.loc[self.info['rows'][i]], 0) - else: - self.mark[i][0] = mappings[operator](matrix.loc[self.info['rows'][i]], value) - - def write(self, count, filename): - f = open(filename, 'a') - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - f.write( - 'model.equality' + str(count[0]) + ' = Constraint(expr=' + self.m[i][j].__str__() + ' == 0)\n') - count[0] += 1 - f.close() - - def test(self, x): - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - fun = lambda x: eval(self.m[i][j].debug_test_str()) - print(i, j, fun(x)) diff --git a/pyincore/analyses/shelbycge/OutputFunctions.py b/pyincore/analyses/shelbycge/OutputFunctions.py deleted file mode 100755 index 25b9f6ec7..000000000 --- a/pyincore/analyses/shelbycge/OutputFunctions.py +++ /dev/null @@ -1,73 +0,0 @@ -''' -functions for output validation - -# NOTE: -This is a hack to create dataframes that resemble matrix results -returned in GAMS -''' - -import shelby.Equationlib -import pandas as pd -import numpy as np - - -# Return initial values function -def baseValue(vars, soln, eqName): - if vars.getInfo(eqName)['size'] == 1: - basevalues = vars.initialVals[vars.getIndex(eqName)] - - else: - rows = vars.getInfo(eqName)['rows'] - rws = [] - if vars.getInfo(eqName)['size'] == vars.getInfo(eqName)['nrows']: - for rr in rows: - number = vars.initialVals[vars.getIndex(eqName, row=rr)] - rws.append(number) - basevalues = pd.DataFrame(rws, index=rows) - - else: - cols = vars.getInfo(eqName)['cols'] - for rr in rows: - clms = [] - for cc in cols: - number = vars.initialVals[vars.getIndex(eqName, row=rr, col=cc)] - clms.append(number) - rws.append(clms) - basevalues = pd.DataFrame(rws, index=rows, columns=cols) - - return basevalues - - -# Get the new values function -def newValue(vars, soln, eqName, ittr): - # for scalar - if vars.getInfo(eqName)['size'] == 1: - newvalue = soln[ittr][vars.getIndex(eqName)] - - else: - rows = vars.getInfo(eqName)['rows'] - rws = [] - # vectors - if vars.getInfo(eqName)['size'] == vars.getInfo(eqName)['nrows']: - for rr in rows: - number = soln[ittr][vars.getIndex(eqName, row=rr)] - rws.append(number) - newvalue = pd.DataFrame(rws, index=rows) - # data frames - else: - for rr in rows: - cols = vars.getInfo(eqName)['cols'] - clms = [] - for cc in cols: - number = soln[ittr][vars.getIndex(eqName, row=rr, col=cc)] - clms.append(number) - rws.append(clms) - newvalue = pd.DataFrame(rws, index=rows, columns=cols) - - return newvalue - - -# Get differences function -def getDiff(vars, soln, eqName, ittr): - difference = newValue(vars, soln, eqName, ittr) - baseValue(vars, soln, eqName) - return difference diff --git a/pyincore/analyses/shelbycge/README.md b/pyincore/analyses/shelbycge/README.md deleted file mode 100755 index d87da9616..000000000 --- a/pyincore/analyses/shelbycge/README.md +++ /dev/null @@ -1,29 +0,0 @@ -# NIST CGE - -## Python Models - -### Shelby - -There are two main scripts for Shelby: - -- **'shelby\_CD\_September\_21\_2020.py'**: This is the Shelby CGE model with Cobb-Douglas production function. - -- **'shelby\_CES\_September\_21\_2020.py'**: This is the Shelby CGE model with CES (Constant elasticity of substitution) production function. - -Both models are created and executed with `runsolver` at the bottom of the script. -Output form 'simulation\_outputs.csv' will be created on the same directory after running script. - -## Installation - -Anaconda or Miniconda are the preferred python3 package managers for this model. Download from [anaconda.com](https://www.anaconda.com/distribution/). Packages and documentation can be found at [conda-forge.org](https://conda-forge.org/) with installation instructions here: [docs.anaconda.com](https://docs.anaconda.com/anaconda/navigator/install/) - -After downloading one of the conda apps, the *environment.yaml* file can be used to build a python3 virtual environment with the correct dependencies. - -If conda is not an option, the bare-bones set of dependencies needed are: - -- ipopt -- numpy -- pandas -- pyomo - -ipopt is part of the COIN project and can be downloaded directly from [coin-or.org](https://projects.coin-or.org/Ipopt) or installed as a package from Anaconda Cloud. diff --git a/pyincore/analyses/shelbycge/__init__.py b/pyincore/analyses/shelbycge/__init__.py index e69de29bb..5be6f4570 100644 --- a/pyincore/analyses/shelbycge/__init__.py +++ b/pyincore/analyses/shelbycge/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) 2019 University of Illinois and others. All rights reserved. +# +# This program and the accompanying materials are made available under the +# terms of the Mozilla Public License v2.0 which accompanies this distribution, +# and is available at https://www.mozilla.org/en-US/MPL/2.0/ + + +from pyincore.analyses.shelbycge.shelbycge import ShelbyCGEModel diff --git a/pyincore/analyses/shelbycge/environment.yaml b/pyincore/analyses/shelbycge/environment.yaml deleted file mode 100644 index b9ad676d6..000000000 --- a/pyincore/analyses/shelbycge/environment.yaml +++ /dev/null @@ -1,388 +0,0 @@ -name: base -channels: - - conda-forge - - defaults -dependencies: - - _anaconda_depends=2020.07=py37_0 - - _ipyw_jlab_nb_ext_conf=0.1.0=py37_0 - - alabaster=0.7.12=py_0 - - anaconda=custom=py37_1 - - anaconda-client=1.7.2=py_0 - - anaconda-navigator=1.9.12=py37_0 - - anaconda-project=0.8.3=py_0 - - appdirs=1.4.3=py_1 - - applaunchservices=0.2.1=py_0 - - appnope=0.1.0=py37hc8dfbb8_1001 - - appscript=1.1.1=py37h9bfed18_0 - - argh=0.26.2=pyh9f0ad1d_1002 - - argon2-cffi=20.1.0=py37h60d8a13_1 - - asn1crypto=1.4.0=pyh9f0ad1d_0 - - astroid=2.4.2=py37hc8dfbb8_0 - - astropy=4.0.1.post1=py37h9bfed18_0 - - async_generator=1.10=py_0 - - atomicwrites=1.4.0=pyh9f0ad1d_0 - - attrs=20.2.0=pyh9f0ad1d_0 - - autopep8=1.4.4=py_0 - - babel=2.8.0=py_0 - - backcall=0.2.0=pyh9f0ad1d_0 - - backports=1.0=py_2 - - backports.functools_lru_cache=1.6.1=py_0 - - backports.shutil_get_terminal_size=1.0.0=py_3 - - beautifulsoup4=4.9.1=py_1 - - bitarray=1.5.3=py37h60d8a13_0 - - bkcharts=0.2=py37_0 - - blas=2.17=openblas - - bleach=3.2.1=pyh9f0ad1d_0 - - blosc=1.20.1=hb1e8313_0 - - bokeh=2.2.1=py37hc8dfbb8_0 - - boost-cpp=1.74.0=he5d75e3_0 - - boto=2.49.0=py_0 - - bottleneck=1.3.2=py37h10e2902_1 - - brotli=1.0.9=hb1e8313_0 - - brotlipy=0.7.0=py37h60d8a13_1000 - - brunsli=0.1=hb1e8313_0 - - bzip2=1.0.8=haf1e3a3_3 - - c-ares=1.16.1=haf1e3a3_3 - - ca-certificates=2020.6.20=hecda079_0 - - cairo=1.16.0=ha8983da_1005 - - certifi=2020.6.20=py37hc8dfbb8_0 - - cffi=1.14.3=py37hf5b7abd_0 - - cfitsio=3.470=hdf94aef_6 - - chardet=3.0.4=py37hc8dfbb8_1007 - - charls=2.1.0=h4a8c4bd_2 - - click=7.1.2=pyh9f0ad1d_0 - - click-plugins=1.1.1=py_0 - - cligj=0.5.0=py_0 - - cloudpickle=1.6.0=py_0 - - clyent=1.2.2=py_1 - - colorama=0.4.3=py_0 - - conda=4.8.5=py37hc8dfbb8_1 - - conda-build=3.20.2=py37hc8dfbb8_0 - - conda-env=2.6.0=1 - - conda-package-handling=1.7.0=py37h60d8a13_5 - - conda-verify=3.1.1=py37hc8dfbb8_1001 - - contextlib2=0.6.0.post1=py_0 - - cryptography=3.1=py37h94e4008_0 - - curl=7.71.1=hcb81553_6 - - cycler=0.10.0=py_2 - - cython=0.29.21=py37hdadc0f0_0 - - cytoolz=0.10.1=py37h0b31af3_0 - - dask=2.27.0=py_0 - - dask-core=2.27.0=py_0 - - dbus=1.13.6=h2f22bb5_0 - - decorator=4.4.2=py_0 - - defusedxml=0.6.0=py_0 - - diff-match-patch=20200713=pyh9f0ad1d_0 - - distributed=2.27.0=py37hc8dfbb8_0 - - docutils=0.16=py37hc8dfbb8_1 - - entrypoints=0.3=py37hc8dfbb8_1001 - - et_xmlfile=1.0.1=py_1001 - - expat=2.2.9=hb1e8313_2 - - fastcache=1.1.0=py37h9bfed18_1 - - filelock=3.0.12=pyh9f0ad1d_0 - - fiona=1.8.17=py37h8cd0b58_0 - - flake8=3.7.9=py37hc8dfbb8_1 - - flask=1.1.2=pyh9f0ad1d_0 - - fontconfig=2.13.1=h79c0d67_1002 - - freetype=2.10.2=h8da9a1a_0 - - freexl=1.0.5=h0b31af3_1002 - - fsspec=0.8.2=py_0 - - future=0.18.2=py37hc8dfbb8_1 - - gdal=3.1.2=py37h85de8e7_1 - - geopandas=0.8.1=py_0 - - geos=3.8.1=h4a8c4bd_0 - - geotiff=1.6.0=h4e9c399_1 - - get_terminal_size=1.0.0=h7520d66_0 - - gettext=0.19.8.1=h46ab8bc_1002 - - gevent=20.6.2=py37h9bfed18_0 - - giflib=5.2.1=h0b31af3_2 - - glib=2.66.0=hdb5fb44_0 - - glob2=0.7=py_0 - - gmp=6.2.0=hb1e8313_2 - - gmpy2=2.1.0b1=py37h4160ff4_0 - - greenlet=0.4.16=py37h9bfed18_0 - - h5py=2.10.0=nompi_py37h28defc4_104 - - hdf4=4.2.13=h84186c3_1003 - - hdf5=1.10.6=nompi_haae91d6_101 - - heapdict=1.0.1=py_0 - - html5lib=1.1=pyh9f0ad1d_0 - - icu=67.1=hb1e8313_0 - - idna=2.10=pyh9f0ad1d_0 - - imagecodecs=2020.5.30=py37h64a549b_2 - - imageio=2.9.0=py_0 - - imagesize=1.2.0=py_0 - - importlib-metadata=1.7.0=py37hc8dfbb8_0 - - importlib_metadata=1.7.0=0 - - iniconfig=1.0.1=pyh9f0ad1d_0 - - intel-openmp=2020.2=258 - - intervaltree=3.0.2=py_0 - - ipopt=3.13.2=he217970_0 - - ipykernel=5.3.4=py37h43977f1_0 - - ipython=7.18.1=py37hc6149b9_0 - - ipython_genutils=0.2.0=py_1 - - ipywidgets=7.5.1=pyh9f0ad1d_1 - - isort=5.5.3=py37hc8dfbb8_0 - - itsdangerous=1.1.0=py_0 - - jbig=2.1=h0b31af3_2002 - - jdcal=1.4.1=py_0 - - jedi=0.15.1=py37_0 - - jinja2=2.11.2=pyh9f0ad1d_0 - - joblib=0.16.0=py_0 - - jpeg=9d=h0b31af3_0 - - json-c=0.13.1=h575e443_1002 - - json5=0.9.5=pyh9f0ad1d_0 - - jsonschema=3.2.0=py37hc8dfbb8_1 - - jupyter=1.0.0=py_2 - - jupyter_client=6.1.7=py_0 - - jupyter_console=6.2.0=py_0 - - jupyter_core=4.6.3=py37hc8dfbb8_1 - - jupyterlab=2.2.8=py_0 - - jupyterlab_pygments=0.1.1=pyh9f0ad1d_0 - - jupyterlab_server=1.2.0=py_0 - - jxrlib=1.1=h0b31af3_2 - - kealib=1.4.13=h40102fb_1 - - keyring=21.4.0=py37hc8dfbb8_1 - - kiwisolver=1.2.0=py37ha1cc60f_0 - - krb5=1.17.1=h75d18d8_3 - - lazy-object-proxy=1.4.3=py37h9bfed18_2 - - lcms2=2.11=h174193d_0 - - lerc=2.2=hb1e8313_0 - - libaec=1.0.4=h4a8c4bd_1 - - libarchive=3.3.3=hf12134e_1008 - - libblas=3.8.0=17_openblas - - libcblas=3.8.0=17_openblas - - libclang=10.0.1=default_hf57f61e_1 - - libcurl=7.71.1=h9bf37e3_6 - - libcxx=10.0.1=h5f48129_0 - - libdap4=3.20.6=h993cace_1 - - libedit=3.1.20191231=h0678c8f_2 - - libev=4.33=haf1e3a3_1 - - libffi=3.2.1=hb1e8313_1007 - - libgdal=3.1.2=h6dfbaa8_1 - - libgfortran=4.0.0=h2d743fc_10 - - libgfortran4=7.5.0=h2d743fc_10 - - libiconv=1.16=haf1e3a3_0 - - libkml=1.3.0=h8ca2c65_1012 - - liblapack=3.8.0=17_openblas - - liblapacke=3.8.0=17_openblas - - liblief=0.10.1=hb1e8313_1 - - libllvm10=10.0.1=h009f743_3 - - libllvm9=9.0.1=h7475705_1 - - libnetcdf=4.7.4=nompi_hc5b2cf3_105 - - libnghttp2=1.41.0=h7580e61_2 - - libopenblas=0.3.10=openmp_h63d9170_4 - - libpng=1.6.37=hb0a8c7a_2 - - libpq=12.3=h489d428_0 - - libsodium=1.0.18=h01d97ff_0 - - libspatialindex=1.9.3=h4a8c4bd_3 - - libspatialite=4.3.0a=h231dce8_1039 - - libssh2=1.9.0=h8a08a2b_5 - - libtiff=4.1.0=h2ae36a8_6 - - libwebp-base=1.1.0=h0b31af3_3 - - libxml2=2.9.10=h2c6e4a5_2 - - libxslt=1.1.33=h29b7fa6_1 - - libzopfli=1.0.3=h4a8c4bd_0 - - llvm-openmp=10.0.1=h28b9765_0 - - llvmlite=0.34.0=py37h3986384_1 - - locket=0.2.0=py_2 - - lxml=4.5.2=py37heb1707f_0 - - lz4-c=1.9.2=hb1e8313_3 - - lzo=2.10=haf1e3a3_1000 - - markupsafe=1.1.1=py37h60d8a13_1 - - matplotlib=3.3.2=0 - - matplotlib-base=3.3.2=py37h886f89f_0 - - mccabe=0.6.1=py_1 - - metis=5.1.0=hb1e8313_1006 - - mistune=0.8.4=py37h9bfed18_1001 - - mkl=2020.2=260 - - mkl-service=2.3.0=py37h60d8a13_1 - - mkl_fft=1.2.0=py37h57c32b8_1 - - mkl_random=1.1.1=py37h570ac47_0 - - mock=4.0.2=py37hc8dfbb8_0 - - more-itertools=8.5.0=py_0 - - mpc=1.1.0=ha57cd0f_1009 - - mpfr=4.0.2=h72d8aaf_1 - - mpmath=1.1.0=py_0 - - msgpack-python=1.0.0=py37ha1cc60f_1 - - multipledispatch=0.6.0=py_0 - - munch=2.5.0=py_0 - - mysql-common=8.0.21=2 - - mysql-libs=8.0.21=hfb8f7af_2 - - navigator-updater=0.2.1=py37_0 - - nbclient=0.5.0=py_0 - - nbconvert=6.0.5=py37hc8dfbb8_0 - - nbformat=5.0.7=py_0 - - ncurses=6.2=hb1e8313_1 - - nest-asyncio=1.4.0=py_1 - - networkx=2.5=py_0 - - nltk=3.4.4=py_0 - - nose=1.3.7=py37hc8dfbb8_1004 - - notebook=6.1.4=py37hc8dfbb8_0 - - nspr=4.20=h0a44026_1000 - - nss=3.47=hc0980d9_0 - - numba=0.51.2=py37h6d0141a_0 - - numexpr=2.7.1=py37h94625e5_1 - - numpydoc=1.1.0=pyh9f0ad1d_0 - - olefile=0.46=py_0 - - openjpeg=2.3.1=h254dc36_3 - - openpyxl=3.0.5=py_0 - - openssl=1.1.1g=haf1e3a3_1 - - packaging=20.4=pyh9f0ad1d_0 - - pandas=1.1.2=py37hdadc0f0_0 - - pandoc=2.10.1=haf1e3a3_0 - - pandocfilters=1.4.2=py_1 - - parso=0.8.0=pyh9f0ad1d_0 - - partd=1.1.0=py_0 - - path=15.0.0=py37hc8dfbb8_0 - - path.py=12.5.0=0 - - pathlib2=2.3.5=py37hc8dfbb8_1 - - pathtools=0.1.2=py_1 - - patsy=0.5.1=py_0 - - pcre=8.44=h4a8c4bd_0 - - pep8=1.7.1=py_0 - - pexpect=4.8.0=py37hc8dfbb8_1 - - pickleshare=0.7.5=py37hc8dfbb8_1001 - - pillow=7.2.0=py37hfd78ece_1 - - pip=20.2.3=py_0 - - pixman=0.38.0=h01d97ff_1003 - - pkginfo=1.5.0.1=py_0 - - pluggy=0.13.1=py37hc8dfbb8_2 - - ply=3.11=py_1 - - poppler=0.89.0=h3232a60_1 - - poppler-data=0.4.9=1 - - postgresql=12.3=h62ab893_0 - - proj=7.1.0=h45baca5_1 - - prometheus_client=0.8.0=pyh9f0ad1d_0 - - prompt-toolkit=3.0.7=py_0 - - prompt_toolkit=3.0.7=0 - - psutil=5.7.2=py37h60d8a13_0 - - ptyprocess=0.6.0=py_1001 - - py=1.9.0=pyh9f0ad1d_0 - - py-lief=0.10.1=py37hdadc0f0_1 - - pycodestyle=2.5.0=py37_0 - - pycosat=0.6.3=py37h60d8a13_1004 - - pycparser=2.20=pyh9f0ad1d_2 - - pycrypto=2.6.1=py37h9bfed18_1004 - - pycurl=7.43.0.5=py37h7d0efee_2 - - pydocstyle=5.1.1=py_0 - - pyflakes=2.1.1=py37_0 - - pygments=2.7.1=py_0 - - pylint=2.6.0=py37hc8dfbb8_0 - - pyodbc=4.0.30=py37h4a8c4bd_0 - - pyomo=5.7.1=py37hdadc0f0_0 - - pyopenssl=19.1.0=py_1 - - pyparsing=2.4.7=pyh9f0ad1d_0 - - pyproj=2.6.1.post1=py37h05a9fa5_1 - - pyqt=5.12.3=py37ha62fc16_3 - - pyrsistent=0.17.3=py37h60d8a13_0 - - pysocks=1.7.1=py37hc8dfbb8_1 - - pytables=3.6.1=py37he7827f7_2 - - pytest=6.0.2=py37hc8dfbb8_0 - - python=3.7.8=hc9dea61_1_cpython - - python-dateutil=2.8.1=py_0 - - python-jsonrpc-server=0.3.4=pyh9f0ad1d_1 - - python-language-server=0.31.10=py37_0 - - python-libarchive-c=2.9=py37hc8dfbb8_0 - - python.app=1.3=py37h9bfed18_1 - - python_abi=3.7=1_cp37m - - pytz=2020.1=pyh9f0ad1d_0 - - pyutilib=6.0.0=pyh9f0ad1d_0 - - pywavelets=1.1.1=py37h57c32b8_2 - - pyyaml=5.3.1=py37h60d8a13_0 - - pyzmq=19.0.2=py37hf1e22d8_0 - - qdarkstyle=2.8.1=pyh9f0ad1d_1 - - qt=5.12.9=h717870c_0 - - qtawesome=0.7.2=pyh9f0ad1d_0 - - qtconsole=4.7.7=pyh9f0ad1d_0 - - qtpy=1.9.0=py_0 - - readline=8.0=h0678c8f_2 - - regex=2020.7.14=py37h60d8a13_0 - - requests=2.24.0=pyh9f0ad1d_0 - - ripgrep=12.1.1=h0b31af3_0 - - rope=0.17.0=pyh9f0ad1d_0 - - rtree=0.9.4=py37h8526d28_1 - - ruamel_yaml=0.15.80=py37h60d8a13_1002 - - scikit-image=0.17.2=py37h6d0141a_2 - - scikit-learn=0.23.2=py37hb7e9fed_0 - - scipy=1.5.2=py37h2702c91_0 - - seaborn=0.11.0=0 - - seaborn-base=0.11.0=py_0 - - send2trash=1.5.0=py_0 - - shapely=1.7.1=py37h40e7c26_0 - - simplegeneric=0.8.1=py_1 - - singledispatch=3.4.0.3=py37_1000 - - sip=4.19.24=py37hdadc0f0_0 - - six=1.15.0=pyh9f0ad1d_0 - - snappy=1.1.8=hb1e8313_3 - - snowballstemmer=2.0.0=py_0 - - sortedcollections=1.2.1=pyh9f0ad1d_0 - - sortedcontainers=2.2.2=pyh9f0ad1d_0 - - soupsieve=2.0.1=py_1 - - sphinx=3.2.1=py_0 - - sphinxcontrib=1.0=py37_1 - - sphinxcontrib-applehelp=1.0.2=py_0 - - sphinxcontrib-devhelp=1.0.2=py_0 - - sphinxcontrib-htmlhelp=1.0.3=py_0 - - sphinxcontrib-jsmath=1.0.1=py_0 - - sphinxcontrib-qthelp=1.0.3=py_0 - - sphinxcontrib-serializinghtml=1.1.4=py_0 - - sphinxcontrib-websupport=1.2.4=pyh9f0ad1d_0 - - spyder=3.3.6=py37_0 - - spyder-kernels=0.5.2=py37_0 - - sqlalchemy=1.3.19=py37h60d8a13_0 - - sqlite=3.33.0=h960bd1c_0 - - statsmodels=0.12.0=py37h60d8a13_0 - - sympy=1.6.2=py37hc8dfbb8_0 - - tbb=2019.9=ha1b3eb9_1 - - tblib=1.6.0=py_0 - - terminado=0.9.1=py37hc8dfbb8_0 - - testpath=0.4.4=py_0 - - threadpoolctl=2.1.0=pyh5ca1d4c_0 - - tifffile=2020.9.3=py_0 - - tiledb=2.0.8=h8973ade_0 - - tk=8.6.10=hb0a8c7a_0 - - toml=0.10.1=pyh9f0ad1d_0 - - toolz=0.10.0=py_0 - - tornado=6.0.4=py37h9bfed18_1 - - tqdm=4.49.0=pyh9f0ad1d_0 - - traitlets=5.0.4=py_0 - - typed-ast=1.4.1=py37h0b31af3_0 - - typing_extensions=3.7.4.2=py_0 - - tzcode=2020a=h0b31af3_0 - - ujson=1.35=py37h570ac47_1002 - - unicodecsv=0.14.1=py_1 - - unixodbc=2.3.9=hcdbd15d_0 - - urllib3=1.25.10=py_0 - - watchdog=0.10.3=py37h60d8a13_1 - - wcwidth=0.2.5=pyh9f0ad1d_1 - - webencodings=0.5.1=py_1 - - werkzeug=1.0.1=pyh9f0ad1d_0 - - wheel=0.35.1=pyh9f0ad1d_0 - - widgetsnbextension=3.5.1=py37hc8dfbb8_1 - - wrapt=1.11.2=py37h9bfed18_0 - - wurlitzer=2.0.0=py37hc8dfbb8_1 - - xerces-c=3.2.3=h0a0444a_1 - - xlrd=1.2.0=pyh9f0ad1d_1 - - xlsxwriter=1.3.4=pyh9f0ad1d_0 - - xlwings=0.20.7=py37hc8dfbb8_0 - - xlwt=1.3.0=py_1 - - xmltodict=0.12.0=py_0 - - xz=5.2.5=haf1e3a3_1 - - yaml=0.2.5=haf1e3a3_0 - - yapf=0.30.0=pyh9f0ad1d_0 - - zeromq=4.3.2=h4a8c4bd_3 - - zfp=0.5.5=h4a8c4bd_1 - - zict=2.0.0=py_0 - - zipp=3.1.0=py_0 - - zlib=1.2.11=h7795811_1009 - - zope=1.0=py37_1 - - zope.event=4.5.0=pyh9f0ad1d_0 - - zope.interface=5.1.0=py37h9bfed18_0 - - zstd=1.4.5=h289c70a_2 - - pip: - - numpy==1.19.2 - - pyqt5-sip==4.19.18 - - pyqtchart==5.12 - - pyqtwebengine==5.12.1 - - setuptools==50.3.0 -prefix: /Users/taolu/anaconda3 diff --git a/pyincore/analyses/shelbycge/equationlib.py b/pyincore/analyses/shelbycge/equationlib.py new file mode 100755 index 000000000..5c5bb0217 --- /dev/null +++ b/pyincore/analyses/shelbycge/equationlib.py @@ -0,0 +1,833 @@ +from copy import deepcopy +import pandas as pd +import operator as op +import math + +import sys +sys.setrecursionlimit(1500) + +class VarContainer: + """ + All matrix variable(tables) in the GAMS model is flatten to a array to make a better + interface to the solver. + + AllVarList stores all initial values of varibles used in the GAMS model in an array. + It also has a indexing system for looking up. + + Attributes: + namelist: A dictionary with all stored GAMS variables and its information. + nvars: The length of the array, i.e. the size of all matrix variables summed up. + initialVals: Stored initial values of all variables + + """ + def __init__(self): + """ + Initialize to an empty list + """ + self.namelist = {} + self.initialVals = [] + self.nvars = 0 + self.LO = [] + self.UP = [] + + def add(self, name, rows = None, cols = None): + """ + :param name: + :param rows: + :param cols: + :return: + """ + if rows is not None and cols is not None: + size = len(rows) * len(cols) + self.namelist[name] = { \ + 'nrows': len(rows), \ + 'ncols': len(cols), \ + 'rows': rows, \ + 'cols': cols, \ + 'start': self.nvars, \ + 'size': size + } + elif rows is not None and cols is None: + size = len(rows) + self.namelist[name] = { + 'nrows': len(rows), \ + 'rows': rows, \ + 'start': self.nvars, \ + 'size': size + } + else: + size = 1 + self.namelist[name] = {'start': self.nvars, 'size': 1} + + self.initialVals.extend([None]*size) + self.LO.extend([None]*size) + self.UP.extend([None]*size) + self.nvars += size + + return ExprM(self, name=name, rows=rows, cols=cols) + + def set_value(self, name, values, target): + """ + An internal method for setting the initial values or UPs and LOs for variables + + :param name: Name of the variable in GAMS + :param value: a pandas DataFrame, pandas Series, int or float with initial values + :param target: target array to be set + + :return: None + """ + if type(values) == int or type(values) == float: + info = self.namelist[name] + if 'nrows' in info and 'ncols' in info: + values = pd.DataFrame(index = info['rows'], columns = info['cols']).fillna(values) + elif 'nrows' in info and 'ncols' not in info: + values = pd.Series(index = info['rows'], dtype='float64').fillna(values) + if type(values) == pd.DataFrame: + rows = values.index.tolist() + cols = values.columns.tolist() + for i in rows: + for j in cols: + target[self.getIndex(name,row = i, col = j)] = float(values.loc[i][j]) + elif type(values) == pd.Series: + rows = values.index.tolist() + for i in rows: + target[self.getIndex(name, row=i)] = float(values.loc[i]) + else: + target[self.getIndex(name)] = values + + def init(self, name, initialValue): + """ + Flatten the table variable and add to the list. + Also set the initial variable values array. + + :param name: Name of the variable in GAMS + :param initialValue: a pandas DataFrame or pandas Series with initial values + + :return: None. + """ + self.set_value(name, initialValue, self.initialVals) + + def inList(self, name): + """ + Check if a GAMS varible is added to the container + + :param name(str): name of GAMS variable you want to look up + :return: Boolean, whether the variable is added. + """ + return name in self.namelist + + def getInfo(self,name): + """ + Get the information about a GAMS variable + + :param name(str): name of GAMS variable you want to look up + :return: a dictionary with all information + """ + return self.namelist[name] + + def getIndex(self, name, row = None, col = None): + """ + Look up the index by providing the variable name and label information + + :param name: name of GAMS variable you want to look up + :param row: row label of the position you want to look up index for(if it has row labels) + :param col: column label of the position you want to look up index for(if it has column labels) + :return: the index of the position in the array + """ + info = self.namelist[name] + result = info['start'] + if row is not None and col is not None: + result += info['rows'].index(row)*info['ncols']+info['cols'].index(col) + elif row is not None: + result += info['rows'].index(row) + return result + + def getLabel(self, index): + """ + Look up variable name and label information by providing the index + + :param index: the index in the array + :return: its information including the variable name, row label and column label if applicable + """ + result = [] + for i in self.namelist.keys(): + if index >= self.namelist[i]['start'] and index < self.namelist[i]['start'] + self.namelist[i]['size']: + result.append(i) + if self.namelist[i]['size'] > 1: + diff = index -self.namelist[i]['start'] + if 'ncols' in self.namelist[i]: + result.append(self.namelist[i]['rows'][int(diff/self.namelist[i]['ncols'])]) + result.append(self.namelist[i]['cols'][diff%self.namelist[i]['ncols']]) + else: + result.append(self.namelist[i]['rows'][diff]) + return result + + def get_all_variable_printed(self, output = None): + if output is None: + output = self.initialVals + for i in range(len(output)): + label = self.getLabel(i) + if len(label) == 1: + print(label[0]+'='+'{0:.7f}'.format(output[i])+';') + elif len(label) == 2: + print(label[0]+'(\''+label[1]+'\')'+'='+'{0:.7f}'.format(output[i])+';') + elif len(label) == 3: + print(label[0]+'(\''+label[1]+'\',\''+label[2]+'\')'+'='+'{0:.7f}'.format(output[i])+';') + + def get(self, name, x = None): + """ + Returns a Dataframe, Series, or a variable based on the given name and the result array returned from the solver + + :param name: GAMS variable name + :return: if x is not given, it returns the initial values + if x is set to the result, returns the result variable value + """ + if x is None: + x = self.initialVals + + info = self.namelist[name] + if 'nrows' in info and 'ncols' in info: + ret = pd.DataFrame(index = info['rows'], columns = info['cols']).fillna(0.0) + for i in info['rows']: + for j in info['cols']: + ret.at[i,j] = x[self.getIndex(name,row=i,col=j)] + elif 'nrows' in info and 'ncols' not in info: + ret = pd.Series(index = info['rows'], dtype='float64').fillna(0.0) + for i in info['rows']: + ret.at[i] = x[self.getIndex(name,row=i)] + elif 'nrows' not in info and 'ncols' not in info: + ret = x[self.getIndex(name)] + + return ret + + def lo(self, name, value): + """ + Set the LOs of a GAMS variable providing the LOs with a Dataframe, Series, int or float + + :param name: GAMS variable name + :param value: The lower bound to be set + :return: None + """ + self.set_value(name, value, self.LO) + + def up(self, name, value): + """ + Set the UPs of a GAMS variable providing the LOs with a Dataframe, Series, int or float + + :param name: GAMS variable name + :param value: The upper bound to be set + :return: None + """ + self.set_value(name, value, self.UP) + + def write(self, filename): + """ + Write(append) the variables to a file, in the format of setting ipopt model variables + + :param filename: the output filename + :return: None + """ + with open(filename, 'a') as f: + for i in range(self.nvars): + + lower = -1e20 if self.LO[i] == None else self.LO[i] + upper = 1e20 if self.UP[i] == None else self.UP[i] + value = 0 if math.isnan(self.initialVals[i]) else self.initialVals[i] + + + #tmp_list = ['CG','CH','CN','CPI','CPIN','CPIH','CX','D','DD','DS','FD','GCP','GCP1','HH','HN','HW','IGT','KS'] + '''tmp_list = ['CG','CH','CN','CPI','CPIN','CPIH','CX','D','DD','DS','FD','GCP','GCP1','HH','HN','HW','IGT','KS','LAS','M','N','NKI','LNFOR','KPFOR','GVFOR','P','PD','PVA'] + if self.getLabel(i)[0] in tmp_list: + f.write('model.x' + str(i) + ' = Var(bounds=(' + str(lower) + ',' + str(upper) + '),initialize=' + str(self.initialVals[i]) + ')' + '\n') + else: + f.write('model.x' + str(i) + ' = Var(bounds=(' + str(self.initialVals[i]-1e-3) + ',' + str(self.initialVals[i]+1e-3) + '),initialize=' + str(self.initialVals[i]) + ')' + '\n') + ''' + #if i == 1507: + # f.write('model.x' + str(i) + ' = Var(bounds=(' + str(value) + ',' + str(value*10) + '),initialize=' + str(value) + ')' + '\n') + #else: + # f.write('model.x' + str(i) + ' = Var(bounds=(' + str(lower) + ',' + str(upper) + '),initialize=' + str(value) + ')' + '\n') + f.write('model.x' + str(i) + ' = Var(bounds=(' + str(lower) + ',' + str(upper) + '),initialize=' + str(value) + ')' + '\n') + + +class variable: + """ + A GMAS variable, initialized by given the GAMS variable value and its label + """ + def __init__(self, vars, name, row = None, col = None): + """ + Initialize it with a variable container, the GAMS name, the labels + + :param vars: the variable container that already added the GAMS variable + :param name: GAMS variable name + :param row: GAMS row label if there is + :param col: GAMS col label if there is + :return: None + """ + try: + self.index = vars.getIndex(name,row,col) + except Exception as e: + print(e) + #print("invalid name for a variable") + def __str__(self): + """ + returns the variable in the format of "model.x#" if gets printed, + with # being the index in the array in the container + + :return: String + """ + return 'model.x'+str(self.index)+'' + #return 'x[' + str(self.index) + ']' + def debug_test_str(self): + return 'x[' + str(self.index) + ']' + + +class ExprItem: + ''' + You can construct it with a variable, a constant or a deepcopy of another ExprItem + ''' + def __init__(self, v, const = 1): + self.varList = [] + self.const = const + if type(v) == variable: + self.varList.append(v) + elif type(v) == int or type(v) == float: + self.const = v + elif type(v) == ExprItem: + self.const = deepcopy(v.const) + self.varList = deepcopy(v.varList) + else: + print("invalid parameter to create a item") + + ''' + You could multiply it with a number, a variable, a ExprItem or Expression + ''' + def __mul__(self, rhs): + copy = ExprItem(self) + if type(rhs) == int or type(rhs) == float: + copy.const = copy.const*rhs + elif type(rhs) == variable: + copy.varList.append(rhs) + elif type(rhs) == ExprItem: + copy.const*=rhs.const + copy.varList.extend(deepcopy(rhs.varList)) + elif type(rhs) == Expr: + if rhs.isComposite: + if rhs.operator == '/': + return rhs * copy + else: + copy.varList.append(Expr(rhs)) + else: + copyrhs = Expr(rhs) + copyrhs.itemList = [i * copy for i in copyrhs.itemList] + return copyrhs + return copy + + def __str__(self): + #if abs(self.const) > 0.1: + # result = '' + str(round(self.const,3)) + #else: + # result = '' + str(self.const) + #result = '' + str(round(self.const,7)) + result = '' + str(self.const) + for i in range(len(self.varList)): + result += "*" + self.varList[i].__str__() + return result + + def debug_test_str(self): + #if abs(self.const) > 0.1: + # result = '' + str(round(self.const,3)) + #else: + # result = '' + str(self.const) + result = '' + str(self.const) + for i in range(len(self.varList)): + result += "*" + self.varList[i].debug_test_str() + return result + + def is_empty(self): + if abs(self.const)<0.00000001: + return True + else: + return False + + def is_one(self): + if abs(self.const - 1 )< 0.0000001 and len(self.varList) == 0: + return True + else: + return False + +class Expr: + + def __init__(self, item): + self.itemList = [] + self.isComposite = False + if type(item) == ExprItem or type(item) == variable or type(item) == int or type(item) == float: + self.itemList.append(ExprItem(item)) + elif type(item) == Expr: + self.itemList = [ExprItem(item.itemList[i]) if type(item.itemList[i]) == ExprItem else Expr(item.itemList[i]) for i in range(len(item.itemList))] + try: + self.isComposite = deepcopy(item.isComposite) + except Exception as e: + pass + try: + self.operator = deepcopy(item.operator) + except Exception as e: + pass + try: + self.first = Expr(item.first) + except Exception as e: + pass + try: + self.second = Expr(item.second) + except Exception as e: + pass + else: + print("invalid parameter for creating a Expr") + + self.clear_empty() + + def __add__(self, rhs): + copy = Expr(self) + if self.isComposite: + tmp = Expr(self) + copy.itemList = [tmp] + copy.isComposite = False + if type(rhs) == Expr: + if rhs.isComposite: + rhscopy = Expr(rhs) + copy.itemList.append(rhscopy) + else: + rhscopy = Expr(rhs) + copy.itemList = copy.itemList + rhscopy.itemList + elif type(rhs) == ExprItem or type(rhs) == int or type(rhs) == float or type(rhs) == variable: + copy.itemList.append(ExprItem(rhs)) + return copy + + def __sub__(self, rhs): + copy = Expr(self) + return copy + rhs * -1 + + def __mul__(self, rhs): + copy = Expr(self) + if type(rhs) == int or type(rhs) == float or type(rhs) == ExprItem: + if copy.isComposite: + if copy.operator == '/': + copy.first = copy.first * rhs + elif copy.opeartor == '**': + return ExprItem(rhs) * copy + else: + result = [] + for i in copy.itemList: + result.append(i * rhs) + copy.itemList = result + + + elif type(rhs) == Expr: + if copy.isComposite and not rhs.isComposite: + if copy.operator == '/': + copy.first = copy.first * rhs + else: + copy.itemList = [i * copy for i in rhs.itemList] + copy.isComposite = False + elif not copy.isComposite and not rhs.isComposite: + #print('copy',copy) + #print('rhs',rhs) + + if len(copy.itemList) * len(rhs.itemList) > 10: + + tmpItem = ExprItem(1) + tmpItem.varList.append(Expr(copy)) + tmpItem.varList.append(Expr(rhs)) + copy.itemList = [tmpItem] + + else: + + # The expanding way is super slow for long equations + + result = [] + for i in copy.itemList: + for j in rhs.itemList: + if type(i) == Expr: + tmp = Expr(i) + elif type(i) == ExprItem: + tmp = ExprItem(i) + result.append(tmp * j) + copy.itemList = result + + elif not self.isComposite and rhs.isComposite: + return rhs * copy + else: + # both are composite + if copy.operator == '/' and rhs.operator == '/': + copy.first = copy.first * rhs.first + copy.second = copy.second * rhs.second + elif copy.operator == '**' and rhs.operator == '**': + copy.first = copy.first * rhs.first + copy.second = copy.second + rhs.second + elif copy.operator == '/' and rhs.operator == '**': + copy.first = copy.first * rhs + elif copy.operator == '**' and rhs.operator == '/': + copyrhs = Expr(rhs) + copyrhs.first = copyrhs.first * copy + return copy + + + def __truediv__(self,rhs): + copy = Expr(self) + tmp = Expr(copy) + copy.isComposite = True + copy.operator = '/' + copy.first = tmp + copy.second = Expr(rhs) + return copy + + def __pow__(self,rhs): + copy = Expr(self) + tmp = Expr(copy) + copy.isComposite = True + copy.operator = '**' + copy.first = tmp + copy.second = Expr(rhs) + return copy + + def __str__(self): + if self.isComposite: + result = "(" + self.first.__str__() + self.operator + self.second.__str__() + ")" + else: + if len(self.itemList) == 0: + return '0' + result = '' + for i in self.itemList[0:-1]: + result += "("+i.__str__()+")" + "+" + result += "("+self.itemList[-1].__str__()+")" + if len(self.itemList) > 1: + result = "(" + result + ")" + return result + + def debug_test_str(self): + if self.isComposite: + result = "(" + self.first.debug_test_str() + self.operator + self.second.debug_test_str() + ")" + else: + if len(self.itemList) == 0: + return '0' + result = '' + for i in self.itemList[0:-1]: + result += "("+i.debug_test_str()+")" + "+" + result += "("+self.itemList[-1].debug_test_str()+")" + if len(self.itemList) > 1: + result = "(" + result + ")" + return result + + def is_empty(self): + if not self.isComposite and len(self.itemList) == 0: + return True + else: + return False + + + def clear_empty(self): + result = [] + if self.isComposite == False: + for i in range(len(self.itemList)): + if type(self.itemList[i]) == ExprItem: + if not self.itemList[i].is_empty(): + result.append(self.itemList[i]) + if type(self.itemList[i]) == Expr: + self.itemList[i].clear_empty() + if not self.itemList[i].is_empty(): + result.append(self.itemList[i]) + self.itemList = result + """ + else: + if self.operator == '**' and is_empty(self.second): + self.isComposite = False + self.itemList = [] + self.itemList.append(ExprItem(1)) + """ + + +class ExprM: + ''' + Three ways to create a ExprMatrix: + 1. Give it the variable name, selected rows and cols(could be empty), + The constructor will create a Expression matrix from the variable matrix + 2. Give it a pandas Series or DataFrame, it will create the Expression matrix + with the content in the Series or DataFrame as constants + 3. Give it a ExprMatrix, will return a deep copy of it + ''' + def __init__(self, vars, name = None, rows = None, cols = None, m = None, em = None): + self.vars = vars + self.hasCondition = False + if em is None: + # if these are the variables, we need to create an Expression by the variable name + if name is not None : + if self.vars.inList(name): + self.info = deepcopy(self.vars.getInfo(name)) + else: + print("Can't find this variable in the all variable list") + + self.info['height'] = 1 + self.info['width'] = 1 + self.info['rows'] = deepcopy(rows) + self.info['cols'] = deepcopy(cols) + if cols is not None: + self.info['width'] = len(cols) + if rows is not None: + self.info['height'] = len(rows) + + if cols is not None: # if it is a DataFrame + self.m = [[Expr(variable(self.vars,name,i,j)) for j in cols] for i in rows] + elif rows is not None: # if it is a Series + self.m = [[Expr(variable(self.vars,name,i))] for i in rows] + else: # if it is a variable + self.m = [[Expr(variable(self.vars,name))]] + + # otherwise these are just constants + else: + self.info = {} + self.info['height'] = 1 + self.info['width'] = 1 + self.info['rows'] = None + self.info['cols'] = None + if type(m) == pd.DataFrame: + self.info['rows'] = m.index.tolist() + self.info['height'] = len(self.info['rows']) + self.info['cols'] = m.columns.tolist() + self.info['width'] = len(self.info['cols']) + self.m = [[Expr(float(m.loc[i,j])) for j in self.info['cols']] for i in self.info['rows']] + elif type(m) == pd.Series: + self.info['rows'] = m.index.tolist() + self.info['height'] = len(self.info['rows']) + self.m = [[Expr(float(m.loc[i]))] for i in self.info['rows']] + else: + self.m = [[Expr(float(m))]] + else: + # make deep copy + self.info = deepcopy(em.info) + self.m = [[Expr(em.m[i][j]) for j in range(em.info['width'])] for i in range(em.info['height'])] + + def operation(self, rhs, oper): + copy = ExprM(self.vars, em = self) + + if type(rhs) == int or type(rhs) == float: + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j], Expr(rhs)) + + elif type(rhs) == pd.DataFrame or type(rhs) == pd.Series: + return self.operation(ExprM(self.vars, m=rhs),oper) + + elif type(rhs) == ExprM: + if copy.info['rows'] == rhs.info['rows'] and copy.info['cols'] == rhs.info['cols']: + # same size, apply operation element-wise + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j],rhs.m[i][j]) + elif copy.info['rows'] == rhs.info['rows'] and copy.info['width'] == 1: + # for each column in rhs + result = [[Expr(0) for j in range(rhs.info['width'])] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(rhs.info['width']): + result[i][j] = oper(copy.m[i][0],rhs.m[i][j]) + copy.m = result + copy.info['width'] = rhs.info['width'] + copy.info['cols'] = deepcopy(rhs.info['cols']) + elif copy.info['rows'] == rhs.info['rows'] and rhs.info['width'] == 1: + # for each column in lhs + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j], rhs.m[i][0]) + elif copy.info['height'] == 1 and copy.info['cols'] == rhs.info['cols']: + # for each row in rhs + result = [[Expr(0) for j in range(rhs.info['width'])] for i in range(rhs.info['height'])] + for i in range(rhs.info['height']): + for j in range(rhs.info['width']): + result[i][j] = oper(copy.m[0][j], rhs.m[i][j]) + copy.m = result + copy.info['height'] = rhs.info['height'] + copy.info['rows'] = deepcopy(rhs.info['rows']) + elif rhs.info['height'] == 1 and copy.info['cols'] == rhs.info['cols']: + # for each row in lhs + for i in range(self.info['height']): + for j in range(self.info['width']): + copy.m[i][j] = oper(copy.m[i][j],rhs.m[0][j]) + elif (self.info['width'] == rhs.info['height'] and self.info['cols'] == rhs.info['rows'] ) or \ + (self.info['height'] == rhs.info['width'] and self.info['rows'] == rhs.info['cols'] ): + # flip the matrix + return oper(self, ~rhs) + + else: + print(copy.info['rows'],copy.info['cols'], rhs.info['rows'],rhs.info['cols']) + print(copy.info['height'],copy.info['width'], rhs.info['height'],rhs.info['width']) + print("Invalid size for ", str(oper)) + return copy + + def __add__(self, rhs): + return self.operation(rhs, op.add) + + def __radd__(self, lhs): + return self + lhs + + def __sub__(self, rhs): + return self.operation(rhs, op.sub) + + def __rsub__(self, lhs): + return self * -1 + lhs + + def __mul__(self, rhs): + return self.operation(rhs, op.mul) + + def __truediv__(self, rhs): + return self.operation(rhs, op.truediv) + + def __pow__(self, rhs): + return self.operation(rhs, op.pow) + + def __xor__(self, rhs): + """ + create 2d list out of 2 single lists + """ + # has to be 2 single lists + if self.info['width'] != 1 or rhs.info['width'] !=1: + print("Invalid size for creating a 2-D matrix") + else: + copy = ExprM(self.vars,em = self) + copy.m = [[copy.m[i][0] * rhs.m[j][0] for j in range(rhs.info['height'])] for i in range(copy.info['height'])] + copy.info['cols'] = deepcopy(rhs.info['rows']) + copy.info['width'] = deepcopy(rhs.info['height']) + return copy + + def __invert__(self): + """ + Return the transpose of a Expression matrix + """ + copy = ExprM(self.vars,em = self) + result = [[copy.m[i][j] for i in range(copy.info['height'])] for j in range(copy.info['width'])] + copy.info['height'],copy.info['width'] = copy.info['width'],copy.info['height'] + copy.info['rows'],copy.info['cols'] = copy.info['cols'],copy.info['rows'] + copy.m = result + return copy + + def __str__(self): + result = '' + for i in self.m: + for j in i: + result+= j.__str__() + '\n' + result+='///////////////////\n' + return result + + + def loc(self, rows=None, cols = None): + """ + get a subset of the matrix by labels + """ + copy = ExprM(self.vars,em = self) + if cols is not None: + result = [[Expr(copy.m[self.info['rows'].index(i)][self.info['cols'].index(j)]) for j in cols] for i in rows] + copy.m = result + copy.info['rows'] = deepcopy(rows) + copy.info['height'] = len(copy.info['rows']) + copy.info['cols'] = deepcopy(cols) + copy.info['width'] = len(copy.info['cols']) + return copy + elif rows is not None: + result = [[Expr(copy.m[self.info['rows'].index(i)][0])] for i in rows] + copy.m = result + copy.info['rows'] = deepcopy(rows) + copy.info['height'] = len(copy.info['rows']) + return copy + else: + return copy + + def sum(self, label = None): + copy = ExprM(self.vars,em = self) + if label == None: + result = Expr(0) + for i in range(self.info['height']): + for j in range(self.info['width']): + result = result + copy.m[i][j] + copy.m = [[result]] + copy.info['width'] = 1 + copy.info['height'] = 1 + copy.info['rows'] = None + copy.info['cols'] = None + + elif label == self.info['rows'] or label == 0: + result = [[Expr(0) for j in range(self.info['width'])]] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[0][j] = result[0][j] + copy.m[i][j] + copy.m = result + copy.info['height'] = 1 + copy.info['rows'] = None + + elif label == self.info['cols'] or label == 1: + result = [[Expr(0)] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[i][0] = result[i][0] + copy.m[i][j] + copy.m = result + copy.info['width'] = 1 + copy.info['cols'] = None + return copy + + def prod(self, label): + copy = ExprM(self.vars,em = self) + if label == self.info['rows'] or label == 0: + result = [[Expr(1) for j in range(self.info['width'])]] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[0][j] = result[0][j] * copy.m[i][j] + copy.m = result + copy.info['height'] = 1 + copy.info['rows'] = None + elif label == self.info['cols'] or label == 1: + result = [[Expr(1)] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + result[i][0] = result[i][0] * copy.m[i][j] + copy.m = result + copy.info['width'] = 1 + copy.info['cols'] = None + return copy + + def setCondition(self, matrix, operator=None, value=None): + self.hasCondition = True + mappings = {'LT': op.lt, 'LE': op.le, 'EQ': op.eq , 'INEQ': op.ne} # not complete list + if type(matrix) == pd.DataFrame: + self.mark = [[False for j in range(self.info['width'])] for i in range(self.info['height'])] + for i in range(self.info['height']): + for j in range(self.info['width']): + if operator == None: + self.mark[i][j] = op.ne(matrix.loc[self.info['rows'][i]][self.info['cols'][j]], 0) + else: + self.mark[i][j] = mappings[operator](matrix.loc[self.info['rows'][i]][self.info['cols'][j]], value) + + if type(matrix) == pd.Series: + self.mark = [[False] for i in range(self.info['height'])] + for i in range(self.info['height']): + if operator == None: + self.mark[i][0] = op.ne(matrix.loc[self.info['rows'][i]], 0) + else: + self.mark[i][0] = mappings[operator](matrix.loc[self.info['rows'][i]], value) + + + def write(self, count, filename): + f = open(filename, 'a') + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + f.write('model.equality'+str(count[0])+' = Constraint(expr='+self.m[i][j].__str__() + ' == 0)\n') + count[0]+=1 + f.close() + + def test(self,x): + print("...testing the values....") + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + fun = lambda x: eval( self.m[i][j].debug_test_str() ) + # print(i,j,fun(x)) diff --git a/pyincore/analyses/shelbycge/files/data_insertion.txt b/pyincore/analyses/shelbycge/files/data_insertion.txt new file mode 100644 index 000000000..e69de29bb diff --git a/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py b/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py deleted file mode 100755 index 6a3652663..000000000 --- a/pyincore/analyses/shelbycge/shelby_CD_September_21_2020.py +++ /dev/null @@ -1,1866 +0,0 @@ -from pyincore.analyses.shelbycge.Equationlib import * -import os -import pandas as pd -from pyomo.environ import * -from pyomo.opt import SolverFactory - - -def _(x): - return ExprM(vars, m=x) - - -# ---------------------------------------------------------------- -# set file paths -# ---------------------------------------------------------------- - - -modelPath = os.path.join(os.getcwd(), 'old') -filePath = os.path.join(modelPath, 'old') - -# filePath = './JOP_small/' - -# ---------------------------------------------------------------- -# define sets -# ---------------------------------------------------------------- - -# ALL ACCOUNTS IN SOCIAL ACCOUNTING MATRIX - -Z = [ - 'GOODSA', - 'TRADEA', - 'OTHERA', - 'GOODSB', - 'TRADEB', - 'OTHERB', - 'GOODSC', - 'TRADEC', - 'OTHERC', - 'GOODSD', - 'TRADED', - 'OTHERD', - 'GOODSE', - 'TRADEE', - 'OTHERE', - 'GOODSF', - 'TRADEF', - 'OTHERF', - 'GOODSG', - 'TRADEG', - 'OTHERG', - 'GOODSH', - 'TRADEH', - 'OTHERH', - 'HS1A', - 'HS2A', - 'HS3A', - 'HS1B', - 'HS2B', - 'HS3B', - 'HS1C', - 'HS2C', - 'HS3C', - 'HS1D', - 'HS2D', - 'HS3D', - 'HS1E', - 'HS2E', - 'HS3E', - 'HS1F', - 'HS2F', - 'HS3F', - 'HS1G', - 'HS2G', - 'HS3G', - 'HS1H', - 'HS2H', - 'HS3H', - 'L1A', - 'L2A', - 'L3A', - 'L1B', - 'L2B', - 'L3B', - 'L1C', - 'L2C', - 'L3C', - 'L1D', - 'L2D', - 'L3D', - 'L1E', - 'L2E', - 'L3E', - 'L1F', - 'L2F', - 'L3F', - 'L1G', - 'L2G', - 'L3G', - 'L1H', - 'L2H', - 'L3H', - 'KAP', - 'HH1A', - 'HH2A', - 'HH3A', - 'HH4A', - 'HH5A', - 'HH1B', - 'HH2B', - 'HH3B', - 'HH4B', - 'HH5B', - 'HH1C', - 'HH2C', - 'HH3C', - 'HH4C', - 'HH5C', - 'HH1D', - 'HH2D', - 'HH3D', - 'HH4D', - 'HH5D', - 'HH1E', - 'HH2E', - 'HH3E', - 'HH4E', - 'HH5E', - 'HH1F', - 'HH2F', - 'HH3F', - 'HH4F', - 'HH5F', - 'HH1G', - 'HH2G', - 'HH3G', - 'HH4G', - 'HH5G', - 'HH1H', - 'HH2H', - 'HH3H', - 'HH4H', - 'HH5H', - 'INVES', - 'USSOCL1A', - 'USSOCL2A', - 'USSOCL3A', - 'USSOCL1B', - 'USSOCL2B', - 'USSOCL3B', - 'USSOCL1C', - 'USSOCL2C', - 'USSOCL3C', - 'USSOCL1D', - 'USSOCL2D', - 'USSOCL3D', - 'USSOCL1E', - 'USSOCL2E', - 'USSOCL3E', - 'USSOCL1F', - 'USSOCL2F', - 'USSOCL3F', - 'USSOCL1G', - 'USSOCL2G', - 'USSOCL3G', - 'USSOCL1H', - 'USSOCL2H', - 'USSOCL3H', - 'MEMPROPTAX', - 'OTHERPROPTAX', - 'MEMSALESTAX', - 'OTHERSALESTAX', - 'MEMFEE', - 'OTHERFEE', - 'TNSTX', - 'TNITAX', - 'USPIT', - 'CYGFM', - 'CYGFO', - 'FED', - 'STATE', - 'MEMPHIS', - 'OTHER', - 'OUTCOM1', - 'OUTCOM2', - 'OUTCOM3', - 'ROW'] - -# FACTORS -F = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', 'KAP'] - -F11 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] - -F21 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] - -F31 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] - -# COMMUTERS OUT -CM = ['OUTCOM1', 'OUTCOM2', 'OUTCOM3'] - -# COMMUTERS OUT 1 -CM1 = ['OUTCOM1'] - -# COMMUTERS OUT 2 -CM2 = ['OUTCOM2'] - -# COMMUTERS OUT 3 -CM3 = ['OUTCOM3'] - -# ALL WORKERS WHO LIVE IN SHELBY -LT = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', - 'OUTCOM1', 'OUTCOM2', 'OUTCOM3'] - -# LABOR -L = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'] - -L1 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] - -L2 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] - -L3 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] - -# LAND -# LA(F) = ['LAND'] - -# CAPITAL -K = ['KAP'] - -# GOVERNMENTS -G = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', - 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', - 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', - 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', - 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT', 'CYGFM', 'CYGFO', 'FED', - 'STATE', 'MEMPHIS', 'OTHER'] - -# ENDOGENOUS GOVERNMENTS -GN = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] - -# LOCAL ENDOGENOUS GOVERNMENTS -GNLM = ['MEMPHIS'] - -# LOCAL ENDOGENOUS GOVERNMENTS -GNLO = ['OTHER'] - -# EXOGENOUS GOVERMENTS -GX = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', - 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', - 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', - 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', - 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT'] - -# SALES OR EXCISE TAXES -GS = ['MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', 'OTHERFEE', 'TNSTX'] - -# LAND TAXES -GL = ['MEMPROPTAX', 'OTHERPROPTAX'] - -# FACTOR TAXES -GF = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', - 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', 'MEMPROPTAX', 'OTHERPROPTAX'] - -# SS PAYMENT -GFUS = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', - 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] - -# SS PAYMENT -GFUSC = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', - 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] - -# INCOME TAX UNITS -GI = ['TNITAX', 'USPIT'] - -# HOUSEHOLD TAX UNITS -GH = ['MEMPROPTAX', 'OTHERPROPTAX', 'MEMFEE', 'OTHERFEE'] - -# ENDOGENOUS TRANSFER PMT -GT = ['CYGFM', 'CYGFO', 'FED', 'STATE'] - -# HOUSEHOLDS -H = ['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', - 'HH5C', - 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', - 'HH5F', - 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'] - -# I+G SECTORS -IG = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', - 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', - 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', - 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H', - 'FED', 'STATE', 'MEMPHIS', 'OTHER'] - -# INDUSTRY SECTORS -I = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', - 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', - 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', - 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H'] - -# ENDOGENOUS GOVERNMENTS -IG2 = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] - -# PRODUCTION SECTORS -IP = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', - 'OTHERD', - 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', - 'OTHERH'] - -# PRODUCTION GOV. -FG = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', - 'OTHERD', - 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', - 'OTHERH'] - -# HOUSING SERV.DEMAND -HSD = ['HS1A', 'HS2A', 'HS3A', 'HS1B', 'HS2B', 'HS3B', 'HS1C', 'HS2C', 'HS3C', 'HS1D', 'HS2D', 'HS3D', - 'HS1E', 'HS2E', 'HS3E', 'HS1F', 'HS2F', 'HS3F', 'HS1G', 'HS2G', 'HS3G', 'HS1H', 'HS2H', 'HS3H'] - -# SIMMLOOP -SM = ['BASE', 'TODAY', 'SIMM'] - -# REPORT 1 FOR SCALARS -R1H = ['GFREV', 'SFREV', 'PIT', - 'DGF', 'DSF', 'DDRE', 'PDRE', 'SPI', 'COMM', 'COMMO', - 'GN', 'NKI', 'HH', 'W', 'W1', 'W2', 'W3', 'R', 'RL', 'L', 'K', 'HN', 'HW', 'GFSAVM', 'GFSAVO', 'LD', - 'CMO', 'CMI', 'HC', 'SSC', 'LAND', 'LAS'] - -# REPORT 2 FOR STATUS -R2H = ['M-STAT', 'S-STAT'] - -# LABELS FOR MODEL STATUS -MS = ['OPTIMAL', 'LOCALOP', 'UNBOUND', - 'INFSBLE', 'INFSLOC', 'INFSINT', - 'NOOPTML', 'MIPSOLN', 'NOINTGR', - 'INFSMIP', 'UNUSED', 'UNKNOWN', - 'NOSOLUT'] - -# LABELS FOR SOLVER STATUS -SS = ['OK', 'ITERATE', 'RESRCE', - 'SOLVER', 'EVALUATE', 'NOTKNWN', - 'NOTUSED', 'PRE-PROC', 'SETUP', - 'SLVFAIL', 'SLVINTER', 'POST-PROC', - 'METSYS'] - -# SETS FOR MISC TABLES ONLY - -# HOUSING SERVICES -HSSET = ['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', - 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', - 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] - -# HOUSING SERVICES 2 & 3 -HS23SET = ['HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', - 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] - -# HOUSEHOLDS (INCOME 1) -HH1 = ['HH1A', 'HH1B', 'HH1C', 'HH1D', 'HH1E', 'HH1F', 'HH1G', 'HH1H'] - -# HOUSEHOLDS (INCOME 2) -HH2 = ['HH2A', 'HH2B', 'HH2C', 'HH2D', 'HH2E', 'HH2F', 'HH2G', 'HH2H'] - -# HOUSEHOLDS (INCOME 3) -HH3 = ['HH3A', 'HH3B', 'HH3C', 'HH3D', 'HH3E', 'HH3F', 'HH3G', 'HH3H'] - -# HOUSEHOLDS (INCOME 4) -HH4 = ['HH4A', 'HH4B', 'HH4C', 'HH4D', 'HH4E', 'HH4F', 'HH4G', 'HH4H'] - -# HOUSEHOLDS (INCOME 5) -HH5 = ['HH5A', 'HH5B', 'HH5C', 'HH5D', 'HH5E', 'HH5F', 'HH5G', 'HH5H'] - -# ELASTICITIES -ETA = ['ETAL1', 'ETAI1', 'ETALB1', 'ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU', 'ETAM', 'ETAE', 'ETAY', 'ETAOP'] - -# LANDCAP TABLE ELASTICITIES -ETALANDCAP = ['ETAL1', 'ETAI1', 'ETALB1'] - -# MISCH TABLE ELASTICITIES -ETAMISCH = ['ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU'] - -# MISC TABLE ELASTICITIES -ETAMISC = ['ETAM', 'ETAE', 'ETAY', 'ETAOP'] - -# ---------------------------------------------------------------- -# SET ALIASES -# ---------------------------------------------------------------- - -# ALIAS -J = I -I1 = I -Z1 = Z -F1 = F -G1 = G -G2 = G -GI1 = GI -GS1 = GS -GX1 = GX -GN1 = GN -GH1 = GH -GF1 = GF -H1 = H -HSD1 = HSD -JP = IP -JG = IG -GT1 = GT -GNLM1 = GNLM -GNLO1 = GNLO - -# ---------------------------------------------------------------- -# IMPORT ADDITIONAL DATA FILES -# ---------------------------------------------------------------- - -# SAM -SAM = pd.read_csv(os.path.join(filePath, 'SAM Shelby(1202).csv'), index_col=0) - -# CAPITAL COMP -BB = pd.read_csv(os.path.join(filePath, 'capcomshelby.csv'), index_col=0) - -# MISC TABLES - -TPC = pd.DataFrame(index=H, columns=G).fillna(0.0) -IGTD = pd.DataFrame(index=G, columns=G1).fillna(0.0) -TAUFF = pd.DataFrame(index=G, columns=F).fillna(0.0) -IOUT = pd.DataFrame(index=G1, columns=G1).fillna(0.0) -LANDCAP = pd.DataFrame(index=IG, columns=ETALANDCAP).fillna(0.0) -MISC = pd.DataFrame(index=Z, columns=ETAMISC).fillna(0.0) -MISCH = pd.DataFrame(index=H, columns=ETAMISCH).fillna(0.0) - -miscPath = os.path.join(filePath, 'MiscFile') - -# EMPLOY0 = pd.read_csv(os.path.join(miscPath, 'EMPLOY0(Z,F).csv'), index_col=0) -EMPLOY = pd.read_csv(os.path.join(miscPath, 'EMPLOY(Z,F).csv'), index_col=0) -JOBCR = pd.read_csv(os.path.join(miscPath, 'JOBCR(H,L).csv'), index_col=0) -# JOBCR1 = pd.read_csv(os.path.join(miscPath, 'JOBCR1(H,L).csv'), index_col=0) -HHTABLE = pd.read_csv(os.path.join(miscPath, 'HHTABLE(H,).csv'), index_col=0) -# OUTCR = pd.read_csv(os.path.join(miscPath, 'OUTCR(H,CM).csv'), index_col=0) - -# ---------------------------------------------------------------- -# PARAMETER DECLARATION -# ---------------------------------------------------------------- - -# these are data frames with zeros to be filled during calibration -A = pd.DataFrame(index=Z, columns=Z).fillna(0.0) -AD = pd.DataFrame(index=Z, columns=Z).fillna(0.0) -AG = pd.DataFrame(index=Z, columns=G).fillna(0.0) -AGFS = pd.DataFrame(index=Z, columns=G).fillna(0.0) -SIGMA = pd.Series(index=I, dtype=float).fillna(0.0) -ALPHA = pd.DataFrame(index=F, columns=I).fillna(0.0) -ALPHA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) -B = pd.DataFrame(index=I, columns=IG).fillna(0.0) -B1 = pd.DataFrame(index=I, columns=I).fillna(0.0) -CMOWAGE = pd.Series(index=CM, dtype=float).fillna(0.0) -CMIWAGE = pd.Series(index=L, dtype=float).fillna(0.0) -FCONST = pd.DataFrame(index=F, columns=I).fillna(0.0) -GAMMA = pd.Series(index=I, dtype=float).fillna(0.0) -DELTA = pd.Series(index=I, dtype=float).fillna(0.0) -PIT = pd.DataFrame(index=G, columns=H).fillna(0.0) -PIT0 = pd.DataFrame(index=G, columns=H).fillna(0.0) -PRIVRET1 = pd.Series(index=H, dtype=float).fillna(0.0) -PRIVRET = pd.Series(index=H, dtype=float).fillna(0.0) -# LFOR = pd.Series(index=LA, dtype=float).fillna(0.0) -KFOR = pd.Series(index=K, dtype=float).fillna(0.0) -GFOR = pd.Series(index=G, dtype=float).fillna(0.0) -out = pd.DataFrame(index=G, columns=G).fillna(0.0) -TAUFH = pd.DataFrame(index=G, columns=F).fillna(0.0) -TAUFL = pd.DataFrame(index=G, columns=L).fillna(0.0) -# TAUFLA = pd.DataFrame(index=G, columns=LA).fillna(0.0) -TAUFK = pd.DataFrame(index=G, columns=K).fillna(0.0) -TAUH = pd.DataFrame(index=G, columns=H).fillna(0.0) -TAUH0 = pd.DataFrame(index=G, columns=H).fillna(0.0) -TAUM = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUQ = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUC = pd.DataFrame(index=G, columns=I).fillna(0.0) -TAUCH = pd.DataFrame(index=G, columns=HSD).fillna(0.0) -TAUV = pd.DataFrame(index=G, columns=I).fillna(0.0) -TAUN = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUX = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUG = pd.DataFrame(index=G, columns=I).fillna(0.0) -TAXS = pd.DataFrame(index=G, columns=G).fillna(0.0) -TAXS1 = pd.Series(index=GNLM, dtype=float).fillna(0.0) -TAXS2 = pd.Series(index=GNLO, dtype=float).fillna(0.0) - -# ELASTICITIES AND TAX DATA IMPOSED - -BETA = pd.DataFrame(index=I, columns=H).fillna(0.0) -BETAH = pd.DataFrame(index=HSD, columns=H).fillna(0.0) -ETAD = pd.Series(index=I, dtype=float).fillna(0.0) -ETAE = pd.Series(index=I, dtype=float).fillna(0.0) -ETAI = pd.Series(index=IG, dtype=float).fillna(0.0) -ETAIX = pd.DataFrame(index=K, columns=IG).fillna(0.0) -ETAL1 = pd.Series(index=IG, dtype=float).fillna(0.0) -ETALB1 = pd.Series(index=IG, dtype=float).fillna(0.0) -ETALB = pd.DataFrame(index=L, columns=IG).fillna(0.0) -ETAM = pd.Series(index=I, dtype=float).fillna(0.0) -ETARA = pd.Series(index=H, dtype=float).fillna(0.0) -ETAYDO = pd.Series(index=H, dtype=float).fillna(0.0) -ETAUO = pd.Series(index=H, dtype=float).fillna(0.0) -ETAYDI = pd.Series(index=H, dtype=float).fillna(0.0) -ETAUI = pd.Series(index=H, dtype=float).fillna(0.0) -ETAYD = pd.Series(index=H, dtype=float).fillna(0.0) -ETAU = pd.Series(index=H, dtype=float).fillna(0.0) -ETAPT = pd.Series(index=H, dtype=float).fillna(0.0) -ETAPIT = pd.Series(index=H, dtype=float).fillna(0.0) -EXWGEO = pd.Series(index=CM, dtype=float).fillna(0.0) -EXWGEI = pd.Series(index=L, dtype=float).fillna(0.0) -ECOMI = pd.Series(index=L, dtype=float).fillna(0.0) -ECOMO = pd.Series(index=CM, dtype=float).fillna(0.0) -HOUSECOR = pd.DataFrame(index=H, columns=HSD).fillna(0.0) -JOBCOR = pd.DataFrame(index=H, columns=L).fillna(0.0) - -LAMBDA = pd.DataFrame(index=I, columns=I).fillna(0.0) -LAMBDAH = pd.DataFrame(index=HSD, columns=HSD1).fillna(0.0) - -NRPG = pd.Series(index=H, dtype=float).fillna(0.0) -RHO = pd.Series(index=I, dtype=float).fillna(0.0) -TT = pd.DataFrame(index=Z, columns=IG).fillna(0.0) - -depr = pd.Series(index=IG, dtype=float).fillna(0.1) - -# ARRAYS BUILT TO EXPORT RESULTS TO SEPARATE FILE - -R1 = pd.DataFrame(index=R1H, columns=SM).fillna(0.0) -R2 = pd.DataFrame(index=R2H, columns=SM).fillna(0.0) - -# INITIAL VALUES OF ENDOGENOUS VARIABLES - -CG0 = pd.DataFrame(index=I, columns=G).fillna(0.0) -CG0T = pd.DataFrame(index=I, columns=G).fillna(0.0) -CH0 = pd.DataFrame(index=I, columns=H).fillna(0.0) -CH0T = pd.DataFrame(index=I, columns=H).fillna(0.0) -CMI0 = pd.Series(index=L, dtype=float).fillna(0.0) -CMO0 = pd.Series(index=CM, dtype=float).fillna(0.0) -CN0 = pd.Series(index=I, dtype=float).fillna(0.0) -CN0T = pd.Series(index=I, dtype=float).fillna(0.0) -CPI0 = pd.Series(index=H, dtype=float).fillna(0.0) -CPIN0 = pd.Series(index=H, dtype=float).fillna(0.0) -CPIH0 = pd.Series(index=H, dtype=float).fillna(0.0) -CX0 = pd.Series(index=I, dtype=float).fillna(0.0) -D0 = pd.Series(index=I, dtype=float).fillna(0.0) -DD0 = pd.Series(index=Z, dtype=float).fillna(0.0) -DS0 = pd.Series(index=Z, dtype=float).fillna(0.0) -DQ0 = pd.Series(index=Z, dtype=float).fillna(0.0) - -FD0 = pd.DataFrame(index=F, columns=Z).fillna(0.0) -IGT0 = pd.DataFrame(index=G, columns=GX).fillna(0.0) -KS0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) -KSNEW = pd.DataFrame(index=K, columns=IG).fillna(0.0) -KSNEW0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) -HH0 = pd.Series(index=H, dtype=float).fillna(0.0) -HN0 = pd.Series(index=H, dtype=float).fillna(0.0) -HW0 = pd.Series(index=H, dtype=float).fillna(0.0) -M0 = pd.Series(index=I, dtype=float).fillna(0.0) -M01 = pd.Series(index=Z, dtype=float).fillna(0.0) -MI0 = pd.Series(index=H, dtype=float).fillna(0.0) -MO0 = pd.Series(index=H, dtype=float).fillna(0.0) -N0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) - -# NKIO - -KPFOR01 = pd.Series(index=K, dtype=float).fillna(0.0) -KPFOR0 = pd.Series(index=K, dtype=float).fillna(0.0) -GVFOR0 = pd.Series(index=G, dtype=float).fillna(0.0) -P0 = pd.Series(index=IG, dtype=float).fillna(0.0) -PH0 = pd.Series(index=HSD, dtype=float).fillna(0.0) -PD0 = pd.Series(index=I, dtype=float).fillna(0.0) -PVA0 = pd.Series(index=I, dtype=float).fillna(0.0) -PWM0 = pd.Series(index=I, dtype=float).fillna(0.0) -PW0 = pd.Series(index=I, dtype=float).fillna(0.0) -Q0 = pd.Series(index=Z, dtype=float).fillna(0.0) -Q10 = pd.Series(index=Z, dtype=float).fillna(0.0) -R0 = pd.DataFrame(index=F, columns=Z).fillna(1.0) -RA0 = pd.Series(index=F, dtype=float).fillna(0.0) -S0 = pd.Series(index=Z, dtype=float).fillna(0.0) - -# SPIO - -V0 = pd.Series(index=I, dtype=float).fillna(0.0) -V0T = pd.Series(index=I, dtype=float).fillna(0.0) -V10 = pd.DataFrame(index=I, columns=I).fillna(0.0) -TP = pd.DataFrame(index=H, columns=G).fillna(0.0) - -# TAUF0 = Table(G,F,Z) - -YD0 = pd.Series(index=H, dtype=float).fillna(0.0) -Y0 = pd.Series(index=Z, dtype=float).fillna(0.0) -Y01 = pd.Series(index=H, dtype=float).fillna(0.0) -YT0 = pd.Series(index=G, dtype=float).fillna(0.0) -GCP10 = pd.Series(index=I, dtype=float).fillna(0.0) - -# GCP0 - -DDCX = pd.Series(index=I, dtype=float).fillna(0.0) -''' -TEST1 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST2 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST3 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST4 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST5 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST6 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST7 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST8 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST9 = pd.Series(index=H, dtype=float).fillna(0.0) -TEST10 = pd.Series(index=H, dtype=float).fillna(0.0) -''' - -# SIMPLIFYING TABLES AND DOING AWAY WITH MISC FILES - -for label in G1: - out.loc[label, label] = 0 -out.loc['MEMPHIS', 'CYGFM'] = 1 -out.loc['OTHER', 'CYGFO'] = 1 - -IGTD.loc[G, G1] = 0 -IGTD.loc['FED', GFUS] = 1 -IGTD.loc['FED', 'USPIT'] = 1 - -IGTD.loc['CYGFM', 'MEMPROPTAX'] = 1 -IGTD.loc['CYGFM', 'MEMSALESTAX'] = 1 -IGTD.loc['CYGFM', 'MEMFEE'] = 1 - -IGTD.loc['CYGFO', 'OTHERPROPTAX'] = 1 -IGTD.loc['CYGFO', 'OTHERSALESTAX'] = 1 -IGTD.loc['CYGFO', 'OTHERFEE'] = 1 - -IGTD.loc['STATE', 'TNSTX'] = 1 -IGTD.loc['STATE', 'TNITAX'] = 1 - -TPC.loc[H, G] = 0 -TPC.loc[H, GFUS] = 1 - -TAUFF.loc[G, F] = 0 -TAUFF.loc['USSOCL1A', 'L1A'] = 1 -TAUFF.loc['USSOCL2A', 'L2A'] = 1 -TAUFF.loc['USSOCL3A', 'L3A'] = 1 -TAUFF.loc['USSOCL1B', 'L1B'] = 1 -TAUFF.loc['USSOCL2B', 'L2B'] = 1 -TAUFF.loc['USSOCL3B', 'L3B'] = 1 -TAUFF.loc['USSOCL1C', 'L1C'] = 1 -TAUFF.loc['USSOCL2C', 'L2C'] = 1 -TAUFF.loc['USSOCL3C', 'L3C'] = 1 -TAUFF.loc['USSOCL1D', 'L1D'] = 1 -TAUFF.loc['USSOCL2D', 'L2D'] = 1 -TAUFF.loc['USSOCL3D', 'L3D'] = 1 -TAUFF.loc['USSOCL1E', 'L1E'] = 1 -TAUFF.loc['USSOCL2E', 'L2E'] = 1 -TAUFF.loc['USSOCL3E', 'L3E'] = 1 -TAUFF.loc['USSOCL1F', 'L1F'] = 1 -TAUFF.loc['USSOCL2F', 'L2F'] = 1 -TAUFF.loc['USSOCL3F', 'L3F'] = 1 -TAUFF.loc['USSOCL1G', 'L1G'] = 1 -TAUFF.loc['USSOCL2G', 'L2G'] = 1 -TAUFF.loc['USSOCL3G', 'L3G'] = 1 -TAUFF.loc['USSOCL1H', 'L1H'] = 1 -TAUFF.loc['USSOCL2H', 'L2H'] = 1 -TAUFF.loc['USSOCL3H', 'L3H'] = 1 - -TAUFF.loc['MEMPROPTAX', 'KAP'] = 1 -TAUFF.loc['OTHERPROPTAX', 'KAP'] = 1 - -for label in G1: - IOUT.loc[label, label] = 0 -IOUT.loc['MEMPHIS', 'CYGFM'] = 1 -IOUT.loc['OTHER', 'CYGFO'] = 1 - -LANDCAP.loc[IG, ETALANDCAP] = 1 -MISCH.loc[H, ETAMISCH] = 0 -MISCH.loc[HH1, 'ETAPT'] = -0.5 -MISCH.loc[HH2, 'ETAPIT'] = -0.15 -MISCH.loc[HH3, 'ETAPIT'] = -0.2 -MISCH.loc[HH4, 'ETAPIT'] = -0.25 -MISCH.loc[HH5, 'ETAPIT'] = -0.35 - -MISCH.loc[H, 'NRPG'] = 1 -MISC.loc[IG, ETAMISC] = 0 -MISC.loc[IP, 'ETAM'] = 1 -MISC.loc[I, 'ETAY'] = 1 -MISC.loc[I, 'ETAOP'] = -1 - -# PARAMETERS AND ELASTICITIES - -out.loc[G1, G1] = IOUT.loc[G1, G1] -BETA.loc[I, H] = MISC.loc[I, 'ETAY'] -BETAH.loc[HSD, H] = MISC.loc[HSD, 'ETAY'] - -for label in I: - LAMBDA.loc[label, label] = MISC.loc[label, 'ETAOP'] - -ETAE.loc[I] = MISC.loc[I, 'ETAE'] -ETAM.loc[I] = MISC.loc[I, 'ETAM'] -ETARA.loc[H] = MISCH.loc[H, 'ETARA'] - -ETAPIT.loc[H] = MISCH.loc[H, 'ETAPIT'] -ETAPT.loc[H] = MISCH.loc[H, 'ETAPT'] -ETAYD.loc[H] = MISCH.loc[H, 'ETAYD'] -NRPG.loc[H] = MISCH.loc[H, 'NRPG'] -ETAU.loc[H] = MISCH.loc[H, 'ETAU'] -ETAI.loc[IG] = LANDCAP.loc[IG, 'ETAI1'] -ETAIX.loc['KAP', IG] = ETAI.loc[IG] - -# play with elasticities - -# EXPERIMENTAL ELASTICITIES -ECOMI.loc[L] = 1 -ECOMO.loc[CM] = 1 -EXWGEO.loc[CM] = 1 -EXWGEI.loc[L] = 1 -ETAE.loc[IP] = -0.4 -ETAIX.loc['KAP', IG] = 0.1 -ETARA.loc[H] = 1.5 -ETAYDO.loc[H] = 1.0 -ETAYDI.loc[H] = 1.5 -ETAUI.loc[H] = -0.72 -ETAUO.loc[HH1] = -0.8 -ETAUO.loc[HH2] = -0.6 -ETAUO.loc[HH3] = -0.4 -ETAUO.loc[HH4] = -0.2 -ETAUO.loc[HH5] = -0.2 -ETAU.loc[H] = -0.1 -ETAYD.loc[H] = 1 - -# CALIBRATION - -# Column Totals of SAM table -Q10.loc[Z] = SAM.loc[Z, Z].sum(1) - -# Row Totals of SAM table -Q0.loc[Z] = SAM.loc[Z, Z].sum(0) - -# difference of SAM row and coloumn totals -DQ0.loc[Z] = Q10.loc[Z] - Q0.loc[Z] - -# Column Totals of SAM table -Q10.loc[Z] = SAM.loc[Z].sum(0) - -B1.loc[I, I] = SAM.loc[I, I] - -# Calculate tax rates from SAM information -TAUQ_1 = SAM.loc[GS, I] -TAUQ_2 = SAM.loc[I, I].sum(1) -TAUQ_3 = SAM.loc[I, H].sum(1) -TAUQ_4 = SAM.loc[I, ['INVES']].sum(1) -TAUQ_5 = SAM.loc[I, G].sum(1) -TAUQ_6 = SAM.loc[I, ['ROW']].sum(1) -TAUQ_7 = SAM.loc[GS1, I].sum(0) - -TAUQ.loc[GS, I] = TAUQ_1 / (TAUQ_2 + TAUQ_3 + TAUQ_4 + TAUQ_5 + TAUQ_6 - TAUQ_7) - -# NOTE: -# set taxes to average if not specific to model -TAUC.loc[GS, I] = TAUQ.loc[GS, I] -TAUV.loc[GS, I] = TAUQ.loc[GS, I] -TAUN.loc[GS, I] = TAUQ.loc[GS, I] -TAUG.loc[GS, I] = TAUQ.loc[GS, I] -TAUX.loc[GS, I] = TAUQ.loc[GS, I] - -# FACTOR TAX RATES -TAUFarray = [[[0 for k in range(len(Z))] for j in range(len(F))] for i in range(len(G))] -for i in range(len(GF)): - for j in range(len(F)): - for k in range(len(I)): - if SAM.loc[F[j], I[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: - TAUFarray[G.index(GF[i])][j][Z.index(I[k])] = SAM.loc[GF[i], I[k]] / SAM.loc[F[j], I[k]] - -for i in range(len(GF)): - for j in range(len(F)): - for k in range(len(G)): - if SAM.loc[F[j], G[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: - TAUFarray[G.index(GF[i])][j][Z.index(G[k])] = SAM.loc[GF[i], G[k]] / SAM.loc[F[j], G[k]] - -TAUFX_SUM_array = [[0 for j in range(len(Z))] for i in range(len(F))] -for i in range(len(F)): - for j in range(len(Z)): - tmp = 0 - for k in range(len(G)): - tmp += TAUFarray[k][i][j] - TAUFX_SUM_array[i][j] = tmp - -# TAUFX summed over GX -TAUFX_SUM = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) - -TAUFX_GF = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) - -TAUFXgx = {} -for i in range(len(GX)): - TAUFXgx[GX[i]] = pd.DataFrame(TAUFarray[i], index=F, columns=Z).fillna(0.0) - -# SS TAX RATES -for i in GF: - for j in F: - if TAUFF.loc[i, j] != 0: - TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[Z, F].sum(0).at[j] - -for i in GFUS: - for j in L: - if TAUFF.loc[i, j] != 0: - TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[L, IG].sum(1).at[j] - -# EMPLOYEE PORTION OF FACTOR TAXES -TAUFL.loc[GF, L] = SAM.loc[GF, L] / (SAM.loc[Z, L].sum(0) - SAM.loc[L, ['ROW']].sum(1)) - -TAUFK.loc[GF, K] = SAM.loc[GF, K] / SAM.loc[Z, K].sum(0) - -# SHARES OF ENDOGENOUS GOVERNMENTS TRANFERS TO REVENUE -TAXS.loc[G, GX] = SAM.loc[G, GX] / SAM.loc[G, GX].sum(0) - -TAXS1.loc[GNLM] = SAM.loc[GNLM, ['CYGFM']].sum(1) / SAM.loc[GNLM, ['CYGFM']].sum(1).sum(0) - -TAXS2.loc[GNLO] = SAM.loc[GNLO, ['CYGFO']].sum(1) / SAM.loc[GNLO, ['CYGFO']].sum(1).sum(0) - -# SET INITIAL INTER GOVERNMENTAL TRANSFERS -IGT0.loc[G, GX] = SAM.loc[G, GX] - -# SET INITIAL PRICES TO UNITY LESS SALES AND EXCISE TAXES -PW0.loc[I] = 1.0 -PWM0.loc[I] = 1.0 -P0.loc[I] = 1.0 -PD0.loc[I] = 1.0 -CPI0.loc[H] = 1.0 -CPIN0.loc[H] = 1.0 -CPIH0.loc[H] = 1.0 -TT.loc[F, IG] = 1.0 - -# HOUSEHOLD TRANSFER PAYMENTS AND PERSONAL INCOME TAXES -# TOTAL HH IN Shelby -HH0.loc[H] = HHTABLE.loc[H, 'HH0'] - -# TOTAL WORKING HH IN SHELBY (WORK IN SHELBY & OUTSIDE SHELBY) -HW0.loc[H] = HHTABLE.loc[H, 'HW0'] - -# NON WORKING HH IN SHELBY -HN0.loc[H] = HH0.loc[H] - HW0.loc[H] - -# NOMINAL GOVERNMENT SS PAYMENTS -TP.loc[H, G] = SAM.loc[H, G].div(HH0.loc[H], axis='index').fillna(0.0) - -# FACTOR RENTALS -JOBCOR.loc[H, L] = JOBCR.loc[H, L] - -# RENTAL RATE FOR FACTORS -R0.loc[F, Z] = 1.0 - -R0.loc[F, IG] = (SAM.loc[F, IG] / EMPLOY.loc[IG, F].T).fillna(1.0) - -# REAL FACTOR DEMAND -FD0.loc[F, IG] = EMPLOY.loc[IG, F].T - -KS0.loc[K, IG] = FD0.loc[K, IG] - -# SHARES FOUND IN THE SOCIAL ACCOUNTING MATRIX DATA -# A = INPUT OUTPUT COEFICIENTS -A.loc[Z, Z] = SAM.loc[Z, Z].div(Q0.loc[Z], axis='columns') - - -# AGFS: LABOR PAYMENTS BY G SECTOR + USSOC PAYMENTS BY LABOR (GROSS LABOR PAYMENTS) -AGFS.loc['L1A', G] = SAM.loc['L1A', G] + SAM.loc['USSOCL1A', G] -AGFS.loc['L2A', G] = SAM.loc['L2A', G] + SAM.loc['USSOCL2A', G] -AGFS.loc['L3A', G] = SAM.loc['L3A', G] + SAM.loc['USSOCL3A', G] - -AGFS.loc['L1B', G] = SAM.loc['L1B', G] + SAM.loc['USSOCL1B', G] -AGFS.loc['L2B', G] = SAM.loc['L2B', G] + SAM.loc['USSOCL2B', G] -AGFS.loc['L3B', G] = SAM.loc['L3B', G] + SAM.loc['USSOCL3B', G] - -AGFS.loc['L1C', G] = SAM.loc['L1C', G] + SAM.loc['USSOCL1C', G] -AGFS.loc['L2C', G] = SAM.loc['L2C', G] + SAM.loc['USSOCL2C', G] -AGFS.loc['L3C', G] = SAM.loc['L3C', G] + SAM.loc['USSOCL3C', G] - -AGFS.loc['L1D', G] = SAM.loc['L1D', G] + SAM.loc['USSOCL1D', G] -AGFS.loc['L2D', G] = SAM.loc['L2D', G] + SAM.loc['USSOCL2D', G] -AGFS.loc['L3D', G] = SAM.loc['L3D', G] + SAM.loc['USSOCL3D', G] - -AGFS.loc['L1E', G] = SAM.loc['L1E', G] + SAM.loc['USSOCL1E', G] -AGFS.loc['L2E', G] = SAM.loc['L2E', G] + SAM.loc['USSOCL2E', G] -AGFS.loc['L3E', G] = SAM.loc['L3E', G] + SAM.loc['USSOCL3E', G] - -AGFS.loc['L1F', G] = SAM.loc['L1F', G] + SAM.loc['USSOCL1F', G] -AGFS.loc['L2F', G] = SAM.loc['L2F', G] + SAM.loc['USSOCL2F', G] -AGFS.loc['L3F', G] = SAM.loc['L3F', G] + SAM.loc['USSOCL3F', G] - -AGFS.loc['L1G', G] = SAM.loc['L1G', G] + SAM.loc['USSOCL1G', G] -AGFS.loc['L2G', G] = SAM.loc['L2G', G] + SAM.loc['USSOCL2G', G] -AGFS.loc['L3G', G] = SAM.loc['L3G', G] + SAM.loc['USSOCL3G', G] - -AGFS.loc['L1H', G] = SAM.loc['L1H', G] + SAM.loc['USSOCL1H', G] -AGFS.loc['L2H', G] = SAM.loc['L2H', G] + SAM.loc['USSOCL2H', G] -AGFS.loc['L3H', G] = SAM.loc['L3H', G] + SAM.loc['USSOCL3H', G] - -# AG - GOVERNMENT SPENDING SHARES OF NET INCOME -AG_1 = SAM.loc[I, G] -AG_2 = SAM.loc[I, G].sum(0) + SAM.loc[F, G].sum(0) + SAM.loc[GF, G].sum(0) -AG.loc[I, G] = AG_1 / AG_2 - -AG_1 = SAM.loc[F, G] -AG.loc[F, G] = AG_1 / AG_2 - -AG_1 = AGFS.loc[L, G] -AG.loc[L, G] = AG_1 / AG_2 -AG = AG.fillna(0.0) - -# TRADE INTERMEDIATES CONSUMPTION INVESTMENT INITIAL LEVELS - -# REAL EXPORT CONSUMPTION -CX0.loc[I] = SAM.loc[I, ["ROW"]].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index').sum(1) - -# REAL IMPORTS -M01.loc[I] = SAM.loc[["ROW"], I].sum(0) / PWM0[I].T - -M0.loc[IP] = SAM.loc[IP, Z].sum(1) - (B1.loc[I, IP].sum(0) + SAM.loc[F, IP].sum(0) + SAM.loc[G, IP].sum(0)) - -M0.loc[I] = (M0[I] / PWM0[I]) -M0 = M0.fillna(0.0) - -# * REAL INTERMEDIATE DEMAND -V0.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] / (1.0 + TAUQ.loc[GS, I].sum(0)) -V0T.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] - -# REAL PRIVATE CONSUMPTION -CH0.loc[I, H] = SAM.loc[I, H].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') - -CH0T.loc[I, H] = SAM.loc[I, H].div(P0[I], axis='index') - -CG0.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index').div((1.0 + TAUQ.loc[GS, I].sum(0)), axis='index') - -CG0T.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index') - -DEPR = float((SAM.loc[IG, ["INVES"]].sum(0)) / (KS0.loc[K, IG].sum(1).sum(0))) - -N0.loc[K, IG] = KS0.loc[K, IG] * DEPR - -# INVESTMENT BY SECTOR OF SOURCE -CN0.loc[I] = 0.0 - -B.loc[I, IG] = BB.loc[I, IG].fillna(0.0) - -CN0.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index').div( - 1.0 + TAUN.loc[GS, I].sum(0), axis='index').transpose() - -CN0T.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index') - -DD0.loc[I] = CH0.loc[I, H].sum(1) + CG0.loc[I, G].sum(1) + CN0.loc[I] + V0.loc[I] - -D0.loc[I] = 1.0 - M0.loc[I] / DD0.loc[I] - -# CORRECT IMPORT ELASTICITY TO DOMESTIC SHARE ELASTICITY -ETAD.loc[I] = -1.0 * ETAM.loc[I] * M0.loc[I] / (DD0.loc[I] * D0.loc[I]) - -# PRODUCTION DATA -DS0.loc[I] = DD0.loc[I] + CX0.loc[I] - M0.loc[I] - -AD.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') / DS0.loc[I] - -V10.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') - -PVA0.loc[I] = PD0.loc[I] - ( - AD.loc[I, I].mul(P0.loc[I], axis='index').mul(1.0 + TAUQ.loc[GS, I].sum(0).T, axis='index').sum(0).T) - -# AVERAGE RENTAL RATES FOR FACTORS (NORMALIZED) -RA0.loc[F] = 1.0 - -# CALIBRATION OF PRODUCTION EXPONENTS FOR COBB DOUGLAS -a = SAM.loc['MEMPROPTAX', I] + SAM.loc['OTHERPROPTAX', I] -a = SAM.loc[GFUS, I].append(a, ignore_index=True) # labor, capital -a.index = F - -ALPHA.loc[F, I] = (SAM.loc[F, I] + a.loc[F, I]) / (SAM.loc[F, I].sum(0) + SAM.loc[GF, I].sum(0)) -ALPHA.loc[F, I] = ALPHA.loc[F, I] / ALPHA.loc[F, I].sum(0) - -ACK = pd.Series(index=I, dtype=float).fillna(0.0) -ACK.loc[I] = SAM.loc[F, I].sum(0) - -# replace takes care of multiplying by zeros, by changing zeros to ones. -DELTA.loc[I] = DS0.loc[I] / (FD0.loc[F, I] ** ALPHA.loc[F, I]).replace({0: 1}).product(0) - -SIGMA.loc[I] = 0.67 -RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] - -ATEST1 = pd.Series(index=I, dtype=float).fillna(0.0) -ATEST1.loc[I] = ALPHA.loc[F, I].sum(0) - -GAMMA.loc[I] = DS0.loc[I] / (((ALPHA.loc[F, I] * FD0.loc[F, I] ** (RHO.loc[I])).sum(0)) ** (1 / RHO.loc[I])) - -# OTHER DATA -# HH INVESTMENT INCOME FROM ROW -PRIVRET.loc[H] = SAM.loc[Z, H].sum(0) - (SAM.loc[H, F].sum(1) + SAM.loc[H, CM].sum(1) + SAM.loc[H, GX].sum(1)) - -PRIVRET.loc[H] = PRIVRET.loc[H] / HH0.loc[H] - -# TOTAL OUTPUT -Y0.loc[F] = SAM.loc[F, IG].sum(1) - -KPFOR01.loc[K] = SAM.loc[K, ["ROW"]].sum(1) - -# NOMINAL CAPITAL OUTFLOW -KPFOR0[K] = SAM.loc[Z, K].sum(0).T - SAM.loc[K, IG].sum(1) - -# NOMINAL GOVERNMENT OUTFLOWS -GVFOR0.loc[G] = SAM.loc[G, ["ROW"]].sum(1) -''' -GVFOR0.loc[GT] = SAM.loc[Z, GT].sum(0) - ( - SAM.loc[GT, I].sum(1) - + SAM.loc[GT, F].sum(1) - + SAM.loc[GT, H].sum(1) - + SAM.loc[GT, G].sum(1) - ) -''' - -# ORIGINAL EQUATION -A.loc[H, L] = SAM.loc[H, L].div(HW0.loc[H], axis='index') / ( - Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) + SAM.loc[L, ["ROW"]].sum(1)) - -A.loc[H, K] = SAM.loc[H, K].div(HW0.loc[H], axis='index') / ( - Y0.loc[K] + SAM.loc[Z, K].sum(0) - SAM.loc[K, IG].sum(1)) - -# HH TAXES OTHER THAN PIT -TAUH.loc[GH, H] = SAM.loc[GH, H].div(HH0.loc[H], axis='columns') - -S0.loc[H] = SAM.loc[["INVES"], H].T.sum(1) - -YD0.loc[H] = SAM.loc[I, H].sum(0).T + S0.loc[H] - -Y0.loc[G] = SAM.loc[G, Z].sum(1) - SAM.loc[G, ["ROW"]].sum(1) - -S0.loc[G] = SAM.loc[["INVES"], G].sum(0) - -# COMMUTING IN -CMI0.loc[L] = FD0.loc[L, IG].sum(1) - JOBCOR.loc[H, L].mul(HW0.loc[H], axis='index').sum(0) - -# COMMUTING OUT -CMO0.loc[["OUTCOM1"]] = 46206.0 -CMO0.loc[["OUTCOM2"]] = 24294.0 -CMO0.loc[["OUTCOM3"]] = 13514.0 - -# AVERAGE WAGE FLOWING INTO SHELBY -CMOWAGE.loc[CM] = SAM.loc[CM, ["ROW"]].sum(1).div(CMO0.loc[CM], axis='index').fillna(0.0) - -# AVERAGE WAGES FLOWING OUT OF SHELBY -CMIWAGE.loc[L] = (-1) * (SAM.loc[L, ["ROW"]].sum(1).div(CMI0.loc[L], axis='index').fillna(0.0)) - -# PROPORTION OF CAPITAL INCOME OUTFLOW -KFOR.loc[K] = KPFOR0.loc[K] / SAM.loc[["KAP"], IG].sum(1) - -# PROPORTION OF GOVERNMENT INCOME OUTFLOW -GFOR.loc[G] = GVFOR0.loc[G] / Y0.loc[G] - -A.loc[H, CM] = SAM.loc[H, CM].div(SAM.loc[Z, CM].sum(0), axis='columns') - -# NOMINAL NET CAPITAL INFLOW -NKI0 = (M0.loc[I] * PWM0.loc[I]).sum(0) - (CX0.loc[I] * PD0.loc[I]).sum(0) - \ - (PRIVRET.loc[H] * HH0.loc[H]).sum(0) - \ - KPFOR0.loc[K].sum(0) - GVFOR0.loc[G].sum(0) - \ - (CMOWAGE.loc[CM] * CMO0.loc[CM]).sum(0) - \ - (CMIWAGE.loc[L] * CMI0.loc[L]).sum(0) - -# REAL HH NET INCOME -Y0.loc[H] = (A.loc[H, L].mul(HW0[H], axis='index').div(A.loc[H, L].mul(HW0[H], axis='index').sum(0), axis='columns') \ - .mul(Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) - (CMIWAGE.loc[L] * CMI0.loc[L]), axis='columns')).sum(1) \ - + (A.loc[H, CM].mul((CMOWAGE.loc[CM] * CMO0.loc[CM]), axis='columns')).sum(1) \ - + (A.loc[H, K].mul(HW0[H], axis='index') / A.loc[H, K].mul(HW0[H], axis='index').sum(0) \ - * (Y0[K] * (1.0 - TAUFK.loc[G, K].sum(0)) + KPFOR0.loc[K])).sum(1) - -# PERSONAL INCOME OBJECTIVE FUNCTION -SPI0 = (Y0.loc[H].sum(0) + - TP.loc[H, G].mul(HH0.loc[H], axis='index').sum(1).sum(0) + - (PRIVRET[H] * HH0[H]).sum(0)) - -# PERSONAL INCOME TAX -PIT.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') - -PIT0.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') - -MI0.loc[H] = HH0.loc[H] * 0.04 - -MO0.loc[H] = HH0.loc[H] * 0.04 - -GCP0 = CH0.loc[I, H].sum(1).sum(0) + CN0.loc[I].sum(0) + CG0.loc[I, GN].sum(1).sum(0) + CX0.loc[I].sum(0) - M0.loc[ - I].sum(0) - -GCP10.loc[I] = CH0.loc[I, H].sum(1) + CN0.loc[I] + CG0.loc[I, GN].sum(1) + CX0.loc[I] + M0.loc[I] - -########################################### -# VARIABLE DECLARATION -########################################### - -vars = VarContainer() - -# PUBLIC CONSUMPTION -CG = vars.add('CG', rows=I, cols=G) - -# PRIVATE CONSUMPTION -CH = vars.add('CH', rows=I, cols=H) - -# COMMUTING IN -CMI = vars.add('CMI', rows=L) - -# COMMUTING OUT JASPER -CMO = vars.add('CMO', rows=CM) - -# GROSS INVESTMENT BY SECTOR OF SOURCE -CN = vars.add('CN', rows=I) - -# CONSUMER PRICE INDEX -CPI = vars.add('CPI', rows=H) - -# NONHOUSING CONSUMER PRICE INDEX -CPIN = vars.add('CPIN', rows=H) - -# HOUSING CONSUMER PRICE INDEX -CPIH = vars.add('CPIH', rows=H) - -# EXPORT DEMAND -CX = vars.add('CX', rows=I) - -# DOMESTIC SHARE OF DOMESTIC DEMAND -D = vars.add('D', rows=I) - -# DOMESTIC DEMAND -DD = vars.add('DD', rows=I) - -# DOMESTIC SUPPLY -DS = vars.add('DS', rows=I) - -# SECTORAL FACTOR DEMAND -# FD = vars.add('FD', rows=F, cols=Z) -FD = vars.add('FD', rows=F, cols=Z) - -# GROSS AGGREGATE CITY PRODUCT -GCP = vars.add('GCP') - -# GROSS CITY PRODUCT BY SECTOR -GCP1 = vars.add('GCP1', rows=I) - -# NUMBER OF HOUSEHOLDS -HH = vars.add('HH', rows=H) - -# NUMBER OF NONWORKING HOUSEHOLDS -HN = vars.add('HN', rows=H) - -# NUMBER OF WORKING HOUSEHOLDS -HW = vars.add('HW', rows=H) - -# INTER GOVERNMENTAL TRANSFERS -IGT = vars.add('IGT', rows=G, cols=GX) - -# CAPITAL FLOW -KS = vars.add('KS', rows=K, cols=IG) - -# IMPORTS -M = vars.add('M', rows=I) - -# GROSS INVESTMENT BY SECTOR OF DESTINATION -N = vars.add('N', rows=K, cols=IG) - -# NET CAPITAL INFLOW -NKI = vars.add('NKI') - -# CAPITAL OUTFLOW -KPFOR = vars.add('KPFOR', rows=K) - -# GOVT OUTFLOW -GVFOR = vars.add('GVFOR', rows=G) - -# AGGREGATE DOMESTIC PRICE PAID BY PURCHASERS -P = vars.add('P', rows=I) - -# DOMESTIC PRICE RECEIVED BY SUPPLIERS -PD = vars.add('PD', rows=I) - -# VALUE ADDED PRICE -PVA = vars.add('PVA', rows=I) - -# ECONOMY WIDE SCALAR RENTAL RATES OF FACTORS -RA = vars.add('RA', rows=F) - -# SECTORAL RENTAL RATES -R = vars.add('R', rows=F, cols=Z) - -# SAVINGS -S = vars.add('S', rows=Z) - -# PERSONAL INCOME (OBJECTIVE FUNCTION) -SPI = vars.add('SPI') - -# INTERMEDIATE GOODS -V = vars.add('V', rows=I) - -# additional variable -V1 = vars.add('V1', rows=I, cols=I) - -# GROSS INCOMES -Y = vars.add('Y', rows=Z) - -# AFTER TAX TOTAL HOUSEHOLD INCOMES -YD = vars.add('YD', rows=H) - -# INITIALIZE VARIABLES FOR SOLVER - -vars.init('CG', CG0.loc[I, G]) -vars.init('CH', CH0.loc[I, H]) -vars.init('CMI', CMI0.loc[L]) -vars.init('CMO', CMO0.loc[CM]) -vars.init('CN', CN0.loc[I]) -vars.init('CPI', CPI0.loc[H]) -vars.init('CPIN', CPIN0.loc[H]) -vars.init('CPIH', CPIH0.loc[H]) -vars.init('CX', CX0.loc[I]) -vars.init('D', D0.loc[I]) -vars.init('DD', DD0.loc[I]) -vars.init('DS', DS0.loc[I]) -vars.init('FD', FD0.loc[F, Z]) -vars.init('GCP', GCP0) -vars.init('GCP1', GCP10.loc[I]) -vars.init('HH', HH0.loc[H]) -vars.init('HN', HN0.loc[H]) -vars.init('HW', HW0.loc[H]) -vars.init('IGT', IGT0.loc[G, GX]) -vars.init('KS', KS0.loc[K, IG]) -# vars.init('LAS', LAS0.loc[LA, IG]) -vars.init('M', M0.loc[I]) -vars.init('N', N0.loc[K, IG]) -vars.init('NKI', NKI0) -# vars.init('LNFOR', LNFOR0.loc[LA]) -vars.init('KPFOR', KPFOR0.loc[K]) -vars.init('GVFOR', GVFOR0.loc[G]) -vars.init('P', P0.loc[I]) -vars.init('PD', PD0.loc[I]) -vars.init('PVA', PVA0.loc[I]) -vars.init('RA', RA0.loc[F]) -vars.init('R', R0.loc[F, Z]) -vars.init('S', S0.loc[Z]) -vars.init('SPI', SPI0) -vars.init('V', V0.loc[I]) -vars.init('V1', V10.loc[I, I]) -vars.init('Y', Y0.loc[Z]) -vars.init('YD', YD0.loc[H]) - -# DEFINE BOUNDS FOR VARIABLES - -vars.lo('P', vars.get('P') / 1000) -vars.up('P', vars.get('P') * 1000) -vars.lo('PD', vars.get('PD') / 1000) -vars.up('PD', vars.get('PD') * 1000) -vars.lo('PVA', vars.get('PVA') / 1000) -vars.up('PVA', vars.get('PVA') * 1000) -vars.lo('RA', vars.get('RA') / 1000) -vars.up('RA', vars.get('RA') * 1000) -vars.lo('CPI', vars.get('CPI') / 1000) -vars.up('CPI', vars.get('CPI') * 1000) -vars.lo('CMI', vars.get('CMI') / 1000) -vars.up('CMI', vars.get('CMI') * 1000) -vars.lo('CMO', vars.get('CMO') / 1000) -vars.up('CMO', vars.get('CMO') * 1000) -vars.lo('DS', vars.get('DS') / 1000) -vars.up('DS', vars.get('DS') * 1000) -vars.lo('DD', vars.get('DD') / 1000) -vars.up('DD', vars.get('DD') * 1000) -vars.lo('D', vars.get('D') / 1000) -vars.up('D', vars.get('D') * 1000) -vars.lo('V', vars.get('V') / 1000) -vars.up('V', vars.get('V') * 1000) -vars.lo('FD', vars.get('FD') / 1000) -vars.up('FD', vars.get('FD') * 1000) -vars.lo('HH', vars.get('HH') / 1000) -vars.up('HH', vars.get('HH') * 1000) -vars.lo('HW', vars.get('HW') / 1000) -vars.up('HW', vars.get('HW') * 1000) -vars.lo('HN', vars.get('HN') / 1000) -vars.up('HN', vars.get('HN') * 1000) -vars.lo('KS', vars.get('KS') / 1000) -vars.up('KS', vars.get('KS') * 1000) -vars.lo('M', vars.get('M') / 1000) -vars.up('M', vars.get('M') * 1000) -vars.lo('Y', vars.get('Y') / 1000) -vars.up('Y', vars.get('Y') * 1000) -vars.lo('YD', vars.get('YD') / 1000) -vars.up('YD', vars.get('YD') * 1000) -vars.lo('CH', vars.get('CH') / 1000) -vars.up('CH', vars.get('CH') * 1000) -vars.lo('CG', vars.get('CG') / 1000) -vars.up('CG', vars.get('CG') * 1000) -vars.lo('CX', vars.get('CX') / 1000) -vars.up('CX', vars.get('CX') * 1000) -vars.lo('R', vars.get('R') / 1000) -vars.up('R', vars.get('R') * 1000) -vars.lo('N', 0) -vars.lo('CN', 0) - - -def set_variable(filname): - # clear the file before write the variables - with open(filename, 'w') as f: - f.write("") - - vars.write(filename) - - -# DEFINE EQUATIONS AND SET CONDITIONS - -def set_equation(filename): - count = [0] - - print('CPIEQ(H)') - line1 = (P.loc(I) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0)) * CH.loc(I, H)).sum(I) - line2 = (ExprM(vars, m=P0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0))) * CH.loc(I, H)).sum(I) - - CPIEQ = (line1 / line2 - ~CPI.loc(H)) - print(CPIEQ.test(vars.initialVals)) - CPIEQ.write(count, filename) - - print('YEQ(H)') - line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * ( - Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * ExprM(vars, - m=CMIWAGE.loc[L]) * CMI.loc( - L))).sum(L) - line2 = (ExprM(vars, m=A.loc[H, CM]) * (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM))).sum(CM) - # line3 = (ExprM(vars, m= A.loc[H,LA]) * HW.loc(H) / (ExprM(vars, m= A.loc[H1,LA]) * HW.loc(H1)).sum(H1) * (Y.loc(LA) + LNFOR.loc(LA) ) * ExprM(vars, m= 1 - TAUFLA.loc[G,LA].sum(0))).sum(LA) - line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * ( - Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) - - YEQ = ((line1 + line2 + line4) - Y.loc(H)) - print(YEQ.test(vars.initialVals)) - YEQ.write(count, filename) - - print('YDEQ(H)') - line1 = Y.loc(H) + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)) - line2 = (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum(G) - line3 = ~(ExprM(vars, m=PIT0.loc[GI, H]) * Y.loc(H)).sum(GI) - line4 = ~(ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum(G) - - YDEQ = ((line1 + line2 - line3 - line4) - YD.loc(H)) - YDEQ.write(count, filename) - print(YDEQ.test(vars.initialVals)) - - print('CHEQ(I,H)') - line1 = ExprM(vars, m=CH0.loc[I, H]) * ( - (YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m= - BETA.loc[I, H]) - line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / ( - ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** ExprM(vars, m=LAMBDA.loc[ - J, I])).prod(0) - - CHEQ = ((line1 * line2) - CH.loc(I, H)) - CHEQ.write(count, filename) - print(CHEQ.test(vars.initialVals)) - # print(CHEQ) - - print('SHEQ(H)') - line = YD.loc(H) - ~((P.loc(I) * CH.loc(I, H) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0))).sum(I)) - - SHEQ = (line - S.loc(H)) - SHEQ.write(count, filename) - print(SHEQ.test(vars.initialVals)) - # print(SHEQ) - - print('PVAEQ(I)') - line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) - - PVAEQ = (line - PVA.loc(I)) - PVAEQ.write(count, filename) - print(PVAEQ.test(vars.initialVals)) - # print(PVAEQ) - - print('PFEQ(I)') - line = ExprM(vars, m=DELTA.loc[I]) * ( - (ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) ** ExprM(vars, m=ALPHA.loc[F, I])).prod(F) - - PFEQ = (line - DS.loc(I)) - PFEQ.write(count, filename) - print(PFEQ.test(vars.initialVals)) - # print(PFEQ) - - print('FDEQ(F,I)') - left = R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I]) * ( - ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) - right = ~(PVA.loc(I) * DS.loc(I) * ExprM(vars, m=ALPHA.loc[F, I])) - - FDEQ = (right - left) - - # FDEQ.test(vars.initialVals) - FDEQ.write(count, filename) - print(FDEQ.test(vars.initialVals)) - # print(FDEQ) - - print('VEQ(I)') - line = (ExprM(vars, m=AD.loc[I, J]) * ~DS.loc(J)).sum(1) - - VEQ = (line - V.loc(I)) - VEQ.write(count, filename) - print(VEQ.test(vars.initialVals)) - # print(VEQ) - - print('YFEQL(L)') - line = (R.loc(F, IG) * RA.loc(F) * FD.loc(F, IG)).sum(IG) - - YFEQL = (line - Y.loc(F)) - YFEQL.write(count, filename) - print(YFEQL.test(vars.initialVals)) - # print(YFEQL) - - print('KAPFOR(K)') - line = ExprM(vars, m=KFOR.loc[K]) * Y.loc(K) - - KAPFOR = (line - KPFOR.loc(K)) - KAPFOR.write(count, filename) - print(KAPFOR.test(vars.initialVals)) - # print(KAPFOR) - - # XEQ(I).. CX(I) =E= CX0(I)*( (PD(I)*(1+SUM(GS,TAUX(GS,I)))) - print('XEQ(I)') - line = ExprM(vars, m=CX0.loc[I]) * ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / ExprM(vars, - m=PW0.loc[I] * ( - 1 + - TAUQ.loc[ - GS, I].sum( - 0)))) ** ExprM( - vars, m=ETAE.loc[I]) - - XEQ = (line - CX.loc(I)) - XEQ.write(count, filename) - print(XEQ.test(vars.initialVals)) - # print(XEQ) - - print('DEQ(I)$PWM0(I)') - line = ExprM(vars, m=D0.loc[I]) * (PD.loc(I) / ExprM(vars, m=PWM0.loc[I])) ** ExprM(vars, m=ETAD.loc[I]) - - DEQ = (line - D.loc(I)) - # DEQ.setCondition(PWM0.loc[I]) - DEQ.write(count, filename) - print(DEQ.test(vars.initialVals)) - # print(DEQ) - - print('MEQ(I)') - line = (1 - D.loc(I)) * DD.loc(I) - - MEQ = (line - M.loc(I)) - MEQ.write(count, filename) - print(MEQ.test(vars.initialVals)) - # print(MEQ) - - print('PEQ(I)') - line = (D.loc(I) * PD.loc(I) + (1 - D.loc(I)) * ExprM(vars, m=PWM0.loc[I])) - - PEQ = (line - P.loc(I)) - PEQ.write(count, filename) - print(PEQ.test(vars.initialVals)) - - print('NKIEQ') - line1 = (M.loc(I) * ExprM(vars, m=PWM0.loc[I])).sum(I) - line2 = (CX.loc(I) * PD.loc(I)).sum(I) - line3 = (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) - line5 = KPFOR.loc(K).sum(K) - line6 = GVFOR.loc(G).sum(G) - line7 = (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM)).sum(CM) - line8 = (ExprM(vars, m=CMIWAGE.loc[L]) * CMI.loc(L)).sum(L) - - NKIEQ = ((line1 - line2 - line3 - line5 - line6 - line7 - line8) - NKI) - NKIEQ.write(count, filename) - print(NKIEQ.test(vars.initialVals)) - # print(NKIEQ) - - print('NEQ(K,I)') - line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** ExprM(vars, m=ETAIX.loc[K, I]) - - NEQ = (line - N.loc(K, I)) - NEQ.write(count, filename) - print(NEQ.test(vars.initialVals)) - # print(NEQ) - - print('CNEQ(I)') - left = P.loc(I) * ExprM(vars, m=1 + TAUN.loc[GS, I].sum(0)) * CN.loc(I) - right = (ExprM(vars, m=B.loc[I, IG]) * N.loc(K, IG).sum(K)).sum(IG) - - CNEQ = (right - left) - CNEQ.write(count, filename) - print(CNEQ.test(vars.initialVals)) - # print(CNEQ) - - print('KSEQ(K,IG)') - line = ExprM(vars, m=KS0.loc[K, IG] * (1 - DEPR)) + N.loc(K, IG) - - KSEQ = (line - KS.loc(K, IG)) - KSEQ.write(count, filename) - print(KSEQ.test(vars.initialVals)) - - print('LSEQ1(H)') - line1 = ExprM(vars, m=HW0.loc[H] / HH0.loc[H]) - LSEQ1line2pre = FD.loc(L, Z).sum(1) - line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) \ - * (LSEQ1line2pre.sum(0) / ( - (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum(CM) + CMI.loc( - L).sum(L))) \ - + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) \ - * (CMO.loc(CM).sum(CM) / ( - (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum( - CM) + CMI.loc(L).sum(L))))) \ - ** ExprM(vars, m=ETARA.loc[H]) - line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / ( - ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) - line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + ( - ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) \ - / ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum( - G))) ** ExprM(vars, m=ETAPIT.loc[H]) - - LSEQ1 = ((line1 * line2 * line3 * line4) - HW.loc(H) / HH.loc(H)) - LSEQ1.write(count, filename) - print(LSEQ1.test(vars.initialVals)) - - print('LSEQ2A') - line = ExprM(vars, m=CMO0.loc[CM1]) * ( - FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM1])) - - LSEQ2A = (line - CMO.loc(CM1)) - LSEQ2A.write(count, filename) - print(LSEQ2A.test(vars.initialVals)) - - print('LSEQ2B') - line = ExprM(vars, m=CMO0.loc[CM2]) * ( - FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM2])) - - LSEQ2B = (line - CMO.loc(CM2)) - LSEQ2B.write(count, filename) - print(LSEQ2B.test(vars.initialVals)) - # print(LSEQ2B) - - print('LSEQ2C') - line = ExprM(vars, m=CMO0.loc[CM3]) * ( - FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM3])) - - LSEQ2C = (line - CMO.loc(CM3)) - LSEQ2C.write(count, filename) - print(LSEQ2C.test(vars.initialVals)) - - print('LSEQ3') - line = ExprM(vars, m=CMI0.loc[L]) * ( - (FD.loc(L, FG).sum(FG) / ExprM(vars, m=FD0.loc[L, FG].sum(1))) ** (ExprM(vars, m=ECOMI.loc[L]))) - - LSEQ3 = (line - CMI.loc(L)) - LSEQ3.write(count, filename) - print(LSEQ3.test(vars.initialVals)) - - print('POPEQ(H)') - line1 = ExprM(vars, m=HH0.loc[H] * NRPG.loc[H]) - line2 = ExprM(vars, m=MI0.loc[H]) * ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / ( - CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) - line3 = ((HN.loc(H) / HH.loc(H)) / ExprM(vars, m=HN0.loc[H] / HH0.loc[H])) ** ExprM(vars, m=ETAU.loc[H]) - line4 = (CH.loc(HSD, H).sum(HSD) / ExprM(vars, m=CH0.loc[HSD, H].sum(0))) ** (1) - line5 = ExprM(vars, m=MO0.loc[H]) * (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / ( - ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) - line6 = (ExprM(vars, m=HN0.loc[H] / HH0.loc[H]) / (HN.loc(H) / HH.loc(H))) ** ExprM(vars, m=ETAU.loc[H]) - line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** (1) - - POPEQ = (line1 + line2 * line3 * line4 - line5 * line6 * line7 - HH.loc(H)) - POPEQ.write(count, filename) - print(POPEQ.test(vars.initialVals)) - # print(POPEQ) - - print('ANEQ(H)') - line = HH.loc(H) - HW.loc(H) - - ANEQ = (line - HN.loc(H)) - ANEQ.write(count, filename) - print(ANEQ.test(vars.initialVals)) - - print('YGEQ') - line1 = (ExprM(vars, m=TAUV.loc[GX, I]) * V.loc(I) * P.loc(I)).sum(I) - line2 = (ExprM(vars, m=TAUX.loc[GX, I]) * CX.loc(I) * PD.loc(I)).sum(I) - - YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) # first just set it to correct size - for label in GX: - for hlabel in H: - YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = Expr( - (ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) - - line3 = YGEQline3pre.sum(1) - line4 = (ExprM(vars, m=TAUN.loc[GX, I]) * CN.loc(I) * P.loc(I)).sum(I) - - YGEQline5pre = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) # first just set it to correct size - for label in GX: - YGEQline5pre.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) - line5 = YGEQline5pre - - line6 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) - for label in GX: - line6.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) - - line7 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) - for label in GX: - line7.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) - - line8 = (ExprM(vars, m=TAUFH.loc[GX, F]) * Y.loc(F)).sum(F) - line9 = (ExprM(vars, m=PIT0.loc[GX, H]) * Y.loc(H)).sum(H) - line10 = (ExprM(vars, m=TAUH.loc[GX, H]) * HH.loc(H)).sum(H) - line11 = IGT.loc(GX, GX1).sum(1) - - YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - Y.loc(GX)) - YGEQ.write(count, filename) - print(YGEQ.test(vars.initialVals)) - # print(YGEQ) - - print('YGEQ2(GT)') - line = IGT.loc(GT, GX).sum(GX) - - YGEQ2 = (line - Y.loc(GT)) - YGEQ2.write(count, filename) - print(YGEQ2.test(vars.initialVals)) - # print(YGEQ2) - - print('YGEQM(GNLM)') - line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) - - YGEQM = (line - Y.loc(GNLM)) - YGEQM.write(count, filename) - print(YGEQM.test(vars.initialVals)) - # print(YGEQM) - - print('YGEQO(GNLO)') - line = ExprM(vars, m=TAXS2.loc[GNLO]) * Y.loc(['CYGFO']) - - YGEQO = (line - Y.loc(GNLO)) - YGEQO.write(count, filename) - print(YGEQO.test(vars.initialVals)) - # print(YGEQ1) - - print('GOVFOR(G)') - line = ExprM(vars, m=GFOR.loc[G]) * Y.loc(G) - - GOVFOR = (line - GVFOR.loc(G)) - GOVFOR.write(count, filename) - print(GOVFOR.test(vars.initialVals)) - # print(GOVFOR) - - print('CGEQ(I,GN)') - left = P.loc(I) * ExprM(vars, m=1 + TAUG.loc[GS, I].sum(0)) * CG.loc(I, GN) - right = ExprM(vars, m=AG.loc[I, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) - - CGEQ = (right - left) - CGEQ.write(count, filename) - print(CGEQ.test(vars.initialVals)) - # print(CGEQ) - - print('GFEQ(F,GN)') - left = FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN])) - right = ExprM(vars, m=AG.loc[F, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) - - GFEQ = left - right - GFEQ.write(count, filename) - print(GFEQ.test(vars.initialVals)) - # print(GFEQ) - - print('GSEQL(GN)') - line1 = Y.loc(GN) + GVFOR.loc(GN) - line2 = (CG.loc(I, GN) * P.loc(I) * (1 + ExprM(vars, m=TAUG.loc[GS, I]).sum(GS))).sum(I) - line3 = (FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN]))).sum(F) - - GSEQL = ((line1 - ~line2 - ~line3) - S.loc(GN)) - GSEQL.write(count, filename) - print(GSEQL.test(vars.initialVals)) - # print(GSEQL) - - print('GSEQ(GX)') - line1 = (Y.loc(GX) + ExprM(vars, m=GFOR.loc[GX]) * Y.loc(GX)) - line2 = (ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H) - line3 = IGT.loc(G, GX).sum(G) - - GSEQ = ((line1 - ~line2 - ~line3) - S.loc(GX)) - GSEQ.write(count, filename) - print(GSEQ.test(vars.initialVals)) - # print(GSEQ) - - print('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') - line = ExprM(vars, m=TAXS.loc[G, GX]) * ( - Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) - - TDEQ = line - IGT.loc(G, GX) - TDEQ.setCondition(IGTD.loc[G, GX], 'EQ', 1) - TDEQ.write(count, filename) - print(TDEQ.test(vars.initialVals)) - # print(TDEQ) - - print('SPIEQ') - line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + ( - ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) - - SPIEQ = (line - SPI) - SPIEQ.write(count, filename) - print(SPIEQ.test(vars.initialVals)) - # print(SPIEQ) - - print('LMEQ1(L)') - left = (ExprM(vars, m=JOBCOR.loc[H, L]) * HW.loc(H)).sum(H) + CMI.loc(L) - right = FD.loc(L, Z).sum(Z) - - LMEQ1 = (right - left) - LMEQ1.write(count, filename) - print(LMEQ1.test(vars.initialVals)) - # print(LMEQ1) - - print('KMEQ(K,IG)') - KMEQ = ((ExprM(vars, m=TT.loc[K, IG]) * FD.loc(K, IG)) - KS.loc(K, IG)) - KMEQ.write(count, filename) - print(KMEQ.test(vars.initialVals)) - # print(KMEQ) - - print('GMEQ(I)') - GMEQ = (DD.loc(I) + CX.loc(I) - M.loc(I) - DS.loc(I)) - GMEQ.write(count, filename) - print(GMEQ.test(vars.initialVals)) - # print(GMEQ) - - print('DDEQ(I)') - DDEQ = (V.loc(I) + CH.loc(I, H).sum(H) + CG.loc(I, G).sum(G) + CN.loc(I) - DD.loc(I)) - DDEQ.write(count, filename) - print(DDEQ.test(vars.initialVals)) - # print(DDEQ) - - # ------------------------------------------------------------------------------------------------------------- - # MODEL CLOSURE - # ------------------------------------------------------------------------------------------------------------- - - # FIX INTER GOVERNMENTAL TRANSFERS TO ZERO IF NOT IN ORIGINAL SAM - print('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') - FX1 = IGT.loc(G, GX) - FX1.setCondition(IGT0.loc[G, GX], 'EQ', 0) - FX1.write(count, filename) - # print(FX1) - - # FIX EXOGENOUS INTERGOVERNMENTAL TRANSFERS - print('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') - FX2 = IGT.loc(G, GX) - ExprM(vars, m=IGT0.loc[G, GX]) - FX2.setCondition(IGTD.loc[G, GX], 'EQ', 2) - FX2.write(count, filename) - # print(FX2) - - # FIX INTER SECTORAL WAGE DIFFERENTIALS - print('R.FX(L,Z)=R0(L,Z)') - FX3 = R.loc(L, Z) - ExprM(vars, m=R0.loc[L, Z]) - FX3.write(count, filename) - # print(FX3) - - # FIX ECONOMY WIDE SCALAR - print('RA.FX(K)=RA0(K)') - FX4 = RA.loc(K) - ExprM(vars, m=RA0.loc[K]) - FX4.write(count, filename) - - print("Objective") - obj = vars.getIndex('SPI') - - with open(filename, 'a') as f: - f.write('model.obj = Objective(expr=-1*model.x' + str(obj) + ')') - - -def run_solver(cons_filename, temp_file_name="tmp.py"): - solver = 'ipopt' - solver_io = 'nl' - stream_solver = True # True prints solver output to screen - keepfiles = False # True prints intermediate file names (.nl,.sol,...) - opt = SolverFactory(solver, solver_io=solver_io) - - if opt is None: - print("") - print("ERROR: Unable to create solver plugin for %s " \ - "using the %s interface" % (solver, solver_io)) - print("") - exit(1) - - ### Create the model - model = ConcreteModel() - set_variable(cons_filename) - set_equation(cons_filename) - ### - - exec(open(cons_filename).read()) - - ### Declare all suffixes - - # Ipopt bound multipliers (obtained from solution) - model.ipopt_zL_out = Suffix(direction=Suffix.IMPORT) - model.ipopt_zU_out = Suffix(direction=Suffix.IMPORT) - - # Ipopt bound multipliers (sent to solver) - model.ipopt_zL_in = Suffix(direction=Suffix.EXPORT) - model.ipopt_zU_in = Suffix(direction=Suffix.EXPORT) - - # Obtain dual solutions from first solve and send to warm start - model.dual = Suffix(direction=Suffix.IMPORT_EXPORT) - - ### Set Ipopt options for warm-start - # The current values on the ipopt_zU_out and - # ipopt_zL_out suffixes will be used as initial - # conditions for the bound multipliers to solve - # the new problem - model.ipopt_zL_in.update(model.ipopt_zL_out) - model.ipopt_zU_in.update(model.ipopt_zU_out) - opt.options['warm_start_init_point'] = 'yes' - opt.options['warm_start_bound_push'] = 1e-6 - opt.options['warm_start_mult_bound_push'] = 1e-6 - opt.options['mu_init'] = 1e-6 - - ### Send the model and suffix information to ipopt and collect the solution - # The solver plugin will scan the model for all active suffixes - # valid for importing, which it will store into the results object - - results = opt.solve(model, keepfiles=keepfiles, tee=stream_solver) - - x = [None for i in range(vars.nvars)] - - with open(temp_file_name, 'w') as f: - for i in range(vars.nvars): - f.write('x[' + str(i) + ']=value(model.x' + str(i) + ')\n') - - exec(open(temp_file_name).read()) - - soln.append(x[:]) - - return None - - -''' -Calibrate the model -''' - -soln = [] -filename = os.path.join(filePath, "ipopt_cons.py") -tmp = os.path.join(filePath, "tmp.py") -print("Calibration: ") -run_solver(filename, tmp) - -''' -Simulation code below: -In each simulation: - -1. Apply simulation code (for instance PI(I) = 1.02). -2. Rewrite all equations -3. Solve the new model with the result from last run as initial guess. - -''' - -############ begin shock by using tables - -# iNum = 1 # dynamic model itterations - -sims = pd.read_csv(os.path.join(filePath, 'SIMS 500.csv'), index_col=0) -iNum = 1 -# iNum = len(sims.columns) -KS00 = KS0.copy() - -for num in range(iNum): - # print("Simulation: ", num+1) - KS0.loc[K, I] = KS00.loc[K, I].mul(sims.iloc[:, num]) - run_solver(filename, tmp) - -############ end shock by using tables - -exec(open(os.path.join(modelPath, "shelby_output.py")).read()) diff --git a/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py b/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py deleted file mode 100755 index 74b01e06a..000000000 --- a/pyincore/analyses/shelbycge/shelby_CES_September_21_2020.py +++ /dev/null @@ -1,1907 +0,0 @@ -from pyincore.analyses.shelbycge.Equationlib import * -import os -import pandas as pd -from pyomo.environ import * -from pyomo.opt import SolverFactory - - -def _(x): - return ExprM(vars, m=x) - -# set file paths - -modelPath = os.path.join(os.getcwd(), 'old') -filePath = os.path.join(modelPath, 'old') - -# define sets - -# ALL ACCOUNTS IN SOCIAL ACCOUNTING MATRIX - -Z = [ - 'GOODSA', - 'TRADEA', - 'OTHERA', - 'GOODSB', - 'TRADEB', - 'OTHERB', - 'GOODSC', - 'TRADEC', - 'OTHERC', - 'GOODSD', - 'TRADED', - 'OTHERD', - 'GOODSE', - 'TRADEE', - 'OTHERE', - 'GOODSF', - 'TRADEF', - 'OTHERF', - 'GOODSG', - 'TRADEG', - 'OTHERG', - 'GOODSH', - 'TRADEH', - 'OTHERH', - 'HS1A', - 'HS2A', - 'HS3A', - 'HS1B', - 'HS2B', - 'HS3B', - 'HS1C', - 'HS2C', - 'HS3C', - 'HS1D', - 'HS2D', - 'HS3D', - 'HS1E', - 'HS2E', - 'HS3E', - 'HS1F', - 'HS2F', - 'HS3F', - 'HS1G', - 'HS2G', - 'HS3G', - 'HS1H', - 'HS2H', - 'HS3H', - 'L1A', - 'L2A', - 'L3A', - 'L1B', - 'L2B', - 'L3B', - 'L1C', - 'L2C', - 'L3C', - 'L1D', - 'L2D', - 'L3D', - 'L1E', - 'L2E', - 'L3E', - 'L1F', - 'L2F', - 'L3F', - 'L1G', - 'L2G', - 'L3G', - 'L1H', - 'L2H', - 'L3H', - 'KAP', - 'HH1A', - 'HH2A', - 'HH3A', - 'HH4A', - 'HH5A', - 'HH1B', - 'HH2B', - 'HH3B', - 'HH4B', - 'HH5B', - 'HH1C', - 'HH2C', - 'HH3C', - 'HH4C', - 'HH5C', - 'HH1D', - 'HH2D', - 'HH3D', - 'HH4D', - 'HH5D', - 'HH1E', - 'HH2E', - 'HH3E', - 'HH4E', - 'HH5E', - 'HH1F', - 'HH2F', - 'HH3F', - 'HH4F', - 'HH5F', - 'HH1G', - 'HH2G', - 'HH3G', - 'HH4G', - 'HH5G', - 'HH1H', - 'HH2H', - 'HH3H', - 'HH4H', - 'HH5H', - 'INVES', - 'USSOCL1A', - 'USSOCL2A', - 'USSOCL3A', - 'USSOCL1B', - 'USSOCL2B', - 'USSOCL3B', - 'USSOCL1C', - 'USSOCL2C', - 'USSOCL3C', - 'USSOCL1D', - 'USSOCL2D', - 'USSOCL3D', - 'USSOCL1E', - 'USSOCL2E', - 'USSOCL3E', - 'USSOCL1F', - 'USSOCL2F', - 'USSOCL3F', - 'USSOCL1G', - 'USSOCL2G', - 'USSOCL3G', - 'USSOCL1H', - 'USSOCL2H', - 'USSOCL3H', - 'MEMPROPTAX', - 'OTHERPROPTAX', - 'MEMSALESTAX', - 'OTHERSALESTAX', - 'MEMFEE', - 'OTHERFEE', - 'TNSTX', - 'TNITAX', - 'USPIT', - 'CYGFM', - 'CYGFO', - 'FED', - 'STATE', - 'MEMPHIS', - 'OTHER', - 'OUTCOM1', - 'OUTCOM2', - 'OUTCOM3', - 'ROW'] - -# FACTORS -F = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', 'KAP'] - -F11 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] - -F21 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] - -F31 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] - -# COMMUTERS OUT -CM = ['OUTCOM1', 'OUTCOM2', 'OUTCOM3'] - -# COMMUTERS OUT 1 -CM1 = ['OUTCOM1'] - -# COMMUTERS OUT 2 -CM2 = ['OUTCOM2'] - -# COMMUTERS OUT 3 -CM3 = ['OUTCOM3'] - -# ALL WORKERS WHO LIVE IN SHELBY -LT = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', - 'OUTCOM1', 'OUTCOM2', 'OUTCOM3'] - -# LABOR -L = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'] - -L1 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] - -L2 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] - -L3 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] - -# CAPITAL -K = ['KAP'] - -# GOVERNMENTS -G = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', - 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', - 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', - 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', - 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT', 'CYGFM', 'CYGFO', 'FED', - 'STATE', 'MEMPHIS', 'OTHER'] - -# ENDOGENOUS GOVERNMENTS -GN = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] - -# LOCAL ENDOGENOUS GOVERNMENTS -GNLM = ['MEMPHIS'] - -# LOCAL ENDOGENOUS GOVERNMENTS -GNLO = ['OTHER'] - -# EXOGENOUS GOVERMENTS -GX = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', - 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', - 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', - 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', - 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT'] - -# SALES OR EXCISE TAXES -GS = ['MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', 'OTHERFEE', 'TNSTX'] - -# LAND TAXES -GL = ['MEMPROPTAX', 'OTHERPROPTAX'] - -# FACTOR TAXES -GF = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', - 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', 'MEMPROPTAX', 'OTHERPROPTAX'] - -# SS PAYMENT -GFUS = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', - 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] - -# SS PAYMENT -GFUSC = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', - 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', - 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] - -# INCOME TAX UNITS -GI = ['TNITAX', 'USPIT'] - -# HOUSEHOLD TAX UNITS -GH = ['MEMPROPTAX', 'OTHERPROPTAX', 'MEMFEE', 'OTHERFEE'] - -# ENDOGENOUS TRANSFER PMT -GT = ['CYGFM', 'CYGFO', 'FED', 'STATE'] - -# HOUSEHOLDS -H = ['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', - 'HH5C', - 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', - 'HH5F', - 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'] - -# I+G SECTORS -IG = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', - 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', - 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', - 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H', - 'FED', 'STATE', 'MEMPHIS', 'OTHER'] - -# INDUSTRY SECTORS -I = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', - 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', - 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', - 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H'] - -# ENDOGENOUS GOVERNMENTS -IG2 = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] - -# PRODUCTION SECTORS -IP = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', - 'OTHERD', - 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', - 'OTHERH'] - -# PRODUCTION GOV. -FG = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', - 'OTHERD', - 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', - 'OTHERH'] - -# HOUSING SERV.DEMAND -HSD = ['HS1A', 'HS2A', 'HS3A', 'HS1B', 'HS2B', 'HS3B', 'HS1C', 'HS2C', 'HS3C', 'HS1D', 'HS2D', 'HS3D', - 'HS1E', 'HS2E', 'HS3E', 'HS1F', 'HS2F', 'HS3F', 'HS1G', 'HS2G', 'HS3G', 'HS1H', 'HS2H', 'HS3H'] - -# SIMMLOOP -SM = ['BASE', 'TODAY', 'SIMM'] - -# REPORT 1 FOR SCALARS -R1H = ['GFREV', 'SFREV', 'PIT', - 'DGF', 'DSF', 'DDRE', 'PDRE', 'SPI', 'COMM', 'COMMO', - 'GN', 'NKI', 'HH', 'W', 'W1', 'W2', 'W3', 'R', 'RL', 'L', 'K', 'HN', 'HW', 'GFSAVM', 'GFSAVO', 'LD', - 'CMO', 'CMI', 'HC', 'SSC', 'LAND', 'LAS'] - -# REPORT 2 FOR STATUS -R2H = ['M-STAT', 'S-STAT'] - -# LABELS FOR MODEL STATUS -MS = ['OPTIMAL', 'LOCALOP', 'UNBOUND', - 'INFSBLE', 'INFSLOC', 'INFSINT', - 'NOOPTML', 'MIPSOLN', 'NOINTGR', - 'INFSMIP', 'UNUSED', 'UNKNOWN', - 'NOSOLUT'] - -# LABELS FOR SOLVER STATUS -SS = ['OK', 'ITERATE', 'RESRCE', - 'SOLVER', 'EVALUATE', 'NOTKNWN', - 'NOTUSED', 'PRE-PROC', 'SETUP', - 'SLVFAIL', 'SLVINTER', 'POST-PROC', - 'METSYS'] - -# SETS FOR MISC TABLES ONLY - -# HOUSING SERVICES -HSSET = ['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', - 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', - 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] - -# HOUSING SERVICES 2 & 3 -HS23SET = ['HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', - 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] - -# HOUSEHOLDS (INCOME 1) -HH1 = ['HH1A', 'HH1B', 'HH1C', 'HH1D', 'HH1E', 'HH1F', 'HH1G', 'HH1H'] - -# HOUSEHOLDS (INCOME 2) -HH2 = ['HH2A', 'HH2B', 'HH2C', 'HH2D', 'HH2E', 'HH2F', 'HH2G', 'HH2H'] - -# HOUSEHOLDS (INCOME 3) -HH3 = ['HH3A', 'HH3B', 'HH3C', 'HH3D', 'HH3E', 'HH3F', 'HH3G', 'HH3H'] - -# HOUSEHOLDS (INCOME 4) -HH4 = ['HH4A', 'HH4B', 'HH4C', 'HH4D', 'HH4E', 'HH4F', 'HH4G', 'HH4H'] - -# HOUSEHOLDS (INCOME 5) -HH5 = ['HH5A', 'HH5B', 'HH5C', 'HH5D', 'HH5E', 'HH5F', 'HH5G', 'HH5H'] - -# ELASTICITIES -ETA = ['ETAL1', 'ETAI1', 'ETALB1', 'ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU', 'ETAM', 'ETAE', 'ETAY', 'ETAOP'] - -# LANDCAP TABLE ELASTICITIES -ETALANDCAP = ['ETAL1', 'ETAI1', 'ETALB1'] - -# MISCH TABLE ELASTICITIES -ETAMISCH = ['ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU'] - -# MISC TABLE ELASTICITIES -ETAMISC = ['ETAM', 'ETAE', 'ETAY', 'ETAOP'] - -# SET ALIASES - -# ALIAS -J = I -I1 = I -Z1 = Z -F1 = F -G1 = G -G2 = G -GI1 = GI -GS1 = GS -GX1 = GX -GN1 = GN -GH1 = GH -GF1 = GF -H1 = H -HSD1 = HSD -JP = IP -JG = IG -GT1 = GT -GNLM1 = GNLM -GNLO1 = GNLO - -# IMPORT ADDITIONAL DATA FILES - -# SAM -SAM = pd.read_csv(os.path.join(filePath, 'SAM Shelby(1202).csv'), index_col=0) - -# CAPITAL COMP -BB = pd.read_csv(os.path.join(filePath, 'capcomshelby.csv'), index_col=0) - -# MISC TABLES - -TPC = pd.DataFrame(index=H, columns=G).fillna(0.0) -IGTD = pd.DataFrame(index=G, columns=G1).fillna(0.0) -TAUFF = pd.DataFrame(index=G, columns=F).fillna(0.0) -IOUT = pd.DataFrame(index=G1, columns=G1).fillna(0.0) -LANDCAP = pd.DataFrame(index=IG, columns=ETALANDCAP).fillna(0.0) -MISC = pd.DataFrame(index=Z, columns=ETAMISC).fillna(0.0) -MISCH = pd.DataFrame(index=H, columns=ETAMISCH).fillna(0.0) - -miscPath = os.path.join(filePath, 'MiscFile') - -# EMPLOY0 = pd.read_csv(os.path.join(miscPath, 'EMPLOY0(Z,F).csv'), index_col=0) -EMPLOY = pd.read_csv(os.path.join(miscPath, 'EMPLOY(Z,F).csv'), index_col=0) -JOBCR = pd.read_csv(os.path.join(miscPath, 'JOBCR(H,L).csv'), index_col=0) -# JOBCR1 = pd.read_csv(os.path.join(miscPath, 'JOBCR1(H,L).csv'), index_col=0) -HHTABLE = pd.read_csv(os.path.join(miscPath, 'HHTABLE(H,).csv'), index_col=0) -# OUTCR = pd.read_csv(os.path.join(miscPath, 'OUTCR(H,CM).csv'), index_col=0) - -# PARAMETER DECLARATION - -# these are data frames with zeros to be filled during calibration -A = pd.DataFrame(index=Z, columns=Z).fillna(0.0) -AD = pd.DataFrame(index=Z, columns=Z).fillna(0.0) -AG = pd.DataFrame(index=Z, columns=G).fillna(0.0) -AGFS = pd.DataFrame(index=Z, columns=G).fillna(0.0) -SIGMA = pd.Series(index=I, dtype=float).fillna(0.0) -ALPHA = pd.DataFrame(index=F, columns=I).fillna(0.0) -ALPHA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) -B = pd.DataFrame(index=I, columns=IG).fillna(0.0) -B1 = pd.DataFrame(index=I, columns=I).fillna(0.0) -CMOWAGE = pd.Series(index=CM, dtype=float).fillna(0.0) -CMIWAGE = pd.Series(index=L, dtype=float).fillna(0.0) -FCONST = pd.DataFrame(index=F, columns=I).fillna(0.0) -GAMMA = pd.Series(index=I, dtype=float).fillna(0.0) -DELTA = pd.Series(index=I, dtype=float).fillna(0.0) -PIT = pd.DataFrame(index=G, columns=H).fillna(0.0) -PIT0 = pd.DataFrame(index=G, columns=H).fillna(0.0) -PRIVRET1 = pd.Series(index=H, dtype=float).fillna(0.0) -PRIVRET = pd.Series(index=H, dtype=float).fillna(0.0) -# LFOR = pd.Series(index=LA, dtype=float).fillna(0.0) -KFOR = pd.Series(index=K, dtype=float).fillna(0.0) -GFOR = pd.Series(index=G, dtype=float).fillna(0.0) -out = pd.DataFrame(index=G, columns=G).fillna(0.0) -TAUFH = pd.DataFrame(index=G, columns=F).fillna(0.0) -TAUFL = pd.DataFrame(index=G, columns=L).fillna(0.0) -# TAUFLA = pd.DataFrame(index=G, columns=LA).fillna(0.0) -TAUFK = pd.DataFrame(index=G, columns=K).fillna(0.0) -TAUH = pd.DataFrame(index=G, columns=H).fillna(0.0) -TAUH0 = pd.DataFrame(index=G, columns=H).fillna(0.0) -TAUM = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUQ = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUC = pd.DataFrame(index=G, columns=I).fillna(0.0) -TAUCH = pd.DataFrame(index=G, columns=HSD).fillna(0.0) -TAUV = pd.DataFrame(index=G, columns=I).fillna(0.0) -TAUN = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUX = pd.DataFrame(index=G, columns=IG).fillna(0.0) -TAUG = pd.DataFrame(index=G, columns=I).fillna(0.0) -TAXS = pd.DataFrame(index=G, columns=G).fillna(0.0) -TAXS1 = pd.Series(index=GNLM, dtype=float).fillna(0.0) -TAXS2 = pd.Series(index=GNLO, dtype=float).fillna(0.0) - -# ELASTICITIES AND TAX DATA IMPOSED - -BETA = pd.DataFrame(index=I, columns=H).fillna(0.0) -BETAH = pd.DataFrame(index=HSD, columns=H).fillna(0.0) -ETAD = pd.Series(index=I, dtype=float).fillna(0.0) -ETAE = pd.Series(index=I, dtype=float).fillna(0.0) -ETAI = pd.Series(index=IG, dtype=float).fillna(0.0) -ETAIX = pd.DataFrame(index=K, columns=IG).fillna(0.0) -# ETAL = pd.DataFrame(index=LA, columns=IG).fillna(0.0) -ETAL1 = pd.Series(index=IG, dtype=float).fillna(0.0) -ETALB1 = pd.Series(index=IG, dtype=float).fillna(0.0) -ETALB = pd.DataFrame(index=L, columns=IG).fillna(0.0) -ETAM = pd.Series(index=I, dtype=float).fillna(0.0) -ETARA = pd.Series(index=H, dtype=float).fillna(0.0) -ETAYDO = pd.Series(index=H, dtype=float).fillna(0.0) -ETAUO = pd.Series(index=H, dtype=float).fillna(0.0) -ETAYDI = pd.Series(index=H, dtype=float).fillna(0.0) -ETAUI = pd.Series(index=H, dtype=float).fillna(0.0) -ETAYD = pd.Series(index=H, dtype=float).fillna(0.0) -ETAU = pd.Series(index=H, dtype=float).fillna(0.0) -ETAPT = pd.Series(index=H, dtype=float).fillna(0.0) -ETAPIT = pd.Series(index=H, dtype=float).fillna(0.0) -EXWGEO = pd.Series(index=CM, dtype=float).fillna(0.0) -EXWGEI = pd.Series(index=L, dtype=float).fillna(0.0) -ECOMI = pd.Series(index=L, dtype=float).fillna(0.0) -ECOMO = pd.Series(index=CM, dtype=float).fillna(0.0) -HOUSECOR = pd.DataFrame(index=H, columns=HSD).fillna(0.0) -JOBCOR = pd.DataFrame(index=H, columns=L).fillna(0.0) - -LAMBDA = pd.DataFrame(index=I, columns=I).fillna(0.0) -LAMBDAH = pd.DataFrame(index=HSD, columns=HSD1).fillna(0.0) - -NRPG = pd.Series(index=H, dtype=float).fillna(0.0) -RHO = pd.Series(index=I, dtype=float).fillna(0.0) -TT = pd.DataFrame(index=Z, columns=IG).fillna(0.0) - -depr = pd.Series(index=IG, dtype=float).fillna(0.1) - -# ARRAYS BUILT TO EXPORT RESULTS TO SEPARATE FILE - -R1 = pd.DataFrame(index=R1H, columns=SM).fillna(0.0) -R2 = pd.DataFrame(index=R2H, columns=SM).fillna(0.0) - -# INITIAL VALUES OF ENDOGENOUS VARIABLES - -CG0 = pd.DataFrame(index=I, columns=G).fillna(0.0) -CG0T = pd.DataFrame(index=I, columns=G).fillna(0.0) -CH0 = pd.DataFrame(index=I, columns=H).fillna(0.0) -CH0T = pd.DataFrame(index=I, columns=H).fillna(0.0) -CMI0 = pd.Series(index=L, dtype=float).fillna(0.0) -CMO0 = pd.Series(index=CM, dtype=float).fillna(0.0) -CN0 = pd.Series(index=I, dtype=float).fillna(0.0) -CN0T = pd.Series(index=I, dtype=float).fillna(0.0) -CPI0 = pd.Series(index=H, dtype=float).fillna(0.0) -CPIN0 = pd.Series(index=H, dtype=float).fillna(0.0) -CPIH0 = pd.Series(index=H, dtype=float).fillna(0.0) -CX0 = pd.Series(index=I, dtype=float).fillna(0.0) -D0 = pd.Series(index=I, dtype=float).fillna(0.0) -DD0 = pd.Series(index=Z, dtype=float).fillna(0.0) -DS0 = pd.Series(index=Z, dtype=float).fillna(0.0) -DQ0 = pd.Series(index=Z, dtype=float).fillna(0.0) - -FD0 = pd.DataFrame(index=F, columns=Z).fillna(0.0) -IGT0 = pd.DataFrame(index=G, columns=GX).fillna(0.0) -KS0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) -KSNEW = pd.DataFrame(index=K, columns=IG).fillna(0.0) -KSNEW0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) -# LAS0 = pd.DataFrame(index=LA, columns=IG).fillna(0.0) -HH0 = pd.Series(index=H, dtype=float).fillna(0.0) -HN0 = pd.Series(index=H, dtype=float).fillna(0.0) -HW0 = pd.Series(index=H, dtype=float).fillna(0.0) -M0 = pd.Series(index=I, dtype=float).fillna(0.0) -M01 = pd.Series(index=Z, dtype=float).fillna(0.0) -MI0 = pd.Series(index=H, dtype=float).fillna(0.0) -MO0 = pd.Series(index=H, dtype=float).fillna(0.0) -N0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) - -# NKIO - -KPFOR01 = pd.Series(index=K, dtype=float).fillna(0.0) -KPFOR0 = pd.Series(index=K, dtype=float).fillna(0.0) -# LNFOR0 = pd.Series(index=LA, dtype=float).fillna(0.0) -# LNFOR01 = pd.Series(index=LA, dtype=float).fillna(0.0) -GVFOR0 = pd.Series(index=G, dtype=float).fillna(0.0) -P0 = pd.Series(index=IG, dtype=float).fillna(0.0) -PH0 = pd.Series(index=HSD, dtype=float).fillna(0.0) -PD0 = pd.Series(index=I, dtype=float).fillna(0.0) -PVA0 = pd.Series(index=I, dtype=float).fillna(0.0) -PWM0 = pd.Series(index=I, dtype=float).fillna(0.0) -PW0 = pd.Series(index=I, dtype=float).fillna(0.0) -Q0 = pd.Series(index=Z, dtype=float).fillna(0.0) -Q10 = pd.Series(index=Z, dtype=float).fillna(0.0) -R0 = pd.DataFrame(index=F, columns=Z).fillna(1.0) -RA0 = pd.Series(index=F, dtype=float).fillna(0.0) -S0 = pd.Series(index=Z, dtype=float).fillna(0.0) - -# SPIO - -V0 = pd.Series(index=I, dtype=float).fillna(0.0) -V0T = pd.Series(index=I, dtype=float).fillna(0.0) -V10 = pd.DataFrame(index=I, columns=I).fillna(0.0) -TP = pd.DataFrame(index=H, columns=G).fillna(0.0) - -# TAUF0 = Table(G,F,Z) - -YD0 = pd.Series(index=H, dtype=float).fillna(0.0) -Y0 = pd.Series(index=Z, dtype=float).fillna(0.0) -Y01 = pd.Series(index=H, dtype=float).fillna(0.0) -YT0 = pd.Series(index=G, dtype=float).fillna(0.0) -GCP10 = pd.Series(index=I, dtype=float).fillna(0.0) - -# GCP0 - -DDCX = pd.Series(index=I, dtype=float).fillna(0.0) - -TESTA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) -TESTA2 = pd.DataFrame(index=F, columns=I).fillna(0.0) -TESTA3 = pd.DataFrame(index=F, columns=I).fillna(0.0) - -# SIMPLIFYING TABLES AND DOING AWAY WITH MISC FILES - -for label in G1: - out.loc[label, label] = 0 -out.loc['MEMPHIS', 'CYGFM'] = 1 -out.loc['OTHER', 'CYGFO'] = 1 - -IGTD.loc[G, G1] = 0 -IGTD.loc['FED', GFUS] = 1 -IGTD.loc['FED', 'USPIT'] = 1 - -IGTD.loc['CYGFM', 'MEMPROPTAX'] = 1 -IGTD.loc['CYGFM', 'MEMSALESTAX'] = 1 -IGTD.loc['CYGFM', 'MEMFEE'] = 1 - -IGTD.loc['CYGFO', 'OTHERPROPTAX'] = 1 -IGTD.loc['CYGFO', 'OTHERSALESTAX'] = 1 -IGTD.loc['CYGFO', 'OTHERFEE'] = 1 - -IGTD.loc['STATE', 'TNSTX'] = 1 -IGTD.loc['STATE', 'TNITAX'] = 1 - -TPC.loc[H, G] = 0 -TPC.loc[H, GFUS] = 1 - -TAUFF.loc[G, F] = 0 -TAUFF.loc['USSOCL1A', 'L1A'] = 1 -TAUFF.loc['USSOCL2A', 'L2A'] = 1 -TAUFF.loc['USSOCL3A', 'L3A'] = 1 -TAUFF.loc['USSOCL1B', 'L1B'] = 1 -TAUFF.loc['USSOCL2B', 'L2B'] = 1 -TAUFF.loc['USSOCL3B', 'L3B'] = 1 -TAUFF.loc['USSOCL1C', 'L1C'] = 1 -TAUFF.loc['USSOCL2C', 'L2C'] = 1 -TAUFF.loc['USSOCL3C', 'L3C'] = 1 -TAUFF.loc['USSOCL1D', 'L1D'] = 1 -TAUFF.loc['USSOCL2D', 'L2D'] = 1 -TAUFF.loc['USSOCL3D', 'L3D'] = 1 -TAUFF.loc['USSOCL1E', 'L1E'] = 1 -TAUFF.loc['USSOCL2E', 'L2E'] = 1 -TAUFF.loc['USSOCL3E', 'L3E'] = 1 -TAUFF.loc['USSOCL1F', 'L1F'] = 1 -TAUFF.loc['USSOCL2F', 'L2F'] = 1 -TAUFF.loc['USSOCL3F', 'L3F'] = 1 -TAUFF.loc['USSOCL1G', 'L1G'] = 1 -TAUFF.loc['USSOCL2G', 'L2G'] = 1 -TAUFF.loc['USSOCL3G', 'L3G'] = 1 -TAUFF.loc['USSOCL1H', 'L1H'] = 1 -TAUFF.loc['USSOCL2H', 'L2H'] = 1 -TAUFF.loc['USSOCL3H', 'L3H'] = 1 - -TAUFF.loc['MEMPROPTAX', 'KAP'] = 1 -TAUFF.loc['OTHERPROPTAX', 'KAP'] = 1 - -for label in G1: - IOUT.loc[label, label] = 0 -IOUT.loc['MEMPHIS', 'CYGFM'] = 1 -IOUT.loc['OTHER', 'CYGFO'] = 1 - -LANDCAP.loc[IG, ETALANDCAP] = 1 - -MISCH.loc[H, ETAMISCH] = 0 -MISCH.loc[HH1, 'ETAPT'] = -0.5 -MISCH.loc[HH2, 'ETAPIT'] = -0.15 -MISCH.loc[HH3, 'ETAPIT'] = -0.2 -MISCH.loc[HH4, 'ETAPIT'] = -0.25 -MISCH.loc[HH5, 'ETAPIT'] = -0.35 - -MISCH.loc[H, 'NRPG'] = 1 - -MISC.loc[IG, ETAMISC] = 0 -MISC.loc[IP, 'ETAM'] = 1 -# MISC.loc[IP, 'ETAE'] = -3.65 -MISC.loc[I, 'ETAY'] = 1 -MISC.loc[I, 'ETAOP'] = -1 - -# PARAMETERS AND ELASTICITIES - - -out.loc[G1, G1] = IOUT.loc[G1, G1] -BETA.loc[I, H] = MISC.loc[I, 'ETAY'] -BETAH.loc[HSD, H] = MISC.loc[HSD, 'ETAY'] - -for label in I: - LAMBDA.loc[label, label] = MISC.loc[label, 'ETAOP'] - -ETAE.loc[I] = MISC.loc[I, 'ETAE'] -ETAM.loc[I] = MISC.loc[I, 'ETAM'] -ETARA.loc[H] = MISCH.loc[H, 'ETARA'] - -ETAPIT.loc[H] = MISCH.loc[H, 'ETAPIT'] -ETAPT.loc[H] = MISCH.loc[H, 'ETAPT'] -ETAYD.loc[H] = MISCH.loc[H, 'ETAYD'] -NRPG.loc[H] = MISCH.loc[H, 'NRPG'] -ETAU.loc[H] = MISCH.loc[H, 'ETAU'] -ETAI.loc[IG] = LANDCAP.loc[IG, 'ETAI1'] -ETAIX.loc['KAP', IG] = ETAI.loc[IG] - -# play with elasticities - -# EXPERIMENTAL ELASTICITIES -ECOMI.loc[L] = 1 -ECOMO.loc[CM] = 1 -EXWGEO.loc[CM] = 1 -EXWGEI.loc[L] = 1 -ETAE.loc[IP] = -0.4 -ETAIX.loc['KAP', IG] = 0.1 -ETARA.loc[H] = 1.5 -ETAYDO.loc[H] = 1.0 -ETAYDI.loc[H] = 1.5 -ETAUI.loc[H] = -0.72 -ETAUO.loc[HH1] = -0.8 -ETAUO.loc[HH2] = -0.6 -ETAUO.loc[HH3] = -0.4 -ETAUO.loc[HH4] = -0.2 -ETAUO.loc[HH5] = -0.2 -ETAU.loc[H] = -0.1 -ETAYD.loc[H] = 1 - -# CALIBRATION - -# Column Totals of SAM table -Q10.loc[Z] = SAM.loc[Z, Z].sum(1) - -# Row Totals of SAM table -Q0.loc[Z] = SAM.loc[Z, Z].sum(0) - -# difference of SAM row and coloumn totals -DQ0.loc[Z] = Q10.loc[Z] - Q0.loc[Z] - -# Column Totals of SAM table -Q10.loc[Z] = SAM.loc[Z].sum(0) - -B1.loc[I, I] = SAM.loc[I, I] - -# Calculate tax rates from SAM information -TAUQ_1 = SAM.loc[GS, I] -TAUQ_2 = SAM.loc[I, I].sum(1) -TAUQ_3 = SAM.loc[I, H].sum(1) -TAUQ_4 = SAM.loc[I, ['INVES']].sum(1) -TAUQ_5 = SAM.loc[I, G].sum(1) -TAUQ_6 = SAM.loc[I, ['ROW']].sum(1) -TAUQ_7 = SAM.loc[GS1, I].sum(0) - -TAUQ.loc[GS, I] = TAUQ_1 / (TAUQ_2 + TAUQ_3 + TAUQ_4 + TAUQ_5 + TAUQ_6 - TAUQ_7) - -# NOTE: -# set taxes to average if not specific to model -TAUC.loc[GS, I] = TAUQ.loc[GS, I] -TAUV.loc[GS, I] = TAUQ.loc[GS, I] -TAUN.loc[GS, I] = TAUQ.loc[GS, I] -TAUG.loc[GS, I] = TAUQ.loc[GS, I] -TAUX.loc[GS, I] = TAUQ.loc[GS, I] - -# FACTOR TAX RATES -TAUFarray = [[[0 for k in range(len(Z))] for j in range(len(F))] for i in range(len(G))] -for i in range(len(GF)): - for j in range(len(F)): - for k in range(len(I)): - if SAM.loc[F[j], I[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: - TAUFarray[G.index(GF[i])][j][Z.index(I[k])] = SAM.loc[GF[i], I[k]] / SAM.loc[F[j], I[k]] - -for i in range(len(GF)): - for j in range(len(F)): - for k in range(len(G)): - if SAM.loc[F[j], G[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: - TAUFarray[G.index(GF[i])][j][Z.index(G[k])] = SAM.loc[GF[i], G[k]] / SAM.loc[F[j], G[k]] - -TAUFX_SUM_array = [[0 for j in range(len(Z))] for i in range(len(F))] -for i in range(len(F)): - for j in range(len(Z)): - tmp = 0 - for k in range(len(G)): - tmp += TAUFarray[k][i][j] - TAUFX_SUM_array[i][j] = tmp - -# TAUFX summed over GX -TAUFX_SUM = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) - -TAUFX_GF = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) - -TAUFXgx = {} -for i in range(len(GX)): - TAUFXgx[GX[i]] = pd.DataFrame(TAUFarray[i], index=F, columns=Z).fillna(0.0) - -# SS TAX RATES -for i in GF: - for j in F: - if TAUFF.loc[i, j] != 0: - # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[Z, F].sum(0).loc[j]) - TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[Z, F].sum(0).at[j] - -for i in GFUS: - for j in L: - if TAUFF.loc[i, j] != 0: - # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[L, IG].sum(1).loc[j]) - TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[L, IG].sum(1).at[j] - -# EMPLOYEE PORTION OF FACTOR TAXES -TAUFL.loc[GF, L] = SAM.loc[GF, L] / (SAM.loc[Z, L].sum(0) - SAM.loc[L, ['ROW']].sum(1)) - -TAUFK.loc[GF, K] = SAM.loc[GF, K] / SAM.loc[Z, K].sum(0) - -# SHARES OF ENDOGENOUS GOVERNMENTS TRANFERS TO REVENUE -TAXS.loc[G, GX] = SAM.loc[G, GX] / SAM.loc[G, GX].sum(0) - -TAXS1.loc[GNLM] = SAM.loc[GNLM, ['CYGFM']].sum(1) / SAM.loc[GNLM, ['CYGFM']].sum(1).sum(0) - -TAXS2.loc[GNLO] = SAM.loc[GNLO, ['CYGFO']].sum(1) / SAM.loc[GNLO, ['CYGFO']].sum(1).sum(0) - -# SET INITIAL INTER GOVERNMENTAL TRANSFERS -IGT0.loc[G, GX] = SAM.loc[G, GX] - -# SET INITIAL PRICES TO UNITY LESS SALES AND EXCISE TAXES -PW0.loc[I] = 1.0 -PWM0.loc[I] = 1.0 -P0.loc[I] = 1.0 -PD0.loc[I] = 1.0 -CPI0.loc[H] = 1.0 -CPIN0.loc[H] = 1.0 -CPIH0.loc[H] = 1.0 -TT.loc[F, IG] = 1.0 - -# HOUSEHOLD TRANSFER PAYMENTS AND PERSONAL INCOME TAXES -# TOTAL HH IN Shelby -HH0.loc[H] = HHTABLE.loc[H, 'HH0'] - -# TOTAL WORKING HH IN SHELBY (WORK IN SHELBY & OUTSIDE SHELBY) -HW0.loc[H] = HHTABLE.loc[H, 'HW0'] - -# NON WORKING HH IN SHELBY -HN0.loc[H] = HH0.loc[H] - HW0.loc[H] - -# NOMINAL GOVERNMENT SS PAYMENTS -TP.loc[H, G] = SAM.loc[H, G].div(HH0.loc[H], axis='index').fillna(0.0) - -# FACTOR RENTALS -JOBCOR.loc[H, L] = JOBCR.loc[H, L] - -# RENTAL RATE FOR FACTORS -R0.loc[F, Z] = 1.0 - -R0.loc[F, IG] = (SAM.loc[F, IG] / EMPLOY.loc[IG, F].T).fillna(1.0) - -# REAL FACTOR DEMAND -FD0.loc[F, IG] = EMPLOY.loc[IG, F].T - -KS0.loc[K, IG] = FD0.loc[K, IG] - -# SHARES FOUND IN THE SOCIAL ACCOUNTING MATRIX DATA -# A = INPUT OUTPUT COEFICIENTS -A.loc[Z, Z] = SAM.loc[Z, Z].div(Q0.loc[Z], axis='columns') - -# SS PAYMENTS FROM IN-COMMUTERS - -# AGFS: LABOR PAYMENTS BY G SECTOR + USSOC PAYMENTS BY LABOR (GROSS LABOR PAYMENTS) -AGFS.loc['L1A', G] = SAM.loc['L1A', G] + SAM.loc['USSOCL1A', G] -AGFS.loc['L2A', G] = SAM.loc['L2A', G] + SAM.loc['USSOCL2A', G] -AGFS.loc['L3A', G] = SAM.loc['L3A', G] + SAM.loc['USSOCL3A', G] - -AGFS.loc['L1B', G] = SAM.loc['L1B', G] + SAM.loc['USSOCL1B', G] -AGFS.loc['L2B', G] = SAM.loc['L2B', G] + SAM.loc['USSOCL2B', G] -AGFS.loc['L3B', G] = SAM.loc['L3B', G] + SAM.loc['USSOCL3B', G] - -AGFS.loc['L1C', G] = SAM.loc['L1C', G] + SAM.loc['USSOCL1C', G] -AGFS.loc['L2C', G] = SAM.loc['L2C', G] + SAM.loc['USSOCL2C', G] -AGFS.loc['L3C', G] = SAM.loc['L3C', G] + SAM.loc['USSOCL3C', G] - -AGFS.loc['L1D', G] = SAM.loc['L1D', G] + SAM.loc['USSOCL1D', G] -AGFS.loc['L2D', G] = SAM.loc['L2D', G] + SAM.loc['USSOCL2D', G] -AGFS.loc['L3D', G] = SAM.loc['L3D', G] + SAM.loc['USSOCL3D', G] - -AGFS.loc['L1E', G] = SAM.loc['L1E', G] + SAM.loc['USSOCL1E', G] -AGFS.loc['L2E', G] = SAM.loc['L2E', G] + SAM.loc['USSOCL2E', G] -AGFS.loc['L3E', G] = SAM.loc['L3E', G] + SAM.loc['USSOCL3E', G] - -AGFS.loc['L1F', G] = SAM.loc['L1F', G] + SAM.loc['USSOCL1F', G] -AGFS.loc['L2F', G] = SAM.loc['L2F', G] + SAM.loc['USSOCL2F', G] -AGFS.loc['L3F', G] = SAM.loc['L3F', G] + SAM.loc['USSOCL3F', G] - -AGFS.loc['L1G', G] = SAM.loc['L1G', G] + SAM.loc['USSOCL1G', G] -AGFS.loc['L2G', G] = SAM.loc['L2G', G] + SAM.loc['USSOCL2G', G] -AGFS.loc['L3G', G] = SAM.loc['L3G', G] + SAM.loc['USSOCL3G', G] - -AGFS.loc['L1H', G] = SAM.loc['L1H', G] + SAM.loc['USSOCL1H', G] -AGFS.loc['L2H', G] = SAM.loc['L2H', G] + SAM.loc['USSOCL2H', G] -AGFS.loc['L3H', G] = SAM.loc['L3H', G] + SAM.loc['USSOCL3H', G] - -# AG - GOVERNMENT SPENDING SHARES OF NET INCOME -AG_1 = SAM.loc[I, G] -AG_2 = SAM.loc[I, G].sum(0) + SAM.loc[F, G].sum(0) + SAM.loc[GF, G].sum(0) -AG.loc[I, G] = AG_1 / AG_2 - -AG_1 = SAM.loc[F, G] -AG.loc[F, G] = AG_1 / AG_2 - -AG_1 = AGFS.loc[L, G] -AG.loc[L, G] = AG_1 / AG_2 -AG = AG.fillna(0.0) - -# TRADE INTERMEDIATES CONSUMPTION INVESTMENT INITIAL LEVELS - -# REAL EXPORT CONSUMPTION -CX0.loc[I] = SAM.loc[I, ["ROW"]].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index').sum(1) - -# REAL IMPORTS -M01.loc[I] = SAM.loc[["ROW"], I].sum(0) / PWM0[I].T - -M0.loc[IP] = SAM.loc[IP, Z].sum(1) - (B1.loc[I, IP].sum(0) + SAM.loc[F, IP].sum(0) + SAM.loc[G, IP].sum(0)) - -M0.loc[I] = (M0[I] / PWM0[I]) -M0 = M0.fillna(0.0) - -# * REAL INTERMEDIATE DEMAND -V0.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] / (1.0 + TAUQ.loc[GS, I].sum(0)) -V0T.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] - -# REAL PRIVATE CONSUMPTION -CH0.loc[I, H] = SAM.loc[I, H].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') - -CH0T.loc[I, H] = SAM.loc[I, H].div(P0[I], axis='index') - -CG0.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index').div((1.0 + TAUQ.loc[GS, I].sum(0)), axis='index') - -CG0T.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index') - -DEPR = float((SAM.loc[IG, ["INVES"]].sum(0)) / (KS0.loc[K, IG].sum(1).sum(0))) - -N0.loc[K, IG] = KS0.loc[K, IG] * DEPR - -# INVESTMENT BY SECTOR OF SOURCE -CN0.loc[I] = 0.0 - -B.loc[I, IG] = BB.loc[I, IG].fillna(0.0) - -CN0.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index').div( - 1.0 + TAUN.loc[GS, I].sum(0), axis='index').transpose() - -CN0T.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index') - -DD0.loc[I] = CH0.loc[I, H].sum(1) + CG0.loc[I, G].sum(1) + CN0.loc[I] + V0.loc[I] - -D0.loc[I] = 1.0 - M0.loc[I] / DD0.loc[I] - -# CORRECT IMPORT ELASTICITY TO DOMESTIC SHARE ELASTICITY -ETAD.loc[I] = -1.0 * ETAM.loc[I] * M0.loc[I] / (DD0.loc[I] * D0.loc[I]) - -# PRODUCTION DATA -DS0.loc[I] = DD0.loc[I] + CX0.loc[I] - M0.loc[I] - -AD.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') / DS0.loc[I] - -V10.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') - -PVA0.loc[I] = PD0.loc[I] - ( - AD.loc[I, I].mul(P0.loc[I], axis='index').mul(1.0 + TAUQ.loc[GS, I].sum(0).T, axis='index').sum(0).T) - -# AVERAGE RENTAL RATES FOR FACTORS (NORMALIZED) -RA0.loc[F] = 1.0 - -# CALIBRATION OF PRODUCTION EXPONENTS FOR COBB DOUGLAS -# a = pd.Series(index=I, dtype=float).fillna(0.0) -# a = SAM.loc[GFUS, I].append(a, ignore_index=True).append(SAM.loc[GL, I]) # labor, capital -a = SAM.loc['MEMPROPTAX', I] + SAM.loc['OTHERPROPTAX', I] -a = SAM.loc[GFUS, I].append(a, ignore_index=True) # labor, capital -a.index = F - -ALPHA.loc[F, I] = (SAM.loc[F, I] + a.loc[F, I]) / (SAM.loc[F, I].sum(0) + SAM.loc[GF, I].sum(0)) -ALPHA.loc[F, I] = ALPHA.loc[F, I] / ALPHA.loc[F, I].sum(0) - -ACK = pd.Series(index=I, dtype=float).fillna(0.0) -ACK.loc[I] = SAM.loc[F, I].sum(0) - -# Cobb-Douglas Technology Parameter; replace takes care of multiplying by zeros, by changing zeros to ones. -# DELTA.loc[I] = DS0.loc[I] / (FD0.loc[F, I] ** ALPHA.loc[F, I]).replace({0: 1}).product(0) - -# CES Production Function -SIGMA.loc[I] = 0.67 -RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] - -TESTA1.loc[F, I] = 0.0 - -TESTA1.loc[F, I] = R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( - FD0.loc[F, I] ** (1 - RHO.loc[I])) - -TESTA2_pre = (R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( - FD0.loc[F, I] ** (1 - RHO.loc[I]))).sum(0) -TESTA2.loc[F, I] = 1 -TESTA2.loc[F, I] = TESTA2.loc[F, I] * TESTA2_pre - -TESTA3.loc[F, I] = TESTA1.loc[F, I] / TESTA2.loc[F, I] - -ALPHA.loc[F, I] = TESTA3.loc[F, I] - -# add THETA to make FDEQ work -THETA = ALPHA.where(ALPHA == 0, 1) - -ATEST1 = pd.Series(index=I, dtype=float).fillna(0.0) -ATEST1.loc[I] = ALPHA.loc[F, I].sum(0) - -GAMMA.loc[I] = DS0.loc[I] / (((ALPHA.loc[F, I] * FD0.loc[F, I] ** (RHO.loc[I])).sum(0)) ** (1 / RHO.loc[I])) - -# OTHER DATA -# HH INVESTMENT INCOME FROM ROW -PRIVRET.loc[H] = SAM.loc[Z, H].sum(0) - (SAM.loc[H, F].sum(1) + SAM.loc[H, CM].sum(1) + SAM.loc[H, GX].sum(1)) - -PRIVRET.loc[H] = PRIVRET.loc[H] / HH0.loc[H] - -# TOTAL OUTPUT -Y0.loc[F] = SAM.loc[F, IG].sum(1) - -KPFOR01.loc[K] = SAM.loc[K, ["ROW"]].sum(1) - -# NOMINAL CAPITAL OUTFLOW -KPFOR0[K] = SAM.loc[Z, K].sum(0).T - SAM.loc[K, IG].sum(1) - -# NOMINAL GOVERNMENT OUTFLOWS -GVFOR0.loc[G] = SAM.loc[G, ["ROW"]].sum(1) -''' -GVFOR0.loc[GT] = SAM.loc[Z, GT].sum(0) - ( - SAM.loc[GT, I].sum(1) - + SAM.loc[GT, F].sum(1) - + SAM.loc[GT, H].sum(1) - + SAM.loc[GT, G].sum(1) - ) -''' - -# ORIGINAL EQUATION -A.loc[H, L] = SAM.loc[H, L].div(HW0.loc[H], axis='index') / ( - Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) + SAM.loc[L, ["ROW"]].sum(1)) - -A.loc[H, K] = SAM.loc[H, K].div(HW0.loc[H], axis='index') / ( - Y0.loc[K] + SAM.loc[Z, K].sum(0) - SAM.loc[K, IG].sum(1)) - -# HH TAXES OTHER THAN PIT -TAUH.loc[GH, H] = SAM.loc[GH, H].div(HH0.loc[H], axis='columns') - -S0.loc[H] = SAM.loc[["INVES"], H].T.sum(1) - -YD0.loc[H] = SAM.loc[I, H].sum(0).T + S0.loc[H] - -Y0.loc[G] = SAM.loc[G, Z].sum(1) - SAM.loc[G, ["ROW"]].sum(1) - -S0.loc[G] = SAM.loc[["INVES"], G].sum(0) - -# COMMUTING IN -CMI0.loc[L] = FD0.loc[L, IG].sum(1) - JOBCOR.loc[H, L].mul(HW0.loc[H], axis='index').sum(0) - -# COMMUTING OUT -CMO0.loc[["OUTCOM1"]] = 46206.0 -CMO0.loc[["OUTCOM2"]] = 24294.0 -CMO0.loc[["OUTCOM3"]] = 13514.0 - -# AVERAGE WAGE FLOWING INTO SHELBY -CMOWAGE.loc[CM] = SAM.loc[CM, ["ROW"]].sum(1).div(CMO0.loc[CM], axis='index').fillna(0.0) - -# AVERAGE WAGES FLOWING OUT OF SHELBY -CMIWAGE.loc[L] = (-1) * (SAM.loc[L, ["ROW"]].sum(1).div(CMI0.loc[L], axis='index').fillna(0.0)) - -# PROPORTION OF CAPITAL INCOME OUTFLOW -KFOR.loc[K] = KPFOR0.loc[K] / SAM.loc[["KAP"], IG].sum(1) - -# PROPORTION OF GOVERNMENT INCOME OUTFLOW -GFOR.loc[G] = GVFOR0.loc[G] / Y0.loc[G] - -A.loc[H, CM] = SAM.loc[H, CM].div(SAM.loc[Z, CM].sum(0), axis='columns') - -# NOMINAL NET CAPITAL INFLOW -NKI0 = (M0.loc[I] * PWM0.loc[I]).sum(0) - (CX0.loc[I] * PD0.loc[I]).sum(0) - \ - (PRIVRET.loc[H] * HH0.loc[H]).sum(0) - \ - KPFOR0.loc[K].sum(0) - GVFOR0.loc[G].sum(0) - \ - (CMOWAGE.loc[CM] * CMO0.loc[CM]).sum(0) - \ - (CMIWAGE.loc[L] * CMI0.loc[L]).sum(0) - -# REAL HH NET INCOME -Y0.loc[H] = (A.loc[H, L].mul(HW0[H], axis='index').div(A.loc[H, L].mul(HW0[H], axis='index').sum(0), axis='columns') \ - .mul(Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) - (CMIWAGE.loc[L] * CMI0.loc[L]), axis='columns')).sum(1) \ - + (A.loc[H, CM].mul((CMOWAGE.loc[CM] * CMO0.loc[CM]), axis='columns')).sum(1) \ - + (A.loc[H, K].mul(HW0[H], axis='index') / A.loc[H, K].mul(HW0[H], axis='index').sum(0) \ - * (Y0[K] * (1.0 - TAUFK.loc[G, K].sum(0)) + KPFOR0.loc[K])).sum(1) - -# PERSONAL INCOME OBJECTIVE FUNCTION -SPI0 = (Y0.loc[H].sum(0) + - TP.loc[H, G].mul(HH0.loc[H], axis='index').sum(1).sum(0) + - (PRIVRET[H] * HH0[H]).sum(0)) - -# PERSONAL INCOME TAX -PIT.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') - -PIT0.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') - -MI0.loc[H] = HH0.loc[H] * 0.04 - -MO0.loc[H] = HH0.loc[H] * 0.04 - -GCP0 = CH0.loc[I, H].sum(1).sum(0) + CN0.loc[I].sum(0) + CG0.loc[I, GN].sum(1).sum(0) + CX0.loc[I].sum(0) - M0.loc[ - I].sum(0) - -GCP10.loc[I] = CH0.loc[I, H].sum(1) + CN0.loc[I] + CG0.loc[I, GN].sum(1) + CX0.loc[I] + M0.loc[I] - -########################################### -# VARIABLE DECLARATION -########################################### - -vars = VarContainer() - -# PUBLIC CONSUMPTION -CG = vars.add('CG', rows=I, cols=G) - -# PRIVATE CONSUMPTION -CH = vars.add('CH', rows=I, cols=H) - -# COMMUTING IN -CMI = vars.add('CMI', rows=L) - -# COMMUTING OUT JASPER -CMO = vars.add('CMO', rows=CM) - -# GROSS INVESTMENT BY SECTOR OF SOURCE -CN = vars.add('CN', rows=I) - -# CONSUMER PRICE INDEX -CPI = vars.add('CPI', rows=H) - -# NONHOUSING CONSUMER PRICE INDEX -CPIN = vars.add('CPIN', rows=H) - -# HOUSING CONSUMER PRICE INDEX -CPIH = vars.add('CPIH', rows=H) - -# EXPORT DEMAND -CX = vars.add('CX', rows=I) - -# DOMESTIC SHARE OF DOMESTIC DEMAND -D = vars.add('D', rows=I) - -# DOMESTIC DEMAND -DD = vars.add('DD', rows=I) - -# DOMESTIC SUPPLY -DS = vars.add('DS', rows=I) - -# SECTORAL FACTOR DEMAND -# FD = vars.add('FD', rows=F, cols=Z) -FD = vars.add('FD', rows=F, cols=Z) - -# GROSS AGGREGATE CITY PRODUCT -GCP = vars.add('GCP') - -# GROSS CITY PRODUCT BY SECTOR -GCP1 = vars.add('GCP1', rows=I) - -# NUMBER OF HOUSEHOLDS -HH = vars.add('HH', rows=H) - -# NUMBER OF NONWORKING HOUSEHOLDS -HN = vars.add('HN', rows=H) - -# NUMBER OF WORKING HOUSEHOLDS -HW = vars.add('HW', rows=H) - -# INTER GOVERNMENTAL TRANSFERS -IGT = vars.add('IGT', rows=G, cols=GX) - -# CAPITAL FLOW -KS = vars.add('KS', rows=K, cols=IG) - -# IMPORTS -M = vars.add('M', rows=I) - -# GROSS INVESTMENT BY SECTOR OF DESTINATION -N = vars.add('N', rows=K, cols=IG) - -# NET CAPITAL INFLOW -NKI = vars.add('NKI') - -# CAPITAL OUTFLOW -KPFOR = vars.add('KPFOR', rows=K) - -# GOVT OUTFLOW -GVFOR = vars.add('GVFOR', rows=G) - -# AGGREGATE DOMESTIC PRICE PAID BY PURCHASERS -P = vars.add('P', rows=I) - -# DOMESTIC PRICE RECEIVED BY SUPPLIERS -PD = vars.add('PD', rows=I) - -# VALUE ADDED PRICE -PVA = vars.add('PVA', rows=I) - -# ECONOMY WIDE SCALAR RENTAL RATES OF FACTORS -RA = vars.add('RA', rows=F) - -# SECTORAL RENTAL RATES -R = vars.add('R', rows=F, cols=Z) - -# SAVINGS -S = vars.add('S', rows=Z) - -# PERSONAL INCOME (OBJECTIVE FUNCTION) -SPI = vars.add('SPI') - -# INTERMEDIATE GOODS -V = vars.add('V', rows=I) - -# additional variable -V1 = vars.add('V1', rows=I, cols=I) - -# GROSS INCOMES -Y = vars.add('Y', rows=Z) - -# additional variables -# Y1 = vars.add('Y1', rows=H) -# Y2 = vars.add('Y2', rows=H) -# Y3 = vars.add('Y3', rows=H) - -# AFTER TAX TOTAL HOUSEHOLD INCOMES -YD = vars.add('YD', rows=H) - -# GOV INCOME -# YT = vars.add('YT', rows=G, cols=G) - -# INITIALIZE VARIABLES FOR SOLVER - - -vars.init('CG', CG0.loc[I, G]) -vars.init('CH', CH0.loc[I, H]) -vars.init('CMI', CMI0.loc[L]) -vars.init('CMO', CMO0.loc[CM]) -vars.init('CN', CN0.loc[I]) -vars.init('CPI', CPI0.loc[H]) -vars.init('CPIN', CPIN0.loc[H]) -vars.init('CPIH', CPIH0.loc[H]) -vars.init('CX', CX0.loc[I]) -vars.init('D', D0.loc[I]) -vars.init('DD', DD0.loc[I]) -vars.init('DS', DS0.loc[I]) -vars.init('FD', FD0.loc[F, Z]) -vars.init('GCP', GCP0) -vars.init('GCP1', GCP10.loc[I]) -vars.init('HH', HH0.loc[H]) -vars.init('HN', HN0.loc[H]) -vars.init('HW', HW0.loc[H]) -vars.init('IGT', IGT0.loc[G, GX]) -vars.init('KS', KS0.loc[K, IG]) -# vars.init('LAS', LAS0.loc[LA, IG]) -vars.init('M', M0.loc[I]) -vars.init('N', N0.loc[K, IG]) -vars.init('NKI', NKI0) -# vars.init('LNFOR', LNFOR0.loc[LA]) -vars.init('KPFOR', KPFOR0.loc[K]) -vars.init('GVFOR', GVFOR0.loc[G]) -vars.init('P', P0.loc[I]) -vars.init('PD', PD0.loc[I]) -vars.init('PVA', PVA0.loc[I]) -vars.init('RA', RA0.loc[F]) -vars.init('R', R0.loc[F, Z]) -vars.init('S', S0.loc[Z]) -vars.init('SPI', SPI0) -vars.init('V', V0.loc[I]) -vars.init('V1', V10.loc[I, I]) -vars.init('Y', Y0.loc[Z]) -vars.init('YD', YD0.loc[H]) -# vars.init('YT') - - -# ------------------------------------------------------------------------------------------------------------- -# DEFINE BOUNDS FOR VARIABLES -# ------------------------------------------------------------------------------------------------------------- - -vars.lo('P', vars.get('P') / 1000) -vars.up('P', vars.get('P') * 1000) -vars.lo('PD', vars.get('PD') / 1000) -vars.up('PD', vars.get('PD') * 1000) -vars.lo('PVA', vars.get('PVA') / 1000) -vars.up('PVA', vars.get('PVA') * 1000) -vars.lo('RA', vars.get('RA') / 1000) -vars.up('RA', vars.get('RA') * 1000) -vars.lo('CPI', vars.get('CPI') / 1000) -vars.up('CPI', vars.get('CPI') * 1000) -vars.lo('CMI', vars.get('CMI') / 1000) -vars.up('CMI', vars.get('CMI') * 1000) -vars.lo('CMO', vars.get('CMO') / 1000) -vars.up('CMO', vars.get('CMO') * 1000) -vars.lo('DS', vars.get('DS') / 1000) -vars.up('DS', vars.get('DS') * 1000) -vars.lo('DD', vars.get('DD') / 1000) -vars.up('DD', vars.get('DD') * 1000) -vars.lo('D', vars.get('D') / 1000) -vars.up('D', vars.get('D') * 1000) -vars.lo('V', vars.get('V') / 1000) -vars.up('V', vars.get('V') * 1000) -vars.lo('FD', vars.get('FD') / 1000) -vars.up('FD', vars.get('FD') * 1000) -vars.lo('HH', vars.get('HH') / 1000) -vars.up('HH', vars.get('HH') * 1000) -vars.lo('HW', vars.get('HW') / 1000) -vars.up('HW', vars.get('HW') * 1000) -vars.lo('HN', vars.get('HN') / 1000) -vars.up('HN', vars.get('HN') * 1000) -vars.lo('KS', vars.get('KS') / 1000) -vars.up('KS', vars.get('KS') * 1000) -vars.lo('M', vars.get('M') / 1000) -vars.up('M', vars.get('M') * 1000) -vars.lo('Y', vars.get('Y') / 1000) -vars.up('Y', vars.get('Y') * 1000) -vars.lo('YD', vars.get('YD') / 1000) -vars.up('YD', vars.get('YD') * 1000) -vars.lo('CH', vars.get('CH') / 1000) -vars.up('CH', vars.get('CH') * 1000) -vars.lo('CG', vars.get('CG') / 1000) -vars.up('CG', vars.get('CG') * 1000) -vars.lo('CX', vars.get('CX') / 1000) -vars.up('CX', vars.get('CX') * 1000) -vars.lo('R', vars.get('R') / 1000) -vars.up('R', vars.get('R') * 1000) -vars.lo('N', 0) -vars.lo('CN', 0) - - -def set_variable(filname): - # clear the file before write the variables - with open(filename, 'w') as f: - f.write("") - - vars.write(filename) - - -# ------------------------------------------------------------------------------------------------------------- -# DEFINE EQUATIONS AND SET CONDITIONS -# ------------------------------------------------------------------------------------------------------------- - -def set_equation(filename): - count = [0] - - print('CPIEQ(H)') - line1 = (P.loc(I) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0)) * CH.loc(I, H)).sum(I) - line2 = (ExprM(vars, m=P0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0))) * CH.loc(I, H)).sum(I) - - CPIEQ = (line1 / line2 - ~CPI.loc(H)) - print(CPIEQ.test(vars.initialVals)) - CPIEQ.write(count, filename) - - - print('YEQ(H)') - line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * ( - Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * ExprM(vars, - m=CMIWAGE.loc[L]) * CMI.loc( - L))).sum(L) - line2 = (ExprM(vars, m=A.loc[H, CM]) * (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM))).sum(CM) - # line3 = (ExprM(vars, m= A.loc[H,LA]) * HW.loc(H) / (ExprM(vars, m= A.loc[H1,LA]) * HW.loc(H1)).sum(H1) * (Y.loc(LA) + LNFOR.loc(LA) ) * ExprM(vars, m= 1 - TAUFLA.loc[G,LA].sum(0))).sum(LA) - line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * ( - Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) - - YEQ = ((line1 + line2 + line4) - Y.loc(H)) - print(YEQ.test(vars.initialVals)) - YEQ.write(count, filename) - - print('YDEQ(H)') - line1 = Y.loc(H) + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)) - line2 = (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum(G) - line3 = ~(ExprM(vars, m=PIT0.loc[GI, H]) * Y.loc(H)).sum(GI) - line4 = ~(ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum(G) - - YDEQ = ((line1 + line2 - line3 - line4) - YD.loc(H)) - YDEQ.write(count, filename) - print(YDEQ.test(vars.initialVals)) - # print(YDEQ) - - print('CHEQ(I,H)') - line1 = ExprM(vars, m=CH0.loc[I, H]) * ( - (YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m= - BETA.loc[I, H]) - line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / ( - ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** ExprM(vars, m=LAMBDA.loc[ - J, I])).prod(0) - - CHEQ = ((line1 * line2) - CH.loc(I, H)) - CHEQ.write(count, filename) - print(CHEQ.test(vars.initialVals)) - # print(CHEQ) - print('SHEQ(H)') - line = YD.loc(H) - ~((P.loc(I) * CH.loc(I, H) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0))).sum(I)) - - SHEQ = (line - S.loc(H)) - SHEQ.write(count, filename) - print(SHEQ.test(vars.initialVals)) - # print(SHEQ) - - print('PVAEQ(I)') - line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) - - PVAEQ = (line - PVA.loc(I)) - PVAEQ.write(count, filename) - print(PVAEQ.test(vars.initialVals)) - # print(PVAEQ) - - # Cobb-Douglas - # PFEQ(I)..DS(I) =E= DELTA(I)*PROD(F$ALPHA(F,I),(TT(F,I)*FD(F,I))**ALPHA(F,I)) - # CES - # PFEQ(I)..DS(I) =E= GAMMA(I)*(SUM(F, ALPHA(F,I)*(FD(F,I)**(RHO(I)))))**(1/RHO(I)) - - print('PFEQ(I)') - line = ExprM(vars, m=GAMMA.loc[I]) * ( - (ExprM(vars, m=ALPHA.loc[F, I]) * (FD.loc(F, I) ** ExprM(vars, m=RHO.loc[I]))).sum(F)) ** ExprM(vars, - m=1 / RHO.loc[ - I]) - - PFEQ = (line - DS.loc(I)) - PFEQ.write(count, filename) - print(PFEQ.test(vars.initialVals)) - - # FD of CES - # FDEQ(F,I).. (R(F,I) * RA(F)*(1 + SUM(GF,TAUFX(GF,F,I))))* (FD(F,I)**(1-RHO(I))) - # =E= PVA(I)* ALPHA(F,I)*(GAMMA(I)**RHO(I))*(DS(I)**(1-RHO(I))) - print('FDEQ(F,I)') - left = (R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I])) * ( - FD.loc(F, I) ** ExprM(vars, m=1 - RHO.loc[I])) - right = ~(PVA.loc(I) * (ExprM(vars, m=ALPHA.loc[F, I] * (GAMMA.loc[I] ** RHO.loc[I])) * ( - DS.loc(I) ** ExprM(vars, m=1 - RHO.loc[I])))) - FDEQ = (right - left) - FDEQ.setCondition(FD0.loc[F, I], 'INEQ', 0) - - # FDEQ.test(vars.initialVals) - FDEQ.write(count, filename) - print(FDEQ.test(vars.initialVals)) - # print(FDEQ) - - # VEQ(I).. V(I) =E= SUM(J, AD(I,J) * DS(J) ) - print('VEQ(I)') - line = (ExprM(vars, m=AD.loc[I, J]) * ~DS.loc(J)).sum(1) - - VEQ = (line - V.loc(I)) - VEQ.write(count, filename) - print(VEQ.test(vars.initialVals)) - # print(VEQ) - - # YFEQL(F).. Y(F) =E= SUM(IG, R(F,IG) * RA(F)*FD(F,IG)) - print('YFEQL(L)') - line = (R.loc(F, IG) * RA.loc(F) * FD.loc(F, IG)).sum(IG) - - YFEQL = (line - Y.loc(F)) - YFEQL.write(count, filename) - print(YFEQL.test(vars.initialVals)) - # print(YFEQL) - - # KAPFOR(K).. KPFOR(K) =E= KFOR(K) * Y(K) - print('KAPFOR(K)') - line = ExprM(vars, m=KFOR.loc[K]) * Y.loc(K) - - KAPFOR = (line - KPFOR.loc(K)) - KAPFOR.write(count, filename) - print(KAPFOR.test(vars.initialVals)) - # print(KAPFOR) - - print('XEQ(I)') - line = ExprM(vars, m=CX0.loc[I]) * ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / ExprM(vars, - m=PW0.loc[I] * ( - 1 + - TAUQ.loc[ - GS, I].sum( - 0)))) ** ExprM( - vars, m=ETAE.loc[I]) - - XEQ = (line - CX.loc(I)) - XEQ.write(count, filename) - print(XEQ.test(vars.initialVals)) - # print(XEQ) - - # DEQ(I)$PWM0(I).. D(I) =E= D0(I) *(PD(I)/PWM0(I))**(ETAD(I)) - print('DEQ(I)$PWM0(I)') - line = ExprM(vars, m=D0.loc[I]) * (PD.loc(I) / ExprM(vars, m=PWM0.loc[I])) ** ExprM(vars, m=ETAD.loc[I]) - - DEQ = (line - D.loc(I)) - # DEQ.setCondition(PWM0.loc[I]) - DEQ.write(count, filename) - print(DEQ.test(vars.initialVals)) - # print(DEQ) - - # MEQ(I).. M(I) =E= ( 1 - D(I) ) * DD(I) - print('MEQ(I)') - line = (1 - D.loc(I)) * DD.loc(I) - - MEQ = (line - M.loc(I)) - MEQ.write(count, filename) - print(MEQ.test(vars.initialVals)) - # print(MEQ) - - # PEQ(I).. P(I) =E= D(I) * PD(I) + ( 1 - D(I) ) * PWM0(I) - print('PEQ(I)') - line = (D.loc(I) * PD.loc(I) + (1 - D.loc(I)) * ExprM(vars, m=PWM0.loc[I])) - - PEQ = (line - P.loc(I)) - PEQ.write(count, filename) - print(PEQ.test(vars.initialVals)) - - print('NKIEQ') - line1 = (M.loc(I) * ExprM(vars, m=PWM0.loc[I])).sum(I) - line2 = (CX.loc(I) * PD.loc(I)).sum(I) - line3 = (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) - line5 = KPFOR.loc(K).sum(K) - line6 = GVFOR.loc(G).sum(G) - line7 = (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM)).sum(CM) - line8 = (ExprM(vars, m=CMIWAGE.loc[L]) * CMI.loc(L)).sum(L) - - NKIEQ = ((line1 - line2 - line3 - line5 - line6 - line7 - line8) - NKI) - NKIEQ.write(count, filename) - print(NKIEQ.test(vars.initialVals)) - # print(NKIEQ) - - # NEQ(K,I).. N(K,I) =E= N0(K,I)*(R(K,I)/R0(K,I))**(ETAIX(K,I)) - print('NEQ(K,I)') - line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** ExprM(vars, m=ETAIX.loc[K, I]) - - NEQ = (line - N.loc(K, I)) - NEQ.write(count, filename) - print(NEQ.test(vars.initialVals)) - # print(NEQ) - - # CNEQ(I).. P(I)*(1 + SUM(GS, TAUN(GS,I)))*CN(I) - # =E= SUM(IG, B(I,IG)*(SUM(K, N(K,IG)))) - print('CNEQ(I)') - left = P.loc(I) * ExprM(vars, m=1 + TAUN.loc[GS, I].sum(0)) * CN.loc(I) - right = (ExprM(vars, m=B.loc[I, IG]) * N.loc(K, IG).sum(K)).sum(IG) - - CNEQ = (right - left) - CNEQ.write(count, filename) - print(CNEQ.test(vars.initialVals)) - # print(CNEQ) - - # KSEQ(K,IG).. KS(K,IG) =E= KS0(K,IG) * ( 1 - DEPR) + N(K,IG) - print('KSEQ(K,IG)') - line = ExprM(vars, m=KS0.loc[K, IG] * (1 - DEPR)) + N.loc(K, IG) - - KSEQ = (line - KS.loc(K, IG)) - KSEQ.write(count, filename) - print(KSEQ.test(vars.initialVals)) - - print('LSEQ1(H)') - line1 = ExprM(vars, m=HW0.loc[H] / HH0.loc[H]) - LSEQ1line2pre = FD.loc(L, Z).sum(1) - line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) - * (LSEQ1line2pre.sum(0) / ( - (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum(CM) + CMI.loc( - L).sum(L))) - + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) - * (CMO.loc(CM).sum(CM) / ( - (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum( - CM) + CMI.loc(L).sum(L))))) ** ExprM(vars, m=ETARA.loc[H]) - line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / ( - ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) - line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + ( - ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) - / ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum( - G))) ** ExprM(vars, m=ETAPIT.loc[H]) - - LSEQ1 = ((line1 * line2 * line3 * line4) - HW.loc(H) / HH.loc(H)) - LSEQ1.write(count, filename) - print(LSEQ1.test(vars.initialVals)) - # print(LSEQ1) - - print('LSEQ2A') - line = ExprM(vars, m=CMO0.loc[CM1]) * ( - FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM1])) - - LSEQ2A = (line - CMO.loc(CM1)) - LSEQ2A.write(count, filename) - print(LSEQ2A.test(vars.initialVals)) - # print(LSEQ2A) - - print('LSEQ2B') - line = ExprM(vars, m=CMO0.loc[CM2]) * ( - FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM2])) - - LSEQ2B = (line - CMO.loc(CM2)) - LSEQ2B.write(count, filename) - print(LSEQ2B.test(vars.initialVals)) - - print('LSEQ2C') - line = ExprM(vars, m=CMO0.loc[CM3]) * ( - FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM3])) - - LSEQ2C = (line - CMO.loc(CM3)) - LSEQ2C.write(count, filename) - print(LSEQ2C.test(vars.initialVals)) - - print('LSEQ3') - line = ExprM(vars, m=CMI0.loc[L]) * ( - (FD.loc(L, FG).sum(FG) / ExprM(vars, m=FD0.loc[L, FG].sum(1))) ** (ExprM(vars, m=ECOMI.loc[L]))) - - LSEQ3 = (line - CMI.loc(L)) - LSEQ3.write(count, filename) - print(LSEQ3.test(vars.initialVals)) - - print('POPEQ(H)') - line1 = ExprM(vars, m=HH0.loc[H] * NRPG.loc[H]) - line2 = ExprM(vars, m=MI0.loc[H]) * ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / ( - CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) - line3 = ((HN.loc(H) / HH.loc(H)) / ExprM(vars, m=HN0.loc[H] / HH0.loc[H])) ** ExprM(vars, m=ETAU.loc[H]) - line4 = (CH.loc(HSD, H).sum(HSD) / ExprM(vars, m=CH0.loc[HSD, H].sum(0))) ** (1) - line5 = ExprM(vars, m=MO0.loc[H]) * (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / ( - ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) - line6 = (ExprM(vars, m=HN0.loc[H] / HH0.loc[H]) / (HN.loc(H) / HH.loc(H))) ** ExprM(vars, m=ETAU.loc[H]) - line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** (1) - - POPEQ = (line1 + line2 * line3 * line4 - line5 * line6 * line7 - HH.loc(H)) - POPEQ.write(count, filename) - print(POPEQ.test(vars.initialVals)) - - print('ANEQ(H)') - line = HH.loc(H) - HW.loc(H) - - ANEQ = (line - HN.loc(H)) - ANEQ.write(count, filename) - print(ANEQ.test(vars.initialVals)) - - print('YGEQ') - line1 = (ExprM(vars, m=TAUV.loc[GX, I]) * V.loc(I) * P.loc(I)).sum(I) - line2 = (ExprM(vars, m=TAUX.loc[GX, I]) * CX.loc(I) * PD.loc(I)).sum(I) - - YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) # first just set it to correct size - for label in GX: - for hlabel in H: - YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = Expr( - (ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) - - line3 = YGEQline3pre.sum(1) - line4 = (ExprM(vars, m=TAUN.loc[GX, I]) * CN.loc(I) * P.loc(I)).sum(I) - - YGEQline5pre = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) # first just set it to correct size - for label in GX: - YGEQline5pre.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) - line5 = YGEQline5pre - - line6 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) - for label in GX: - line6.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) - - line7 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) - for label in GX: - line7.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) - - line8 = (ExprM(vars, m=TAUFH.loc[GX, F]) * Y.loc(F)).sum(F) - line9 = (ExprM(vars, m=PIT0.loc[GX, H]) * Y.loc(H)).sum(H) - line10 = (ExprM(vars, m=TAUH.loc[GX, H]) * HH.loc(H)).sum(H) - line11 = IGT.loc(GX, GX1).sum(1) - - YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - Y.loc(GX)) - YGEQ.write(count, filename) - print(YGEQ.test(vars.initialVals)) - # print(YGEQ) - - print('YGEQ2(GT)') - line = IGT.loc(GT, GX).sum(GX) - - YGEQ2 = (line - Y.loc(GT)) - YGEQ2.write(count, filename) - print(YGEQ2.test(vars.initialVals)) - # print(YGEQ2) - - print('YGEQM(GNLM)') - line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) - - YGEQM = (line - Y.loc(GNLM)) - YGEQM.write(count, filename) - print(YGEQM.test(vars.initialVals)) - - print('YGEQO(GNLO)') - line = ExprM(vars, m=TAXS2.loc[GNLO]) * Y.loc(['CYGFO']) - - YGEQO = (line - Y.loc(GNLO)) - YGEQO.write(count, filename) - print(YGEQO.test(vars.initialVals)) - - print('GOVFOR(G)') - line = ExprM(vars, m=GFOR.loc[G]) * Y.loc(G) - - GOVFOR = (line - GVFOR.loc(G)) - GOVFOR.write(count, filename) - print(GOVFOR.test(vars.initialVals)) - - print('CGEQ(I,GN)') - left = P.loc(I) * ExprM(vars, m=1 + TAUG.loc[GS, I].sum(0)) * CG.loc(I, GN) - right = ExprM(vars, m=AG.loc[I, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) - - CGEQ = (right - left) - CGEQ.write(count, filename) - print(CGEQ.test(vars.initialVals)) - print('GFEQ(F,GN)') - - left = FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN])) - right = ExprM(vars, m=AG.loc[F, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) - - GFEQ = left - right - GFEQ.write(count, filename) - print(GFEQ.test(vars.initialVals)) - - print('GSEQL(GN)') - line1 = Y.loc(GN) + GVFOR.loc(GN) - line2 = (CG.loc(I, GN) * P.loc(I) * (1 + ExprM(vars, m=TAUG.loc[GS, I]).sum(GS))).sum(I) - line3 = (FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN]))).sum(F) - - GSEQL = ((line1 - ~line2 - ~line3) - S.loc(GN)) - GSEQL.write(count, filename) - print(GSEQL.test(vars.initialVals)) - - print('GSEQ(GX)') - line1 = (Y.loc(GX) + ExprM(vars, m=GFOR.loc[GX]) * Y.loc(GX)) - line2 = (ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H) - line3 = IGT.loc(G, GX).sum(G) - - GSEQ = ((line1 - ~line2 - ~line3) - S.loc(GX)) - GSEQ.write(count, filename) - print(GSEQ.test(vars.initialVals)) - - print('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') - line = ExprM(vars, m=TAXS.loc[G, GX]) * ( - Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) - - TDEQ = line - IGT.loc(G, GX) - TDEQ.setCondition(IGTD.loc[G, GX], 'EQ', 1) - TDEQ.write(count, filename) - print(TDEQ.test(vars.initialVals)) - print('SPIEQ') - line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + ( - ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) - - SPIEQ = (line - SPI) - SPIEQ.write(count, filename) - print(SPIEQ.test(vars.initialVals)) - - print('LMEQ1(L)') - left = (ExprM(vars, m=JOBCOR.loc[H, L]) * HW.loc(H)).sum(H) + CMI.loc(L) - right = FD.loc(L, Z).sum(Z) - - LMEQ1 = (right - left) - LMEQ1.write(count, filename) - print(LMEQ1.test(vars.initialVals)) - - print('KMEQ(K,IG)') - KMEQ = ((ExprM(vars, m=TT.loc[K, IG]) * FD.loc(K, IG)) - KS.loc(K, IG)) - KMEQ.write(count, filename) - print(KMEQ.test(vars.initialVals)) - - print('GMEQ(I)') - GMEQ = (DD.loc(I) + CX.loc(I) - M.loc(I) - DS.loc(I)) - GMEQ.write(count, filename) - print(GMEQ.test(vars.initialVals)) - - print('DDEQ(I)') - DDEQ = (V.loc(I) + CH.loc(I, H).sum(H) + CG.loc(I, G).sum(G) + CN.loc(I) - DD.loc(I)) - DDEQ.write(count, filename) - print(DDEQ.test(vars.initialVals)) - - # MODEL CLOSURE - - # FIX INTER GOVERNMENTAL TRANSFERS TO ZERO IF NOT IN ORIGINAL SAM - print('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') - FX1 = IGT.loc(G, GX) - FX1.setCondition(IGT0.loc[G, GX], 'EQ', 0) - FX1.write(count, filename) - # print(FX1) - - # FIX EXOGENOUS INTERGOVERNMENTAL TRANSFERS - print('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') - FX2 = IGT.loc(G, GX) - ExprM(vars, m=IGT0.loc[G, GX]) - FX2.setCondition(IGTD.loc[G, GX], 'EQ', 2) - FX2.write(count, filename) - - # FIX INTER SECTORAL WAGE DIFFERENTIALS - print('R.FX(L,Z)=R0(L,Z)') - FX3 = R.loc(L, Z) - ExprM(vars, m=R0.loc[L, Z]) - FX3.write(count, filename) - - # FIX ECONOMY WIDE SCALAR - print('RA.FX(K)=RA0(K)') - FX4 = RA.loc(K) - ExprM(vars, m=RA0.loc[K]) - FX4.write(count, filename) - # print(FX5) - - print("Objective") - obj = vars.getIndex('SPI') - - with open(filename, 'a') as f: - f.write('model.obj = Objective(expr=-1*model.x' + str(obj) + ')') - - -def run_solver(cons_filename, temp_file_name="tmp.py"): - solver = 'ipopt' - solver_io = 'nl' - stream_solver = True # True prints solver output to screen - keepfiles = False # True prints intermediate file names (.nl,.sol,...) - opt = SolverFactory(solver, solver_io=solver_io) - - if opt is None: - print("") - print("ERROR: Unable to create solver plugin for %s " - "using the %s interface" % (solver, solver_io)) - print("") - exit(1) - - # Create the model - model = ConcreteModel() - set_variable(cons_filename) - set_equation(cons_filename) - - # read the model - exec(open(cons_filename).read()) - - # Declare all suffixes - - # Ipopt bound multipliers (obtained from solution) - model.ipopt_zL_out = Suffix(direction=Suffix.IMPORT) - model.ipopt_zU_out = Suffix(direction=Suffix.IMPORT) - - # Ipopt bound multipliers (sent to solver) - model.ipopt_zL_in = Suffix(direction=Suffix.EXPORT) - model.ipopt_zU_in = Suffix(direction=Suffix.EXPORT) - - # Obtain dual solutions from first solve and send to warm start - model.dual = Suffix(direction=Suffix.IMPORT_EXPORT) - - # opt.options['halt_on_ampl_error'] = 'yes' - # opt.options['acceptable_tol'] = '1e-3' - ### Send the model to ipopt and collect the solution - # results = opt.solve(model,keepfiles=keepfiles,tee=stream_solver) - - # IMPORT / IMPORT_EXPORT Suffix components) - # model.solutions.load_from(results) - - ### Set Ipopt options for warm-start - # The current values on the ipopt_zU_out and - # ipopt_zL_out suffixes will be used as initial - # conditions for the bound multipliers to solve - # the new problem - model.ipopt_zL_in.update(model.ipopt_zL_out) - model.ipopt_zU_in.update(model.ipopt_zU_out) - opt.options['warm_start_init_point'] = 'yes' - opt.options['warm_start_bound_push'] = 1e-6 - opt.options['warm_start_mult_bound_push'] = 1e-6 - opt.options['mu_init'] = 1e-6 - # opt.options['acceptable_tol'] = 10 - # opt.options['max_iter'] = 15 - # opt.options['compl_inf_tol'] = 1e-3 - # opt.options['bound_relax_factor'] = 0 - # opt.options['start_with_resto'] = 'yes' - # opt.options['acceptable_iter'] = 15 - # opt.options['halt_on_ampl_error'] = 'yes' - # opt.options['fixed_variable_treatment'] = 'relax_bounds' - # opt.options['print_options_documentation'] = 'yes' - - # Send the model and suffix information to ipopt and collect the solution - # The solver plugin will scan the model for all active suffixes - # valid for importing, which it will store into the results object - - results = opt.solve(model, keepfiles=keepfiles, tee=stream_solver) - - x = [None for i in range(vars.nvars)] - - with open(temp_file_name, 'w') as f: - for i in range(vars.nvars): - f.write('x[' + str(i) + ']=value(model.x' + str(i) + ')\n') - - exec(open(temp_file_name).read()) - - soln.append(x[:]) - - return None - - -''' -Calibrate the model -''' - -soln = [] -filename = os.path.join(filePath, "ipopt_cons.py") -tmp = os.path.join(filePath, "tmp.py") -print("Calibration: ") -run_solver(filename, tmp) - -''' -Simulation code below: -In each simulation: - -1. Apply simulation code (for instance PI(I) = 1.02). -2. Rewrite all equations -3. Solve the new model with the result from last run as initial guess. - -''' - -# begin shock on specific industries or household groups - -# begin shock by using tables - -# iNum = 1 # dynamic model itterations - -sims = pd.read_csv(os.path.join(filePath, 'SIMS 500.csv'), index_col=0) -iNum = 1 -KS00 = KS0.copy() - -for num in range(iNum): - # print("Simulation: ", num+1) - KS0.loc[K, I] = KS00.loc[K, I].mul(sims.iloc[:, num]) - run_solver(filename, tmp) - -# end shock by using tables - -exec(open(os.path.join(modelPath, "shelby_output.py")).read()) diff --git a/pyincore/analyses/shelbycge/shelby_output.py b/pyincore/analyses/shelbycge/shelby_output.py deleted file mode 100755 index 4d8a6596d..000000000 --- a/pyincore/analyses/shelbycge/shelby_output.py +++ /dev/null @@ -1,211 +0,0 @@ -""" -# After running a model, use solution dictionaries to replicate GAMS -# results with DataFrames -# -# NOTE: -# solution variables stored in "vars" and "soln" objects should -# be the primary source for model evaluation. -# This swas only created to assist those unfamiliar with python objects -""" - -#from jopSmall.OutputFunctions import baseValue, newValue, getDiff -import pandas as pd - -#CG0 -CG0 = vars.get('CG', x=soln[0]) - -#CH0 -CH0 = vars.get('CH', x=soln[0]) - -#CMI0 -CMI0 = vars.get('CMI', x=soln[0]) - -#CMO0 -CMO0 = vars.get('CMO', x=soln[0]) - -#CN0 -CN0 = vars.get('CN', x=soln[0]) - -#CPI0 -CPI0 = vars.get('CPI', x=soln[0]) - -#CX0 -CX0 = vars.get('CX', x=soln[0]) - -#D0 -D0 = vars.get('D', x=soln[0]) - -#DD0 -DD0 = vars.get('DD', x=soln[0]) - -#DS0 -DS0 = vars.get('DS', x=soln[0]) - -#FD -FD0 = vars.get('FD', x=soln[0]) - -#IGT -IGT0 = vars.get('IGT', x=soln[0]) - -#KS -KS0 = vars.get('KS', x=soln[0]) - -#LAS -#LAS0 = vars.get('LAS', x=soln[0]) - -#HH -HH0 = vars.get('HH', x=soln[0]) - -#HN -HN0 = vars.get('HN', x=soln[0]) - -#HW -HW0 = vars.get('HW', x=soln[0]) - -#M -M0 = vars.get('M', x=soln[0]) - -#N -N0 = vars.get('N', x=soln[0]) - -#NKI -NKI0 = vars.get('NKI', x=soln[0]) - -#LNFOR -#LNFOR0 = vars.get('LNFOR', x=soln[0]) - -#KPFOR -KPFOR0 = vars.get('KPFOR', x=soln[0]) - -#GVFOR -GVFOR0 = vars.get('GVFOR', x=soln[0]) - -#P -P0 = vars.get('P', x=soln[0]) - -#PD -PD0 = vars.get('PD', x=soln[0]) - -#PVA -PVA0 = vars.get('PVA', x=soln[0]) - -#RA -RA0 = vars.get('RA', x=soln[0]) - -#R -R0 = vars.get('R', x=soln[0]) - -#S -S0 = vars.get('S', x=soln[0]) - -#SPI -SPI0 = vars.get('SPI', x=soln[0]) - -#V -V0 = vars.get('V', x=soln[0]) - -#Y -Y0 = vars.get('Y', x=soln[0]) - -#Yd -YD0 = vars.get('YD', x=soln[0]) - -# DIFFERENCES -writer = pd.ExcelWriter('test.xlsx',engine='xlsxwriter') -workbook=writer.book - -emplist = [] -dsrlist = [] -dsclist = [] -hhinclist = [] -miglist = [] -simlist = [] - -for i in range(iNum): - - CGL = vars.get('CG', x=soln[i+1]) - CHL = vars.get('CH', x=soln[i+1]) - CMIL = vars.get('CMI', x=soln[i+1]) - CMOL = vars.get('CMO', x=soln[i+1]) - CNL = vars.get('CN', x=soln[i+1]) - CPIL = vars.get('CPI', x=soln[i+1]) - CXL = vars.get('CX', x=soln[i+1]) - DL = vars.get('D', x=soln[i+1]) - DDL = vars.get('DD', x=soln[i+1]) - DSL = vars.get('DS', x=soln[i+1]) - FDL = vars.get('FD', x=soln[i+1]) - IGTL = vars.get('IGT', x=soln[i+1]) - KSL = vars.get('KS', x=soln[i+1]) - #LASL = vars.get('LAS', x=soln[i+1]) - HHL = vars.get('HH', x=soln[i+1]) - HNL = vars.get('HN', x=soln[i+1]) - HWL = vars.get('HW', x=soln[i+1]) - ML = vars.get('M', x=soln[i+1]) - NL = vars.get('N', x=soln[i+1]) - NKIL = vars.get('NKI', x=soln[i+1]) - #LNFORL = vars.get('LNFOR', x=soln[i+1]) - KPFORL = vars.get('KPFOR', x=soln[i+1]) - GVFORL = vars.get('GVFOR', x=soln[i+1]) - PL = vars.get('P', x=soln[i+1]) - PDL = vars.get('PD', x=soln[i+1]) - PVAL = vars.get('PVA', x=soln[i+1]) - RAL = vars.get('RA', x=soln[i+1]) - RL = vars.get('R', x=soln[i+1]) - SL = vars.get('S', x=soln[i+1]) - SPIL = vars.get('SPI', x=soln[i+1]) - VL = vars.get('V', x=soln[i+1]) - YL = vars.get('Y', x=soln[i+1]) - YDL = vars.get('YD', x=soln[i+1]) - - DFCG = CGL - CG0 - DFFD = FDL - FD0 - DK = KSL - KS0 - DY = (YL/CPIL) - Y0 - DDS = DSL - DS0 - DDD = DDL - DD0 - DCX = CXL - CX0 - DCH = CHL - CH0 - DR = RL - R0 - DCMI = CMIL - CMI0 - DCMO = CMOL - CMO0 - - DM = ML - M0 - - DV = VL - V0 - - DN = NL - N0 - - s_name = 'Simulation ' + str(i+1) - - - emp = DFFD[DFFD.index.isin(['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'])].sum().sum() - dsr = DDS[DDS.index.isin(['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', - 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', - 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'])].sum() - dsc = DDS[DDS.index.isin(['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', 'OTHERD', - 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', 'OTHERH'])].sum() - hhinc = DY[DY.index.isin(['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', 'HH5C', - 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', 'HH5F', - 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'])].sum() - hhdiff = HHL-HH0 - mig = hhdiff.sum() - - emplist.append(emp) - dsrlist.append(dsr) - dsclist.append(dsc) - hhinclist.append(hhinc) - miglist.append(mig) - simlist.append(s_name) - - - -cols = {'dsc' : dsclist, - 'dsr' : dsrlist, - 'mig' : miglist, - 'emp' : emplist, - 'hhinc' : hhinclist} - -df = pd.DataFrame.from_dict(cols) -df.to_csv('simulation_outputs.csv') diff --git a/pyincore/analyses/shelbycge/shelbycge.py b/pyincore/analyses/shelbycge/shelbycge.py new file mode 100644 index 000000000..6797be77e --- /dev/null +++ b/pyincore/analyses/shelbycge/shelbycge.py @@ -0,0 +1,2385 @@ +# Copyright (c) 2019 University of Illinois and others. All rights reserved. +# +# This program and the accompanying materials are made available under the +# terms of the Mozilla Public License v2.0 which accompanies this distribution, +# and is available at https://www.mozilla.org/en-US/MPL/2.0/ + +import os +import pandas as pd + +from pyincore import BaseAnalysis +from pyincore import globals as pyglobals +from equationlib import * +from pyomo.environ import * +from pyomo.opt import SolverFactory + + +logger = pyglobals.LOGGER + +class ShelbyCGEModel(BaseAnalysis): + """A computable general equilibrium (CGE) model is based on fundamental economic principles. + A CGE model uses multiple data sources to reflect the interactions of households, + firms and relevant government entities as they contribute to economic activity. + The model is based on (1) utility-maximizing households that supply labor and capital, + using the proceeds to pay for goods and services (both locally produced and imported) + and taxes; (2) the production sector, with perfectly competitive, profit-maximizing firms + using intermediate inputs, capital, land and labor to produce goods and services for both + domestic consumption and export; (3) the government sector that collects taxes and uses + tax revenues in order to finance the provision of public services; and (4) the rest of the world. + + Args: + incore_client (IncoreClient): Service authentication. + + """ + def __init__(self, incore_client): + super(ShelbyCGEModel, self).__init__(incore_client) + + def get_spec(self): + return { + 'name': 'Shelby cge', + 'description': 'CGE model for Shelby.', + 'input_parameters': [ + { + 'id': 'print_solver_output', + 'required': False, + 'description': 'Print solver output.', + 'type': bool + }, + { + 'id': 'solver_path', + 'required': False, + 'description': 'Path to ipopt package. If none is provided, it will default to your environment\'ts' + 'path to the package.', + 'type': str + } + ], + 'input_datasets': [ + { + 'id': 'SAM', + 'required': True, + 'description': 'Social accounting matrix (SAM) contains data for firms, ' + 'households and government which are organized in a way to ' + 'represent the interactions of all three entities in a typical economy.', + 'type': ['incore:SeasideCGEsam'] + }, + { + 'id': 'BB', + 'required': True, + 'description': 'BB is a matrix which describes how investment in physical infrastructure is' + ' transformed into functioning capital such as commercial and residential buildings.' + ' These data are collected from the Bureau of Economic Analysis (BEA).', + 'type': ['incore:SeasideCGEbb'] + }, + { + 'id': 'HHTABLE', + 'required': True, + 'description': 'HH Table.', + 'type': ['incore:SeasideCGEhhtable'] + }, + { + 'id': 'EMPLOY', + 'required': True, + 'description': 'EMPLOY is a table name containing data for commercial sector employment.', + 'type': ['incore:SeasideCGEemploy'] + }, + { + 'id': 'JOBCR', + 'required': True, + 'description': 'JOBCR is a matrix describing the supply of workers' + ' coming from each household group in the economy.', + 'type': ['incore:SeasideCGEjobcr'] + }, + { + 'id': 'SIMS', + 'required': True, + 'description': 'Random numbers for the change of capital stocks in the CGE model.', + 'type': ['incore:SeasideCGEsim'] + }, + { + 'id': 'sector_shocks', + 'required': True, + 'description': 'Aggregation of building functionality states to capital shocks per sector', + 'type': ['incore:capitalShocks'] + } + ], + 'output_datasets': [ + { + 'id': 'Seaside_Sims', + 'parent_type': '', + 'description': 'CSV file of Seaside cge simulations', + 'type': 'incore:SeasideCGEsims' + }, + { + 'id': 'Seaside_output', + 'parent_type': '', + 'description': 'CSV file of output of Seaside cge, containing changes in employment and supply.', + 'type': 'incore:SeasideCGEEmployDS' + } + ] + } + + def run(is_cd=True, test_values=False): + def _(x): + return ExprM(vars, m=x) + + # ---------------------------------------------------------------- + # set file paths + # ---------------------------------------------------------------- + modelPath = os.getcwd() + filePath = os.path.join(modelPath, 'files') + miscPath = os.path.join(filePath, 'MiscFile') + + # ---------------------------------------------------------------- + # define sets + # ---------------------------------------------------------------- + # ALL ACCOUNTS IN SOCIAL ACCOUNTING MATRIX + Z = [ + 'GOODSA', + 'TRADEA', + 'OTHERA', + 'GOODSB', + 'TRADEB', + 'OTHERB', + 'GOODSC', + 'TRADEC', + 'OTHERC', + 'GOODSD', + 'TRADED', + 'OTHERD', + 'GOODSE', + 'TRADEE', + 'OTHERE', + 'GOODSF', + 'TRADEF', + 'OTHERF', + 'GOODSG', + 'TRADEG', + 'OTHERG', + 'GOODSH', + 'TRADEH', + 'OTHERH', + 'HS1A', + 'HS2A', + 'HS3A', + 'HS1B', + 'HS2B', + 'HS3B', + 'HS1C', + 'HS2C', + 'HS3C', + 'HS1D', + 'HS2D', + 'HS3D', + 'HS1E', + 'HS2E', + 'HS3E', + 'HS1F', + 'HS2F', + 'HS3F', + 'HS1G', + 'HS2G', + 'HS3G', + 'HS1H', + 'HS2H', + 'HS3H', + 'L1A', + 'L2A', + 'L3A', + 'L1B', + 'L2B', + 'L3B', + 'L1C', + 'L2C', + 'L3C', + 'L1D', + 'L2D', + 'L3D', + 'L1E', + 'L2E', + 'L3E', + 'L1F', + 'L2F', + 'L3F', + 'L1G', + 'L2G', + 'L3G', + 'L1H', + 'L2H', + 'L3H', + 'KAP', + 'HH1A', + 'HH2A', + 'HH3A', + 'HH4A', + 'HH5A', + 'HH1B', + 'HH2B', + 'HH3B', + 'HH4B', + 'HH5B', + 'HH1C', + 'HH2C', + 'HH3C', + 'HH4C', + 'HH5C', + 'HH1D', + 'HH2D', + 'HH3D', + 'HH4D', + 'HH5D', + 'HH1E', + 'HH2E', + 'HH3E', + 'HH4E', + 'HH5E', + 'HH1F', + 'HH2F', + 'HH3F', + 'HH4F', + 'HH5F', + 'HH1G', + 'HH2G', + 'HH3G', + 'HH4G', + 'HH5G', + 'HH1H', + 'HH2H', + 'HH3H', + 'HH4H', + 'HH5H', + 'INVES', + 'USSOCL1A', + 'USSOCL2A', + 'USSOCL3A', + 'USSOCL1B', + 'USSOCL2B', + 'USSOCL3B', + 'USSOCL1C', + 'USSOCL2C', + 'USSOCL3C', + 'USSOCL1D', + 'USSOCL2D', + 'USSOCL3D', + 'USSOCL1E', + 'USSOCL2E', + 'USSOCL3E', + 'USSOCL1F', + 'USSOCL2F', + 'USSOCL3F', + 'USSOCL1G', + 'USSOCL2G', + 'USSOCL3G', + 'USSOCL1H', + 'USSOCL2H', + 'USSOCL3H', + 'MEMPROPTAX', + 'OTHERPROPTAX', + 'MEMSALESTAX', + 'OTHERSALESTAX', + 'MEMFEE', + 'OTHERFEE', + 'TNSTX', + 'TNITAX', + 'USPIT', + 'CYGFM', + 'CYGFO', + 'FED', + 'STATE', + 'MEMPHIS', + 'OTHER', + 'OUTCOM1', + 'OUTCOM2', + 'OUTCOM3', + 'ROW'] + + # FACTORS + F = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', + 'L1F', 'L2F', 'L3F', 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', 'KAP'] + F11 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] + F21 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] + F31 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] + + # COMMUTERS OUT + CM = ['OUTCOM1', 'OUTCOM2', 'OUTCOM3'] + + # COMMUTERS OUT 1 + CM1 = ['OUTCOM1'] + + # COMMUTERS OUT 2 + CM2 = ['OUTCOM2'] + + # COMMUTERS OUT 3 + CM3 = ['OUTCOM3'] + + # ALL WORKERS WHO LIVE IN SHELBY + LT = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', + 'L1F', 'L2F', 'L3F', 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H', 'OUTCOM1', 'OUTCOM2', 'OUTCOM3'] + + # LABOR + L = ['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', + 'L1F', 'L2F', 'L3F', 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'] + + L1 = ['L1A', 'L1B', 'L1C', 'L1D', 'L1E', 'L1F', 'L1G', 'L1H'] + + L2 = ['L2A', 'L2B', 'L2C', 'L2D', 'L2E', 'L2F', 'L2G', 'L2H'] + + L3 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] + + # LAND + # LA(F) = ['LAND'] + + # CAPITAL + K = ['KAP'] + + # GOVERNMENTS + G = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', + 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', + 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', + 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', + 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT', 'CYGFM', 'CYGFO', 'FED', + 'STATE', 'MEMPHIS', 'OTHER'] + + # ENDOGENOUS GOVERNMENTS + GN = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] + + # LOCAL ENDOGENOUS GOVERNMENTS + GNLM = ['MEMPHIS'] + + # LOCAL ENDOGENOUS GOVERNMENTS + GNLO = ['OTHER'] + + # EXOGENOUS GOVERMENTS + GX = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', + 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', + 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', + 'MEMPROPTAX', 'OTHERPROPTAX', 'MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', + 'OTHERFEE', 'TNSTX', 'TNITAX', 'USPIT'] + + # SALES OR EXCISE TAXES + GS = ['MEMSALESTAX', 'OTHERSALESTAX', 'MEMFEE', 'OTHERFEE', 'TNSTX'] + + # LAND TAXES + GL = ['MEMPROPTAX', 'OTHERPROPTAX'] + + # FACTOR TAXES + GF = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H', 'MEMPROPTAX', 'OTHERPROPTAX'] + + # SS PAYMENT + GFUS = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] + + # SS PAYMENT + GFUSC = ['USSOCL1A', 'USSOCL2A', 'USSOCL3A', 'USSOCL1B', 'USSOCL2B', 'USSOCL3B', 'USSOCL1C', 'USSOCL2C', 'USSOCL3C', + 'USSOCL1D', 'USSOCL2D', 'USSOCL3D', 'USSOCL1E', 'USSOCL2E', 'USSOCL3E', 'USSOCL1F', 'USSOCL2F', 'USSOCL3F', + 'USSOCL1G', 'USSOCL2G', 'USSOCL3G', 'USSOCL1H', 'USSOCL2H', 'USSOCL3H'] + + # INCOME TAX UNITS + GI = ['TNITAX', 'USPIT'] + + # HOUSEHOLD TAX UNITS + GH = ['MEMPROPTAX', 'OTHERPROPTAX', 'MEMFEE', 'OTHERFEE'] + + # ENDOGENOUS TRANSFER PMT + GT = ['CYGFM', 'CYGFO', 'FED', 'STATE'] + + # HOUSEHOLDS + H = ['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', + 'HH5C', + 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', + 'HH5F', + 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'] + + # I+G SECTORS + IG = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', + 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', + 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', + 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H', + 'FED', 'STATE', 'MEMPHIS', 'OTHER'] + + # INDUSTRY SECTORS + I = ['GOODSA', 'TRADEA', 'OTHERA', 'HS1A', 'HS2A', 'HS3A', 'GOODSB', 'TRADEB', 'OTHERB', 'HS1B', 'HS2B', 'HS3B', + 'GOODSC', 'TRADEC', 'OTHERC', 'HS1C', 'HS2C', 'HS3C', 'GOODSD', 'TRADED', 'OTHERD', 'HS1D', 'HS2D', 'HS3D', + 'GOODSE', 'TRADEE', 'OTHERE', 'HS1E', 'HS2E', 'HS3E', 'GOODSF', 'TRADEF', 'OTHERF', 'HS1F', 'HS2F', 'HS3F', + 'GOODSG', 'TRADEG', 'OTHERG', 'HS1G', 'HS2G', 'HS3G', 'GOODSH', 'TRADEH', 'OTHERH', 'HS1H', 'HS2H', 'HS3H'] + + # ENDOGENOUS GOVERNMENTS + IG2 = ['FED', 'STATE', 'MEMPHIS', 'OTHER'] + + # PRODUCTION SECTORS + IP = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', + 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', + 'OTHERH'] + + # PRODUCTION GOV. + FG = ['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', + 'OTHERD', + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', + 'OTHERH'] + + # HOUSING SERV.DEMAND + HSD = ['HS1A', 'HS2A', 'HS3A', 'HS1B', 'HS2B', 'HS3B', 'HS1C', 'HS2C', 'HS3C', 'HS1D', 'HS2D', 'HS3D', + 'HS1E', 'HS2E', 'HS3E', 'HS1F', 'HS2F', 'HS3F', 'HS1G', 'HS2G', 'HS3G', 'HS1H', 'HS2H', 'HS3H'] + + # SIMMLOOP + SM = ['BASE', 'TODAY', 'SIMM'] + + # REPORT 1 FOR SCALARS + R1H = ['GFREV', 'SFREV', 'PIT', + 'DGF', 'DSF', 'DDRE', 'PDRE', 'SPI', 'COMM', 'COMMO', + 'GN', 'NKI', 'HH', 'W', 'W1', 'W2', 'W3', 'R', 'RL', 'L', 'K', 'HN', 'HW', 'GFSAVM', 'GFSAVO', 'LD', + 'CMO', 'CMI', 'HC', 'SSC', 'LAND', 'LAS'] + + # REPORT 2 FOR STATUS + R2H = ['M-STAT', 'S-STAT'] + + # LABELS FOR MODEL STATUS + MS = ['OPTIMAL', 'LOCALOP', 'UNBOUND', + 'INFSBLE', 'INFSLOC', 'INFSINT', + 'NOOPTML', 'MIPSOLN', 'NOINTGR', + 'INFSMIP', 'UNUSED', 'UNKNOWN', + 'NOSOLUT'] + + # LABELS FOR SOLVER STATUS + SS = ['OK', 'ITERATE', 'RESRCE', + 'SOLVER', 'EVALUATE', 'NOTKNWN', + 'NOTUSED', 'PRE-PROC', 'SETUP', + 'SLVFAIL', 'SLVINTER', 'POST-PROC', + 'METSYS'] + + # =============================================================================== + # SETS FOR MISC TABLES ONLY + + # HOUSING SERVICES + HSSET = ['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', + 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] + + # HOUSING SERVICES 2 & 3 + HS23SET = ['HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'] + + # HOUSEHOLDS (INCOME 1) + HH1 = ['HH1A', 'HH1B', 'HH1C', 'HH1D', 'HH1E', 'HH1F', 'HH1G', 'HH1H'] + + # HOUSEHOLDS (INCOME 2) + HH2 = ['HH2A', 'HH2B', 'HH2C', 'HH2D', 'HH2E', 'HH2F', 'HH2G', 'HH2H'] + + # HOUSEHOLDS (INCOME 3) + HH3 = ['HH3A', 'HH3B', 'HH3C', 'HH3D', 'HH3E', 'HH3F', 'HH3G', 'HH3H'] + + # HOUSEHOLDS (INCOME 4) + HH4 = ['HH4A', 'HH4B', 'HH4C', 'HH4D', 'HH4E', 'HH4F', 'HH4G', 'HH4H'] + + # HOUSEHOLDS (INCOME 5) + HH5 = ['HH5A', 'HH5B', 'HH5C', 'HH5D', 'HH5E', 'HH5F', 'HH5G', 'HH5H'] + + # ELASTICITIES + ETA = ['ETAL1', 'ETAI1', 'ETALB1', 'ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU', 'ETAM', 'ETAE', 'ETAY', 'ETAOP'] + + # LANDCAP TABLE ELASTICITIES + ETALANDCAP = ['ETAL1', 'ETAI1', 'ETALB1'] + + # MISCH TABLE ELASTICITIES + ETAMISCH = ['ETAPIT', 'ETAPT', 'ETARA', 'NRPG', 'ETAYD', 'ETAU'] + + # MISC TABLE ELASTICITIES + ETAMISC = ['ETAM', 'ETAE', 'ETAY', 'ETAOP'] + + # ---------------------------------------------------------------- + # SET ALIASES + # ---------------------------------------------------------------- + + # ALIAS + J = I + I1 = I + Z1 = Z + F1 = F + G1 = G + G2 = G + GI1 = GI + GS1 = GS + GX1 = GX + GN1 = GN + GH1 = GH + GF1 = GF + H1 = H + HSD1 = HSD + JP = IP + JG = IG + GT1 = GT + GNLM1 = GNLM + GNLO1 = GNLO + + # ---------------------------------------------------------------- + # IMPORT ADDITIONAL DATA FILES + # ---------------------------------------------------------------- + + # SAM + SAM = pd.read_csv(os.path.join(filePath, 'SAM Shelby(1202).csv'), index_col=0) + + # CAPITAL COMP + BB = pd.read_csv(os.path.join(filePath, 'capcomshelby.csv'), index_col=0) + + # MISC TABLES + ''' + + ''' + + TPC = pd.DataFrame(index=H, columns=G).fillna(0.0) + IGTD = pd.DataFrame(index=G, columns=G1).fillna(0.0) + TAUFF = pd.DataFrame(index=G, columns=F).fillna(0.0) + IOUT = pd.DataFrame(index=G1, columns=G1).fillna(0.0) + LANDCAP = pd.DataFrame(index=IG, columns=ETALANDCAP).fillna(0.0) + MISC = pd.DataFrame(index=Z, columns=ETAMISC).fillna(0.0) + MISCH = pd.DataFrame(index=H, columns=ETAMISCH).fillna(0.0) + + # EMPLOY0 = pd.read_csv(os.path.join(miscPath, 'EMPLOY0(Z,F).csv'), index_col=0) + EMPLOY = pd.read_csv(os.path.join(miscPath, 'EMPLOY(Z,F).csv'), index_col=0) + JOBCR = pd.read_csv(os.path.join(miscPath, 'JOBCR(H,L).csv'), index_col=0) + # JOBCR1 = pd.read_csv(os.path.join(miscPath, 'JOBCR1(H,L).csv'), index_col=0) + HHTABLE = pd.read_csv(os.path.join(miscPath, 'HHTABLE(H,).csv'), index_col=0) + # OUTCR = pd.read_csv(os.path.join(miscPath, 'OUTCR(H,CM).csv'), index_col=0) + + # ---------------------------------------------------------------- + # PARAMETER DECLARATION + # ---------------------------------------------------------------- + + # these are data frames with zeros to be filled during calibration + A = pd.DataFrame(index=Z, columns=Z).fillna(0.0) + AD = pd.DataFrame(index=Z, columns=Z).fillna(0.0) + AG = pd.DataFrame(index=Z, columns=G).fillna(0.0) + AGFS = pd.DataFrame(index=Z, columns=G).fillna(0.0) + SIGMA = pd.Series(index=I, dtype=float).fillna(0.0) + ALPHA = pd.DataFrame(index=F, columns=I).fillna(0.0) + ALPHA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) + B = pd.DataFrame(index=I, columns=IG).fillna(0.0) + B1 = pd.DataFrame(index=I, columns=I).fillna(0.0) + CMOWAGE = pd.Series(index=CM, dtype=float).fillna(0.0) + CMIWAGE = pd.Series(index=L, dtype=float).fillna(0.0) + FCONST = pd.DataFrame(index=F, columns=I).fillna(0.0) + GAMMA = pd.Series(index=I, dtype=float).fillna(0.0) + DELTA = pd.Series(index=I, dtype=float).fillna(0.0) + PIT = pd.DataFrame(index=G, columns=H).fillna(0.0) + PIT0 = pd.DataFrame(index=G, columns=H).fillna(0.0) + PRIVRET1 = pd.Series(index=H, dtype=float).fillna(0.0) + PRIVRET = pd.Series(index=H, dtype=float).fillna(0.0) + # LFOR = pd.Series(index=LA, dtype=float).fillna(0.0) + KFOR = pd.Series(index=K, dtype=float).fillna(0.0) + GFOR = pd.Series(index=G, dtype=float).fillna(0.0) + out = pd.DataFrame(index=G, columns=G).fillna(0.0) + TAUFH = pd.DataFrame(index=G, columns=F).fillna(0.0) + TAUFL = pd.DataFrame(index=G, columns=L).fillna(0.0) + # TAUFLA = pd.DataFrame(index=G, columns=LA).fillna(0.0) + TAUFK = pd.DataFrame(index=G, columns=K).fillna(0.0) + TAUH = pd.DataFrame(index=G, columns=H).fillna(0.0) + TAUH0 = pd.DataFrame(index=G, columns=H).fillna(0.0) + TAUM = pd.DataFrame(index=G, columns=IG).fillna(0.0) + TAUQ = pd.DataFrame(index=G, columns=IG).fillna(0.0) + TAUC = pd.DataFrame(index=G, columns=I).fillna(0.0) + TAUCH = pd.DataFrame(index=G, columns=HSD).fillna(0.0) + TAUV = pd.DataFrame(index=G, columns=I).fillna(0.0) + TAUN = pd.DataFrame(index=G, columns=IG).fillna(0.0) + TAUX = pd.DataFrame(index=G, columns=IG).fillna(0.0) + TAUG = pd.DataFrame(index=G, columns=I).fillna(0.0) + TAXS = pd.DataFrame(index=G, columns=G).fillna(0.0) + TAXS1 = pd.Series(index=GNLM, dtype=float).fillna(0.0) + TAXS2 = pd.Series(index=GNLO, dtype=float).fillna(0.0) + + # ELASTICITIES AND TAX DATA IMPOSED + + BETA = pd.DataFrame(index=I, columns=H).fillna(0.0) + BETAH = pd.DataFrame(index=HSD, columns=H).fillna(0.0) + ETAD = pd.Series(index=I, dtype=float).fillna(0.0) + ETAE = pd.Series(index=I, dtype=float).fillna(0.0) + ETAI = pd.Series(index=IG, dtype=float).fillna(0.0) + ETAIX = pd.DataFrame(index=K, columns=IG).fillna(0.0) + # ETAL = pd.DataFrame(index=LA, columns=IG).fillna(0.0) + ETAL1 = pd.Series(index=IG, dtype=float).fillna(0.0) + ETALB1 = pd.Series(index=IG, dtype=float).fillna(0.0) + ETALB = pd.DataFrame(index=L, columns=IG).fillna(0.0) + ETAM = pd.Series(index=I, dtype=float).fillna(0.0) + ETARA = pd.Series(index=H, dtype=float).fillna(0.0) + ETAYDO = pd.Series(index=H, dtype=float).fillna(0.0) + ETAUO = pd.Series(index=H, dtype=float).fillna(0.0) + ETAYDI = pd.Series(index=H, dtype=float).fillna(0.0) + ETAUI = pd.Series(index=H, dtype=float).fillna(0.0) + ETAYD = pd.Series(index=H, dtype=float).fillna(0.0) + ETAU = pd.Series(index=H, dtype=float).fillna(0.0) + ETAPT = pd.Series(index=H, dtype=float).fillna(0.0) + ETAPIT = pd.Series(index=H, dtype=float).fillna(0.0) + EXWGEO = pd.Series(index=CM, dtype=float).fillna(0.0) + EXWGEI = pd.Series(index=L, dtype=float).fillna(0.0) + ECOMI = pd.Series(index=L, dtype=float).fillna(0.0) + ECOMO = pd.Series(index=CM, dtype=float).fillna(0.0) + HOUSECOR = pd.DataFrame(index=H, columns=HSD).fillna(0.0) + JOBCOR = pd.DataFrame(index=H, columns=L).fillna(0.0) + + LAMBDA = pd.DataFrame(index=I, columns=I).fillna(0.0) + LAMBDAH = pd.DataFrame(index=HSD, columns=HSD1).fillna(0.0) + + NRPG = pd.Series(index=H, dtype=float).fillna(0.0) + RHO = pd.Series(index=I, dtype=float).fillna(0.0) + TT = pd.DataFrame(index=Z, columns=IG).fillna(0.0) + + depr = pd.Series(index=IG, dtype=float).fillna(0.1) + + # ARRAYS BUILT TO EXPORT RESULTS TO SEPARATE FILE + + R1 = pd.DataFrame(index=R1H, columns=SM).fillna(0.0) + R2 = pd.DataFrame(index=R2H, columns=SM).fillna(0.0) + + # INITIAL VALUES OF ENDOGENOUS VARIABLES + + CG0 = pd.DataFrame(index=I, columns=G).fillna(0.0) + CG0T = pd.DataFrame(index=I, columns=G).fillna(0.0) + CH0 = pd.DataFrame(index=I, columns=H).fillna(0.0) + CH0T = pd.DataFrame(index=I, columns=H).fillna(0.0) + CMI0 = pd.Series(index=L, dtype=float).fillna(0.0) + CMO0 = pd.Series(index=CM, dtype=float).fillna(0.0) + CN0 = pd.Series(index=I, dtype=float).fillna(0.0) + CN0T = pd.Series(index=I, dtype=float).fillna(0.0) + CPI0 = pd.Series(index=H, dtype=float).fillna(0.0) + CPIN0 = pd.Series(index=H, dtype=float).fillna(0.0) + CPIH0 = pd.Series(index=H, dtype=float).fillna(0.0) + CX0 = pd.Series(index=I, dtype=float).fillna(0.0) + D0 = pd.Series(index=I, dtype=float).fillna(0.0) + DD0 = pd.Series(index=Z, dtype=float).fillna(0.0) + DS0 = pd.Series(index=Z, dtype=float).fillna(0.0) + DQ0 = pd.Series(index=Z, dtype=float).fillna(0.0) + + FD0 = pd.DataFrame(index=F, columns=Z).fillna(0.0) + IGT0 = pd.DataFrame(index=G, columns=GX).fillna(0.0) + KS0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) + KSNEW = pd.DataFrame(index=K, columns=IG).fillna(0.0) + KSNEW0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) + # LAS0 = pd.DataFrame(index=LA, columns=IG).fillna(0.0) + HH0 = pd.Series(index=H, dtype=float).fillna(0.0) + HN0 = pd.Series(index=H, dtype=float).fillna(0.0) + HW0 = pd.Series(index=H, dtype=float).fillna(0.0) + M0 = pd.Series(index=I, dtype=float).fillna(0.0) + M01 = pd.Series(index=Z, dtype=float).fillna(0.0) + MI0 = pd.Series(index=H, dtype=float).fillna(0.0) + MO0 = pd.Series(index=H, dtype=float).fillna(0.0) + N0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) + + # NKIO + + KPFOR01 = pd.Series(index=K, dtype=float).fillna(0.0) + KPFOR0 = pd.Series(index=K, dtype=float).fillna(0.0) + # LNFOR0 = pd.Series(index=LA, dtype=float).fillna(0.0) + # LNFOR01 = pd.Series(index=LA, dtype=float).fillna(0.0) + GVFOR0 = pd.Series(index=G, dtype=float).fillna(0.0) + P0 = pd.Series(index=IG, dtype=float).fillna(0.0) + PH0 = pd.Series(index=HSD, dtype=float).fillna(0.0) + PD0 = pd.Series(index=I, dtype=float).fillna(0.0) + PVA0 = pd.Series(index=I, dtype=float).fillna(0.0) + PWM0 = pd.Series(index=I, dtype=float).fillna(0.0) + PW0 = pd.Series(index=I, dtype=float).fillna(0.0) + Q0 = pd.Series(index=Z, dtype=float).fillna(0.0) + Q10 = pd.Series(index=Z, dtype=float).fillna(0.0) + R0 = pd.DataFrame(index=F, columns=Z).fillna(1.0) + RA0 = pd.Series(index=F, dtype=float).fillna(0.0) + S0 = pd.Series(index=Z, dtype=float).fillna(0.0) + + # SPIO + + V0 = pd.Series(index=I, dtype=float).fillna(0.0) + V0T = pd.Series(index=I, dtype=float).fillna(0.0) + V10 = pd.DataFrame(index=I, columns=I).fillna(0.0) + TP = pd.DataFrame(index=H, columns=G).fillna(0.0) + + # TAUF0 = Table(G,F,Z) + + YD0 = pd.Series(index=H, dtype=float).fillna(0.0) + Y0 = pd.Series(index=Z, dtype=float).fillna(0.0) + Y01 = pd.Series(index=H, dtype=float).fillna(0.0) + YT0 = pd.Series(index=G, dtype=float).fillna(0.0) + GCP10 = pd.Series(index=I, dtype=float).fillna(0.0) + + # GCP0 + + DDCX = pd.Series(index=I, dtype=float).fillna(0.0) + + TESTA1 = None + TESTA2 = None + TESTA3 = None + if not is_cd: + TESTA1 = pd.DataFrame(index=F, columns=I).fillna(0.0) + TESTA2 = pd.DataFrame(index=F, columns=I).fillna(0.0) + TESTA3 = pd.DataFrame(index=F, columns=I).fillna(0.0) + + # =============================================================================== + # SIMPLIFYING TABLES AND DOING AWAY WITH MISC FILES + # =============================================================================== + + for label in G1: + out.loc[label, label] = 0 + out.loc['MEMPHIS', 'CYGFM'] = 1 + out.loc['OTHER', 'CYGFO'] = 1 + + IGTD.loc[G, G1] = 0 + IGTD.loc['FED', GFUS] = 1 + IGTD.loc['FED', 'USPIT'] = 1 + + IGTD.loc['CYGFM', 'MEMPROPTAX'] = 1 + IGTD.loc['CYGFM', 'MEMSALESTAX'] = 1 + IGTD.loc['CYGFM', 'MEMFEE'] = 1 + + IGTD.loc['CYGFO', 'OTHERPROPTAX'] = 1 + IGTD.loc['CYGFO', 'OTHERSALESTAX'] = 1 + IGTD.loc['CYGFO', 'OTHERFEE'] = 1 + + IGTD.loc['STATE', 'TNSTX'] = 1 + IGTD.loc['STATE', 'TNITAX'] = 1 + + TPC.loc[H, G] = 0 + TPC.loc[H, GFUS] = 1 + + TAUFF.loc[G, F] = 0 + TAUFF.loc['USSOCL1A', 'L1A'] = 1 + TAUFF.loc['USSOCL2A', 'L2A'] = 1 + TAUFF.loc['USSOCL3A', 'L3A'] = 1 + TAUFF.loc['USSOCL1B', 'L1B'] = 1 + TAUFF.loc['USSOCL2B', 'L2B'] = 1 + TAUFF.loc['USSOCL3B', 'L3B'] = 1 + TAUFF.loc['USSOCL1C', 'L1C'] = 1 + TAUFF.loc['USSOCL2C', 'L2C'] = 1 + TAUFF.loc['USSOCL3C', 'L3C'] = 1 + TAUFF.loc['USSOCL1D', 'L1D'] = 1 + TAUFF.loc['USSOCL2D', 'L2D'] = 1 + TAUFF.loc['USSOCL3D', 'L3D'] = 1 + TAUFF.loc['USSOCL1E', 'L1E'] = 1 + TAUFF.loc['USSOCL2E', 'L2E'] = 1 + TAUFF.loc['USSOCL3E', 'L3E'] = 1 + TAUFF.loc['USSOCL1F', 'L1F'] = 1 + TAUFF.loc['USSOCL2F', 'L2F'] = 1 + TAUFF.loc['USSOCL3F', 'L3F'] = 1 + TAUFF.loc['USSOCL1G', 'L1G'] = 1 + TAUFF.loc['USSOCL2G', 'L2G'] = 1 + TAUFF.loc['USSOCL3G', 'L3G'] = 1 + TAUFF.loc['USSOCL1H', 'L1H'] = 1 + TAUFF.loc['USSOCL2H', 'L2H'] = 1 + TAUFF.loc['USSOCL3H', 'L3H'] = 1 + + TAUFF.loc['MEMPROPTAX', 'KAP'] = 1 + TAUFF.loc['OTHERPROPTAX', 'KAP'] = 1 + + for label in G1: + IOUT.loc[label, label] = 0 + IOUT.loc['MEMPHIS', 'CYGFM'] = 1 + IOUT.loc['OTHER', 'CYGFO'] = 1 + + LANDCAP.loc[IG, ETALANDCAP] = 1 + ''' + LANDCAP.loc['CONST1', 'ETAL1'] = 0.5 + LANDCAP.loc['RETAIL1', 'ETAL1'] = 2 + LANDCAP.loc['SERV1', 'ETAL1'] = 1.4 + LANDCAP.loc['HC1', 'ETAL1'] = 1.4 + LANDCAP.loc['ACCOM1', 'ETAL1'] = 0.5 + LANDCAP.loc['REST1', 'ETAL1'] = 0.5 + LANDCAP.loc['AG2', 'ETAL1'] = 0.5 + LANDCAP.loc['CONST2', 'ETAL1'] = 0.5 + LANDCAP.loc['MANUF2', 'ETAL1'] = 0.5 + LANDCAP.loc['RETAIL2', 'ETAL1'] = 2 + LANDCAP.loc['SERV2', 'ETAL1'] = 0.5 + LANDCAP.loc['HC2', 'ETAL1'] = 0.5 + LANDCAP.loc['ACCOM2', 'ETAL1'] = 0.5 + LANDCAP.loc['REST2', 'ETAL1'] = 0.5 + LANDCAP.loc['AG3', 'ETAL1'] = 0.5 + LANDCAP.loc['UTIL', 'ETAL1'] = 1.4 + LANDCAP.loc['CONST3', 'ETAL1'] = 1.4 + LANDCAP.loc['RETAIL3', 'ETAL1'] = 2 + LANDCAP.loc['SERV3', 'ETAL1'] = 1.4 + LANDCAP.loc['HC3', 'ETAL1'] = 2 + LANDCAP.loc['HS1', 'ETAL1'] = 2 + LANDCAP.loc['HS2', 'ETAL1'] = 2 + LANDCAP.loc['HS3', 'ETAL1'] = 2 + ''' + + MISCH.loc[H, ETAMISCH] = 0 + MISCH.loc[HH1, 'ETAPT'] = -0.5 + MISCH.loc[HH2, 'ETAPIT'] = -0.15 + MISCH.loc[HH3, 'ETAPIT'] = -0.2 + MISCH.loc[HH4, 'ETAPIT'] = -0.25 + MISCH.loc[HH5, 'ETAPIT'] = -0.35 + + MISCH.loc[H, 'NRPG'] = 1 + # MISCH.loc[H, 'ETARA'] = 1 + ''' + # DRAM + MISCH.loc[HH2, 'ETARA'] = 0.2 + MISCH.loc[HH3, 'ETARA'] = 0.3 + MISCH.loc[HH4, 'ETARA'] = 0.5 + MISCH.loc[HH5, 'ETARA'] = 0.8 + + MISCH.loc[HH1, 'ETAYD'] = 1.3 + MISCH.loc[HH2, 'ETAYD'] = 1.6 + MISCH.loc[HH3, 'ETAYD'] = 1.8 + MISCH.loc[HH4, 'ETAYD'] = 2.0 + MISCH.loc[HH5, 'ETAYD'] = 2.1 + + MISCH.loc[HH1, 'ETAU'] = -0.8 + MISCH.loc[HH2, 'ETAU'] = -0.6 + MISCH.loc[HH3, 'ETAU'] = -0.5 + MISCH.loc[HH4, 'ETAU'] = -0.4 + MISCH.loc[HH5, 'ETAU'] = -0.3 + ''' + MISC.loc[IG, ETAMISC] = 0 + MISC.loc[IP, 'ETAM'] = 1 + # MISC.loc[IP, 'ETAE'] = -3.65 + MISC.loc[I, 'ETAY'] = 1 + MISC.loc[I, 'ETAOP'] = -1 + + # =============================================================================== + # PARAMETERS AND ELASTICITIES + # =============================================================================== + + out.loc[G1, G1] = IOUT.loc[G1, G1]; + BETA.loc[I, H] = MISC.loc[I, 'ETAY']; + BETAH.loc[HSD, H] = MISC.loc[HSD, 'ETAY']; + + for label in I: + LAMBDA.loc[label, label] = MISC.loc[label, 'ETAOP']; + ''' + for label in HD: + LAMBDAH.loc[label,label] = MISC.loc[label,'ETAOP']; + ''' + ETAE.loc[I] = MISC.loc[I, 'ETAE']; + ETAM.loc[I] = MISC.loc[I, 'ETAM']; + ETARA.loc[H] = MISCH.loc[H, 'ETARA']; + + ETAPIT.loc[H] = MISCH.loc[H, 'ETAPIT']; + ETAPT.loc[H] = MISCH.loc[H, 'ETAPT']; + ETAYD.loc[H] = MISCH.loc[H, 'ETAYD']; + NRPG.loc[H] = MISCH.loc[H, 'NRPG']; + ETAU.loc[H] = MISCH.loc[H, 'ETAU']; + ETAI.loc[IG] = LANDCAP.loc[IG, 'ETAI1']; + ETAIX.loc['KAP', IG] = ETAI.loc[IG]; + + ''' + ETAIX.loc['KAP',IG] = LANDCAP.loc[IG,'ETAI1']; + ETAL.loc['LAND',IG] = LANDCAP.loc[IG,'ETAL1']; + ETALB.loc[L,IG] = LANDCAP.loc[IG,'ETALB1']; + ''' + + # ======================================================================================================== + # ====================play with elasticities============================================================== + # ======================================================================================================== + + # EXPERIMENTAL ELASTICITIES + ECOMI.loc[L] = 1; + ECOMO.loc[CM] = 1; + EXWGEO.loc[CM] = 1; + EXWGEI.loc[L] = 1; + ETAE.loc[IP] = -0.4; + ETAIX.loc['KAP', IG] = 0.1; + ETARA.loc[H] = 1.5; + ETAYDO.loc[H] = 1.0; + ETAYDI.loc[H] = 1.5; + ETAUI.loc[H] = -0.72; + ETAUO.loc[HH1] = -0.8; + ETAUO.loc[HH2] = -0.6; + ETAUO.loc[HH3] = -0.4; + ETAUO.loc[HH4] = -0.2; + ETAUO.loc[HH5] = -0.2; + ETAU.loc[H] = -0.1; + ETAYD.loc[H] = 1; + ''' + #ETARA[H] = 2.0; + #ETAIX['KAP',IG] = 0.1*ETAIX['KAP',IG]; + ETAIX.loc['KAP',IG] = 0.1; + ETAE.loc[IP] = -1.5; + + # DRAM ELASTICITIES + #ETAUO[H] = MISCH[H, 'ETAU']; + #ETAUI[H] = MISCH[H, 'ETAU']; + #ETAE[IP] = -1.65; + #ETAYDO[H] = ETAYD[H]; + #ETAYDI[H] = ETAYD[H]; + #ETAUI[H] = ETAU[H]; + #ETAUO[H] = ETAU[H]; + + SIGMA.loc[I] = 0.67; + ''' + + # =============================================================================== + # CALIBRATION + # =============================================================================== + + # Column Totals of SAM table + Q10.loc[Z] = SAM.loc[Z, Z].sum(1) + + # Row Totals of SAM table + Q0.loc[Z] = SAM.loc[Z, Z].sum(0) + + # difference of SAM row and coloumn totals + DQ0.loc[Z] = Q10.loc[Z] - Q0.loc[Z] + + # Column Totals of SAM table + Q10.loc[Z] = SAM.loc[Z].sum(0) + + B1.loc[I, I] = SAM.loc[I, I] + + # Calculate tax rates from SAM information + TAUQ_1 = SAM.loc[GS, I] + TAUQ_2 = SAM.loc[I, I].sum(1) + TAUQ_3 = SAM.loc[I, H].sum(1) + TAUQ_4 = SAM.loc[I, ['INVES']].sum(1) + TAUQ_5 = SAM.loc[I, G].sum(1) + TAUQ_6 = SAM.loc[I, ['ROW']].sum(1) + TAUQ_7 = SAM.loc[GS1, I].sum(0) + + TAUQ.loc[GS, I] = TAUQ_1 / (TAUQ_2 + TAUQ_3 + TAUQ_4 + TAUQ_5 + TAUQ_6 - TAUQ_7) + + # NOTE: + # set taxes to average if not specific to model + TAUC.loc[GS, I] = TAUQ.loc[GS, I] + TAUV.loc[GS, I] = TAUQ.loc[GS, I] + TAUN.loc[GS, I] = TAUQ.loc[GS, I] + TAUG.loc[GS, I] = TAUQ.loc[GS, I] + TAUX.loc[GS, I] = TAUQ.loc[GS, I] + + # FACTOR TAX RATES + TAUFarray = [[[0 for k in range(len(Z))] for j in range(len(F))] for i in range(len(G))] + for i in range(len(GF)): + for j in range(len(F)): + for k in range(len(I)): + if SAM.loc[F[j], I[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: + TAUFarray[G.index(GF[i])][j][Z.index(I[k])] = SAM.loc[GF[i], I[k]] / SAM.loc[F[j], I[k]] + + for i in range(len(GF)): + for j in range(len(F)): + for k in range(len(G)): + if SAM.loc[F[j], G[k]] != 0 and TAUFF.loc[GF[i], F[j]] != 0: + TAUFarray[G.index(GF[i])][j][Z.index(G[k])] = SAM.loc[GF[i], G[k]] / SAM.loc[F[j], G[k]] + + TAUFX_SUM_array = [[0 for j in range(len(Z))] for i in range(len(F))] + for i in range(len(F)): + for j in range(len(Z)): + tmp = 0 + for k in range(len(G)): + tmp += TAUFarray[k][i][j] + TAUFX_SUM_array[i][j] = tmp + + # TAUFX summed over GX + TAUFX_SUM = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) + + TAUFX_GF = pd.DataFrame(TAUFX_SUM_array, index=F, columns=Z).fillna(0.0) + + TAUFXgx = {} + for i in range(len(GX)): + TAUFXgx[GX[i]] = pd.DataFrame(TAUFarray[i], index=F, columns=Z).fillna(0.0) + + # SS TAX RATES + # TAUFH(GF,F)$(TAUFF(GF,F)) =SAM(GF,F) / SUM(Z, SAM(Z,F)); + for i in GF: + for j in F: + if TAUFF.loc[i, j] != 0: + # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[Z, F].sum(0).loc[j]) + TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[Z, F].sum(0).at[j] + + # TAUFH(GFUS,L) =SAM(GFUS,L) / SUM(IG, SAM(L,IG)); + for i in GFUS: + for j in L: + if TAUFF.loc[i, j] != 0: + # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[L, IG].sum(1).loc[j]) + TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[L, IG].sum(1).at[j] + + # EMPLOYEE PORTION OF FACTOR TAXES + TAUFL.loc[GF, L] = SAM.loc[GF, L] / (SAM.loc[Z, L].sum(0) - SAM.loc[L, ['ROW']].sum(1)) + + TAUFK.loc[GF, K] = SAM.loc[GF, K] / SAM.loc[Z, K].sum(0) + + # SHARES OF ENDOGENOUS GOVERNMENTS TRANFERS TO REVENUE + TAXS.loc[G, GX] = SAM.loc[G, GX] / SAM.loc[G, GX].sum(0) + + TAXS1.loc[GNLM] = SAM.loc[GNLM, ['CYGFM']].sum(1) / SAM.loc[GNLM, ['CYGFM']].sum(1).sum(0) + + TAXS2.loc[GNLO] = SAM.loc[GNLO, ['CYGFO']].sum(1) / SAM.loc[GNLO, ['CYGFO']].sum(1).sum(0) + + # SET INITIAL INTER GOVERNMENTAL TRANSFERS + IGT0.loc[G, GX] = SAM.loc[G, GX] + + # SET INITIAL PRICES TO UNITY LESS SALES AND EXCISE TAXES + PW0.loc[I] = 1.0 + PWM0.loc[I] = 1.0 + P0.loc[I] = 1.0 + PD0.loc[I] = 1.0 + CPI0.loc[H] = 1.0 + CPIN0.loc[H] = 1.0 + CPIH0.loc[H] = 1.0 + TT.loc[F, IG] = 1.0 + + # HOUSEHOLD TRANSFER PAYMENTS AND PERSONAL INCOME TAXES + # TOTAL HH IN Shelby + HH0.loc[H] = HHTABLE.loc[H, 'HH0'] + + # TOTAL WORKING HH IN SHELBY (WORK IN SHELBY & OUTSIDE SHELBY) + HW0.loc[H] = HHTABLE.loc[H, 'HW0'] + + # NON WORKING HH IN SHELBY + HN0.loc[H] = HH0.loc[H] - HW0.loc[H] + + # NOMINAL GOVERNMENT SS PAYMENTS + TP.loc[H, G] = SAM.loc[H, G].div(HH0.loc[H], axis='index').fillna(0.0) + + # FACTOR RENTALS + JOBCOR.loc[H, L] = JOBCR.loc[H, L] + + # RENTAL RATE FOR FACTORS + R0.loc[F, Z] = 1.0 + + R0.loc[F, IG] = (SAM.loc[F, IG] / EMPLOY.loc[IG, F].T).fillna(1.0) + + # REAL FACTOR DEMAND + FD0.loc[F, IG] = EMPLOY.loc[IG, F].T + + KS0.loc[K, IG] = FD0.loc[K, IG] + + # SHARES FOUND IN THE SOCIAL ACCOUNTING MATRIX DATA + # A = INPUT OUTPUT COEFICIENTS + A.loc[Z, Z] = SAM.loc[Z, Z].div(Q0.loc[Z], axis='columns') + + # SS PAYMENTS FROM IN-COMMUTERS + # A(GFUSC, LCOM) = TAUFL(GFUSC, LCOM); + + # AGFS: LABOR PAYMENTS BY G SECTOR + USSOC PAYMENTS BY LABOR (GROSS LABOR PAYMENTS) + AGFS.loc['L1A', G] = SAM.loc['L1A', G] + SAM.loc['USSOCL1A', G] + AGFS.loc['L2A', G] = SAM.loc['L2A', G] + SAM.loc['USSOCL2A', G] + AGFS.loc['L3A', G] = SAM.loc['L3A', G] + SAM.loc['USSOCL3A', G] + + AGFS.loc['L1B', G] = SAM.loc['L1B', G] + SAM.loc['USSOCL1B', G] + AGFS.loc['L2B', G] = SAM.loc['L2B', G] + SAM.loc['USSOCL2B', G] + AGFS.loc['L3B', G] = SAM.loc['L3B', G] + SAM.loc['USSOCL3B', G] + + AGFS.loc['L1C', G] = SAM.loc['L1C', G] + SAM.loc['USSOCL1C', G] + AGFS.loc['L2C', G] = SAM.loc['L2C', G] + SAM.loc['USSOCL2C', G] + AGFS.loc['L3C', G] = SAM.loc['L3C', G] + SAM.loc['USSOCL3C', G] + + AGFS.loc['L1D', G] = SAM.loc['L1D', G] + SAM.loc['USSOCL1D', G] + AGFS.loc['L2D', G] = SAM.loc['L2D', G] + SAM.loc['USSOCL2D', G] + AGFS.loc['L3D', G] = SAM.loc['L3D', G] + SAM.loc['USSOCL3D', G] + + AGFS.loc['L1E', G] = SAM.loc['L1E', G] + SAM.loc['USSOCL1E', G] + AGFS.loc['L2E', G] = SAM.loc['L2E', G] + SAM.loc['USSOCL2E', G] + AGFS.loc['L3E', G] = SAM.loc['L3E', G] + SAM.loc['USSOCL3E', G] + + AGFS.loc['L1F', G] = SAM.loc['L1F', G] + SAM.loc['USSOCL1F', G] + AGFS.loc['L2F', G] = SAM.loc['L2F', G] + SAM.loc['USSOCL2F', G] + AGFS.loc['L3F', G] = SAM.loc['L3F', G] + SAM.loc['USSOCL3F', G] + + AGFS.loc['L1G', G] = SAM.loc['L1G', G] + SAM.loc['USSOCL1G', G] + AGFS.loc['L2G', G] = SAM.loc['L2G', G] + SAM.loc['USSOCL2G', G] + AGFS.loc['L3G', G] = SAM.loc['L3G', G] + SAM.loc['USSOCL3G', G] + + AGFS.loc['L1H', G] = SAM.loc['L1H', G] + SAM.loc['USSOCL1H', G] + AGFS.loc['L2H', G] = SAM.loc['L2H', G] + SAM.loc['USSOCL2H', G] + AGFS.loc['L3H', G] = SAM.loc['L3H', G] + SAM.loc['USSOCL3H', G] + + # AG - GOVERNMENT SPENDING SHARES OF NET INCOME + AG_1 = SAM.loc[I, G] + AG_2 = SAM.loc[I, G].sum(0) + SAM.loc[F, G].sum(0) + SAM.loc[GF, G].sum(0) + AG.loc[I, G] = AG_1 / AG_2 + + AG_1 = SAM.loc[F, G] + AG.loc[F, G] = AG_1 / AG_2 + + AG_1 = AGFS.loc[L, G] + AG.loc[L, G] = AG_1 / AG_2 + AG = AG.fillna(0.0) + + # TRADE INTERMEDIATES CONSUMPTION INVESTMENT INITIAL LEVELS + + # REAL EXPORT CONSUMPTION + CX0.loc[I] = SAM.loc[I, ["ROW"]].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index').sum(1) + + # REAL IMPORTS + M01.loc[I] = SAM.loc[["ROW"], I].sum(0) / PWM0[I].T + + M0.loc[IP] = SAM.loc[IP, Z].sum(1) - (B1.loc[I, IP].sum(0) + SAM.loc[F, IP].sum(0) + SAM.loc[G, IP].sum(0)) + + M0.loc[I] = (M0[I] / PWM0[I]) + M0 = M0.fillna(0.0) + + # * REAL INTERMEDIATE DEMAND + V0.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] / (1.0 + TAUQ.loc[GS, I].sum(0)) + V0T.loc[I] = SAM.loc[I, I].sum(1) / P0.loc[I] + + # REAL PRIVATE CONSUMPTION + CH0.loc[I, H] = SAM.loc[I, H].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') + + CH0T.loc[I, H] = SAM.loc[I, H].div(P0[I], axis='index') + + CG0.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index').div((1.0 + TAUQ.loc[GS, I].sum(0)), axis='index') + + CG0T.loc[I, GN] = SAM.loc[I, GN].div(P0.loc[I], axis='index') + + DEPR = float((SAM.loc[IG, ["INVES"]].sum(0)) / (KS0.loc[K, IG].sum(1).sum(0))) + + N0.loc[K, IG] = KS0.loc[K, IG] * DEPR + + # INVESTMENT BY SECTOR OF SOURCE + CN0.loc[I] = 0.0 + + B.loc[I, IG] = BB.loc[I, IG].fillna(0.0) + + CN0.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index').div( + 1.0 + TAUN.loc[GS, I].sum(0), axis='index').transpose() + + CN0T.loc[I] = B.loc[I, IG].mul(N0.loc[K, IG].sum(0), axis='columns').sum(1).div(P0.loc[I], axis='index') + + DD0.loc[I] = CH0.loc[I, H].sum(1) + CG0.loc[I, G].sum(1) + CN0.loc[I] + V0.loc[I] + + D0.loc[I] = 1.0 - M0.loc[I] / DD0.loc[I] + + # CORRECT IMPORT ELASTICITY TO DOMESTIC SHARE ELASTICITY + ETAD.loc[I] = -1.0 * ETAM.loc[I] * M0.loc[I] / (DD0.loc[I] * D0.loc[I]) + + # PRODUCTION DATA + DS0.loc[I] = DD0.loc[I] + CX0.loc[I] - M0.loc[I] + + AD.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') / DS0.loc[I] + + V10.loc[I, I] = SAM.loc[I, I].div(P0.loc[I], axis='index').div(1.0 + TAUQ.loc[GS, I].sum(0), axis='index') + + PVA0.loc[I] = PD0.loc[I] - ( + AD.loc[I, I].mul(P0.loc[I], axis='index').mul(1.0 + TAUQ.loc[GS, I].sum(0).T, axis='index').sum(0).T) + + # AVERAGE RENTAL RATES FOR FACTORS (NORMALIZED) + RA0.loc[F] = 1.0 + + # CALIBRATION OF PRODUCTION EXPONENTS FOR COBB DOUGLAS + # a = pd.Series(index=I, dtype=float).fillna(0.0) + # a = SAM.loc[GFUS, I].append(a, ignore_index=True).append(SAM.loc[GL, I]) # labor, capital + a = SAM.loc['MEMPROPTAX', I] + SAM.loc['OTHERPROPTAX', I] + a_new_row = pd.DataFrame([a]) + a = pd.concat([SAM.loc[GFUS, I], a_new_row]) + a.index = F + + ALPHA.loc[F, I] = (SAM.loc[F, I] + a.loc[F, I]) / (SAM.loc[F, I].sum(0) + SAM.loc[GF, I].sum(0)) + ALPHA.loc[F, I] = ALPHA.loc[F, I] / ALPHA.loc[F, I].sum(0) + + ACK = pd.Series(index=I, dtype=float).fillna(0.0) + ACK.loc[I] = SAM.loc[F, I].sum(0) + + if is_cd: + # replace takes care of multiplying by zeros, by changing zeros to ones. + DELTA.loc[I] = DS0.loc[I] / (FD0.loc[F, I] ** ALPHA.loc[F, I]).replace({0: 1}).product(0) + SIGMA.loc[I] = 0.67 + RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] + else: + # Cobb-Douglas Technology Parameter + # replace takes care of multiplying by zeros, by changing zeros to ones. + # CES Production Function + SIGMA.loc[I] = 0.67 + RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] + TESTA1.loc[F, I] = 0.0 + # TESTA1(F,I) = R0(F,I) * RA0(F)*(1 + SUM(GF,TAUFX(GF,F,I)))*((FD0(F,I))**(1-RHO(I))); + TESTA1.loc[F, I] = R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( + FD0.loc[F, I] ** (1 - RHO.loc[I])) + # TESTA2(F,I) = SUM(F1, R0(F1,I) * RA0(F1) * (1 + SUM(GF,TAUFX(GF,F1,I)))*((FD0(F1,I))**(1-RHO(I)))); + TESTA2_pre = (R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( + FD0.loc[F, I] ** (1 - RHO.loc[I]))).sum(0) + TESTA2.loc[F, I] = 1 + TESTA2.loc[F, I] = TESTA2.loc[F, I] * TESTA2_pre + TESTA3.loc[F, I] = TESTA1.loc[F, I] / TESTA2.loc[F, I] + ALPHA.loc[F, I] = TESTA3.loc[F, I] + # add THETA to make FDEQ work + THETA = ALPHA.where(ALPHA == 0, 1) + + ATEST1 = pd.Series(index=I, dtype=float).fillna(0.0) + ATEST1.loc[I] = ALPHA.loc[F, I].sum(0) + + GAMMA.loc[I] = DS0.loc[I] / (((ALPHA.loc[F, I] * FD0.loc[F, I] ** (RHO.loc[I])).sum(0)) ** (1 / RHO.loc[I])) + + # OTHER DATA + # HH INVESTMENT INCOME FROM ROW + PRIVRET.loc[H] = SAM.loc[Z, H].sum(0) - (SAM.loc[H, F].sum(1) + SAM.loc[H, CM].sum(1) + SAM.loc[H, GX].sum(1)) + + PRIVRET.loc[H] = PRIVRET.loc[H] / HH0.loc[H] + + # TOTAL OUTPUT + Y0.loc[F] = SAM.loc[F, IG].sum(1) + + KPFOR01.loc[K] = SAM.loc[K, ["ROW"]].sum(1) + + # NOMINAL CAPITAL OUTFLOW + KPFOR0[K] = SAM.loc[Z, K].sum(0).T - SAM.loc[K, IG].sum(1) + + # NOMINAL GOVERNMENT OUTFLOWS + GVFOR0.loc[G] = SAM.loc[G, ["ROW"]].sum(1) + ''' + GVFOR0.loc[GT] = SAM.loc[Z, GT].sum(0) - ( + SAM.loc[GT, I].sum(1) + + SAM.loc[GT, F].sum(1) + + SAM.loc[GT, H].sum(1) + + SAM.loc[GT, G].sum(1) + ) + ''' + + # ORIGINAL EQUATION + A.loc[H, L] = SAM.loc[H, L].div(HW0.loc[H], axis='index') / ( + Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) + SAM.loc[L, ["ROW"]].sum(1)) + + A.loc[H, K] = SAM.loc[H, K].div(HW0.loc[H], axis='index') / ( + Y0.loc[K] + SAM.loc[Z, K].sum(0) - SAM.loc[K, IG].sum(1)) + + # HH TAXES OTHER THAN PIT + TAUH.loc[GH, H] = SAM.loc[GH, H].div(HH0.loc[H], axis='columns') + + S0.loc[H] = SAM.loc[["INVES"], H].T.sum(1) + + YD0.loc[H] = SAM.loc[I, H].sum(0).T + S0.loc[H] + + Y0.loc[G] = SAM.loc[G, Z].sum(1) - SAM.loc[G, ["ROW"]].sum(1) + + S0.loc[G] = SAM.loc[["INVES"], G].sum(0) + + # COMMUTING IN + CMI0.loc[L] = FD0.loc[L, IG].sum(1) - JOBCOR.loc[H, L].mul(HW0.loc[H], axis='index').sum(0) + + # COMMUTING OUT + CMO0.loc[["OUTCOM1"]] = 46206.0 + CMO0.loc[["OUTCOM2"]] = 24294.0 + CMO0.loc[["OUTCOM3"]] = 13514.0 + + # AVERAGE WAGE FLOWING INTO SHELBY + CMOWAGE.loc[CM] = SAM.loc[CM, ["ROW"]].sum(1).div(CMO0.loc[CM], axis='index').fillna(0.0) + + # AVERAGE WAGES FLOWING OUT OF SHELBY + CMIWAGE.loc[L] = (-1) * (SAM.loc[L, ["ROW"]].sum(1).div(CMI0.loc[L], axis='index').fillna(0.0)) + + # PROPORTION OF CAPITAL INCOME OUTFLOW + KFOR.loc[K] = KPFOR0.loc[K] / SAM.loc[["KAP"], IG].sum(1) + + # PROPORTION OF GOVERNMENT INCOME OUTFLOW + GFOR.loc[G] = GVFOR0.loc[G] / Y0.loc[G] + + A.loc[H, CM] = SAM.loc[H, CM].div(SAM.loc[Z, CM].sum(0), axis='columns') + + # NOMINAL NET CAPITAL INFLOW + NKI0 = (M0.loc[I] * PWM0.loc[I]).sum(0) - (CX0.loc[I] * PD0.loc[I]).sum(0) - \ + (PRIVRET.loc[H] * HH0.loc[H]).sum(0) - \ + KPFOR0.loc[K].sum(0) - GVFOR0.loc[G].sum(0) - \ + (CMOWAGE.loc[CM] * CMO0.loc[CM]).sum(0) - \ + (CMIWAGE.loc[L] * CMI0.loc[L]).sum(0) + + # REAL HH NET INCOME + Y0.loc[H] = (A.loc[H, L].mul(HW0[H], axis='index').div(A.loc[H, L].mul(HW0[H], axis='index').sum(0), axis='columns') \ + .mul(Y0.loc[L] * (1.0 - TAUFL.loc[G, L].sum(0)) - (CMIWAGE.loc[L] * CMI0.loc[L]), axis='columns')).sum(1) \ + + (A.loc[H, CM].mul((CMOWAGE.loc[CM] * CMO0.loc[CM]), axis='columns')).sum(1) \ + + (A.loc[H, K].mul(HW0[H], axis='index') / A.loc[H, K].mul(HW0[H], axis='index').sum(0) \ + * (Y0[K] * (1.0 - TAUFK.loc[G, K].sum(0)) + KPFOR0.loc[K])).sum(1) + + # PERSONAL INCOME OBJECTIVE FUNCTION + SPI0 = (Y0.loc[H].sum(0) + + TP.loc[H, G].mul(HH0.loc[H], axis='index').sum(1).sum(0) + + (PRIVRET[H] * HH0[H]).sum(0)) + + # PERSONAL INCOME TAX + PIT.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') + + PIT0.loc[GI, H] = SAM.loc[GI, H].div(Y0[H], axis='columns') + + MI0.loc[H] = HH0.loc[H] * 0.04 + + MO0.loc[H] = HH0.loc[H] * 0.04 + + GCP0 = CH0.loc[I, H].sum(1).sum(0) + CN0.loc[I].sum(0) + CG0.loc[I, GN].sum(1).sum(0) + CX0.loc[I].sum(0) - M0.loc[ + I].sum(0) + + GCP10.loc[I] = CH0.loc[I, H].sum(1) + CN0.loc[I] + CG0.loc[I, GN].sum(1) + CX0.loc[I] + M0.loc[I] + + ########################################### + # VARIABLE DECLARATION + ########################################### + + vars = VarContainer() + + # PUBLIC CONSUMPTION + CG = vars.add('CG', rows=I, cols=G) + + # PRIVATE CONSUMPTION + CH = vars.add('CH', rows=I, cols=H) + + # COMMUTING IN + CMI = vars.add('CMI', rows=L) + + # COMMUTING OUT JASPER + CMO = vars.add('CMO', rows=CM) + + # GROSS INVESTMENT BY SECTOR OF SOURCE + CN = vars.add('CN', rows=I) + + # CONSUMER PRICE INDEX + CPI = vars.add('CPI', rows=H) + + # NONHOUSING CONSUMER PRICE INDEX + CPIN = vars.add('CPIN', rows=H) + + # HOUSING CONSUMER PRICE INDEX + CPIH = vars.add('CPIH', rows=H) + + # EXPORT DEMAND + CX = vars.add('CX', rows=I) + + # DOMESTIC SHARE OF DOMESTIC DEMAND + D = vars.add('D', rows=I) + + # DOMESTIC DEMAND + DD = vars.add('DD', rows=I) + + # DOMESTIC SUPPLY + DS = vars.add('DS', rows=I) + + # SECTORAL FACTOR DEMAND + # FD = vars.add('FD', rows=F, cols=Z) + FD = vars.add('FD', rows=F, cols=Z) + + # GROSS AGGREGATE CITY PRODUCT + GCP = vars.add('GCP') + + # GROSS CITY PRODUCT BY SECTOR + GCP1 = vars.add('GCP1', rows=I) + + # NUMBER OF HOUSEHOLDS + HH = vars.add('HH', rows=H) + + # NUMBER OF NONWORKING HOUSEHOLDS + HN = vars.add('HN', rows=H) + + # NUMBER OF WORKING HOUSEHOLDS + HW = vars.add('HW', rows=H) + + # INTER GOVERNMENTAL TRANSFERS + IGT = vars.add('IGT', rows=G, cols=GX) + + # CAPITAL FLOW + KS = vars.add('KS', rows=K, cols=IG) + + # IMPORTS + M = vars.add('M', rows=I) + + # GROSS INVESTMENT BY SECTOR OF DESTINATION + N = vars.add('N', rows=K, cols=IG) + + # NET CAPITAL INFLOW + NKI = vars.add('NKI') + + # CAPITAL OUTFLOW + KPFOR = vars.add('KPFOR', rows=K) + + # GOVT OUTFLOW + GVFOR = vars.add('GVFOR', rows=G) + + # AGGREGATE DOMESTIC PRICE PAID BY PURCHASERS + P = vars.add('P', rows=I) + + # DOMESTIC PRICE RECEIVED BY SUPPLIERS + PD = vars.add('PD', rows=I) + + # VALUE ADDED PRICE + PVA = vars.add('PVA', rows=I) + + # ECONOMY WIDE SCALAR RENTAL RATES OF FACTORS + RA = vars.add('RA', rows=F) + + # SECTORAL RENTAL RATES + R = vars.add('R', rows=F, cols=Z) + + # SAVINGS + S = vars.add('S', rows=Z) + + # PERSONAL INCOME (OBJECTIVE FUNCTION) + SPI = vars.add('SPI') + + # INTERMEDIATE GOODS + V = vars.add('V', rows=I) + + # additional variable + V1 = vars.add('V1', rows=I, cols=I) + + # GROSS INCOMES + Y = vars.add('Y', rows=Z) + + # additional variables + # Y1 = vars.add('Y1', rows=H) + # Y2 = vars.add('Y2', rows=H) + # Y3 = vars.add('Y3', rows=H) + + # AFTER TAX TOTAL HOUSEHOLD INCOMES + YD = vars.add('YD', rows=H) + + # GOV INCOME + # YT = vars.add('YT', rows=G, cols=G) + + ########################################### + # INITIALIZE VARIABLES FOR SOLVER + ########################################### + + vars.init('CG', CG0.loc[I, G]) + vars.init('CH', CH0.loc[I, H]) + vars.init('CMI', CMI0.loc[L]) + vars.init('CMO', CMO0.loc[CM]) + vars.init('CN', CN0.loc[I]) + vars.init('CPI', CPI0.loc[H]) + vars.init('CPIN', CPIN0.loc[H]) + vars.init('CPIH', CPIH0.loc[H]) + vars.init('CX', CX0.loc[I]) + vars.init('D', D0.loc[I]) + vars.init('DD', DD0.loc[I]) + vars.init('DS', DS0.loc[I]) + vars.init('FD', FD0.loc[F, Z]) + vars.init('GCP', GCP0) + vars.init('GCP1', GCP10.loc[I]) + vars.init('HH', HH0.loc[H]) + vars.init('HN', HN0.loc[H]) + vars.init('HW', HW0.loc[H]) + vars.init('IGT', IGT0.loc[G, GX]) + vars.init('KS', KS0.loc[K, IG]) + # vars.init('LAS', LAS0.loc[LA, IG]) + vars.init('M', M0.loc[I]) + vars.init('N', N0.loc[K, IG]) + vars.init('NKI', NKI0) + # vars.init('LNFOR', LNFOR0.loc[LA]) + vars.init('KPFOR', KPFOR0.loc[K]) + vars.init('GVFOR', GVFOR0.loc[G]) + vars.init('P', P0.loc[I]) + vars.init('PD', PD0.loc[I]) + vars.init('PVA', PVA0.loc[I]) + vars.init('RA', RA0.loc[F]) + vars.init('R', R0.loc[F, Z]) + vars.init('S', S0.loc[Z]) + vars.init('SPI', SPI0) + vars.init('V', V0.loc[I]) + vars.init('V1', V10.loc[I, I]) + vars.init('Y', Y0.loc[Z]) + # vars.init('Y1') + # vars.init('Y2') + # vars.init('Y3') + vars.init('YD', YD0.loc[H]) + # vars.init('YT') + + + # ------------------------------------------------------------------------------------------------------------- + # DEFINE BOUNDS FOR VARIABLES + # ------------------------------------------------------------------------------------------------------------- + + vars.lo('P', vars.get('P') / 1000); + vars.up('P', vars.get('P') * 1000) + vars.lo('PD', vars.get('PD') / 1000); + vars.up('PD', vars.get('PD') * 1000) + vars.lo('PVA', vars.get('PVA') / 1000); + vars.up('PVA', vars.get('PVA') * 1000) + vars.lo('RA', vars.get('RA') / 1000); + vars.up('RA', vars.get('RA') * 1000) + vars.lo('CPI', vars.get('CPI') / 1000); + vars.up('CPI', vars.get('CPI') * 1000) + vars.lo('CMI', vars.get('CMI') / 1000); + vars.up('CMI', vars.get('CMI') * 1000) + vars.lo('CMO', vars.get('CMO') / 1000); + vars.up('CMO', vars.get('CMO') * 1000) + vars.lo('DS', vars.get('DS') / 1000); + vars.up('DS', vars.get('DS') * 1000) + vars.lo('DD', vars.get('DD') / 1000); + vars.up('DD', vars.get('DD') * 1000) + vars.lo('D', vars.get('D') / 1000); + vars.up('D', vars.get('D') * 1000) + vars.lo('V', vars.get('V') / 1000); + vars.up('V', vars.get('V') * 1000) + vars.lo('FD', vars.get('FD') / 1000); + vars.up('FD', vars.get('FD') * 1000) + vars.lo('HH', vars.get('HH') / 1000); + vars.up('HH', vars.get('HH') * 1000) + vars.lo('HW', vars.get('HW') / 1000); + vars.up('HW', vars.get('HW') * 1000) + vars.lo('HN', vars.get('HN') / 1000); + vars.up('HN', vars.get('HN') * 1000) + vars.lo('KS', vars.get('KS') / 1000); + vars.up('KS', vars.get('KS') * 1000) + # vars.lo('LAS',vars.get('LAS')/1000); vars.up('LAS',vars.get('LAS')*1000) + vars.lo('M', vars.get('M') / 1000); + vars.up('M', vars.get('M') * 1000) + vars.lo('Y', vars.get('Y') / 1000); + vars.up('Y', vars.get('Y') * 1000) + vars.lo('YD', vars.get('YD') / 1000); + vars.up('YD', vars.get('YD') * 1000) + vars.lo('CH', vars.get('CH') / 1000); + vars.up('CH', vars.get('CH') * 1000) + vars.lo('CG', vars.get('CG') / 1000); + vars.up('CG', vars.get('CG') * 1000) + vars.lo('CX', vars.get('CX') / 1000); + vars.up('CX', vars.get('CX') * 1000) + vars.lo('R', vars.get('R') / 1000); + vars.up('R', vars.get('R') * 1000) + vars.lo('N', 0); + vars.lo('CN', 0); + + + def set_variable(filename): + # clear the file before write the variables + with open(filename, 'w') as f: + f.write("") + + vars.write(filename) + + # ------------------------------------------------------------------------------------------------------------- + # DEFINE EQUATIONS AND SET CONDITIONS + # ------------------------------------------------------------------------------------------------------------- + def set_equation(filename): + count = [0] + + # CPIEQ(H).. + # CPI(H)=E= + # SUM(I, P(I) * ( 1 + SUM(GS, TAUC(GS,I) ) ) * CH(I,H) ) + # / SUM(I, P0(I) * ( 1 + SUM(GS, TAUQ(GS,I) ) ) * CH(I,H) ); + print('CPIEQ(H)') + line1 = (P.loc(I) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0)) * CH.loc(I, H)).sum(I) + line2 = (ExprM(vars, m=P0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0))) * CH.loc(I, H)).sum(I) + + CPIEQ = (line1 / line2 - ~CPI.loc(H)) + if test_values: + CPIEQ.test(vars.initialVals) + CPIEQ.write(count, filename) + + # YEQ(H).. + # YEQ(H).. Y(H) =E= SUM(L, A(H,L) * HW(H) / SUM(H1, A(H1,L) * HW(H1) ) * (Y(L) * ( 1 - SUM(G, TAUFL(G,L))) - RA(L)*CMIWAGE(L)*CMI(L))) + # + SUM(CM, A(H,CM)*(CMOWAGE(CM)*CMO(CM))) + # + SUM(K, A(H,K) * HW(H) / SUM(H1, A(H1,K) * HW(H1)) + # * (Y(K) + KPFOR(K)) * ( 1 - SUM(G, TAUFK(G,K) ) ) ); + + print('YEQ(H)') + line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * ( + Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * ExprM(vars, + m=CMIWAGE.loc[L]) * CMI.loc( + L))).sum(L) + line2 = (ExprM(vars, m=A.loc[H, CM]) * (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM))).sum(CM) + # line3 = (ExprM(vars, m= A.loc[H,LA]) * HW.loc(H) / (ExprM(vars, m= A.loc[H1,LA]) * HW.loc(H1)).sum(H1) * (Y.loc(LA) + LNFOR.loc(LA) ) * ExprM(vars, m= 1 - TAUFLA.loc[G,LA].sum(0))).sum(LA) + line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * ( + Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) + + YEQ = ((line1 + line2 + line4) - Y.loc(H)) + if test_values: + YEQ.test(vars.initialVals) + YEQ.write(count, filename) + # print(YEQ) + + # YDEQ(H).. YD(H) =E= Y(H) + (PRIVRET(H) * HH(H)) + # + SUM(G, TP(H,G) * HH(H)) + # - SUM(GI, PIT0(GI,H) * Y(H)) + # - SUM(G, TAUH(G,H) * HH(H)); + print('YDEQ(H)') + line1 = Y.loc(H) + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)) + line2 = (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum(G) + line3 = ~(ExprM(vars, m=PIT0.loc[GI, H]) * Y.loc(H)).sum(GI) + line4 = ~(ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum(G) + + YDEQ = ((line1 + line2 - line3 - line4) - YD.loc(H)) + YDEQ.write(count, filename) + if test_values: + YDEQ.test(vars.initialVals) + # print(YDEQ) + + # CHEQ(I,H).. CH(I,H) =E= CH0(I,H)* ((YD(H) / YD0(H)) / ( CPI(H) / CPI0(H)))**(BETA(I,H)) + # * PROD(J, ((P(J)*( 1 + SUM(GS, TAUC(GS,J))))/ (P0(J)*(1 + SUM(GS, TAUQ(GS,J)))))** (LAMBDA(J,I))); + print('CHEQ(I,H)') + line1 = ExprM(vars, m=CH0.loc[I, H]) * ( + (YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m= + BETA.loc[I, H]) + line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / ( + ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** ExprM(vars, m=LAMBDA.loc[ + J, I])).prod(0) + + CHEQ = ((line1 * line2) - CH.loc(I, H)) + CHEQ.write(count, filename) + if test_values: + CHEQ.test(vars.initialVals) + # print(CHEQ) + + # SHEQ(H).. S(H) =E= YD(H) - SUM(I, P(I) * CH(I,H) * ( 1 + SUM(GS, TAUC(GS,I)))); + print('SHEQ(H)') + line = YD.loc(H) - ~((P.loc(I) * CH.loc(I, H) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0))).sum(I)) + + SHEQ = (line - S.loc(H)) + SHEQ.write(count, filename) + if test_values: + SHEQ.test(vars.initialVals) + # print(SHEQ) + + # PVAEQ(I).. PVA(I) =E= PD(I) - SUM(J, AD(J,I) * P(J) * (1 + SUM(GS, TAUQ(GS, J)))); + print('PVAEQ(I)') + line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) + + PVAEQ = (line - PVA.loc(I)) + PVAEQ.write(count, filename) + if test_values: + PVAEQ.test(vars.initialVals) + # print(PVAEQ) + + # PFEQ(I)..DS(I) =E= DELTA(I)*PROD(F$ALPHA(F,I),(TT(F,I)*FD(F,I))**ALPHA(F,I)); + if is_cd: + print('PFEQ(I)') + line = ExprM(vars, m=DELTA.loc[I]) * ( + (ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) ** ExprM(vars, m=ALPHA.loc[F, I])).prod(F) + + PFEQ = (line - DS.loc(I)) + PFEQ.write(count, filename) + if test_values: + PFEQ.test(vars.initialVals) + # print(PFEQ) + else: + # CES + # PFEQ(I)..DS(I) =E= GAMMA(I)*(SUM(F, ALPHA(F,I)*(FD(F,I)**(RHO(I)))))**(1/RHO(I)); + print('PFEQ(I)') + line = ExprM(vars, m=GAMMA.loc[I]) * \ + ((ExprM(vars, m=ALPHA.loc[F, I]) * (FD.loc(F, I) ** ExprM(vars, m=RHO.loc[I]))).sum(F)) \ + ** ExprM(vars, m=1 / RHO.loc[I]) + PFEQ = (line - DS.loc(I)) + PFEQ.write(count, filename) + if test_values: + PFEQ.test(vars.initialVals) + # print(PFEQ) + if is_cd: + # FDEQ(F,I).. R(F,I) * RA(F) * (1 + SUM(GF,TAUFX(GF,F,I) ) )* (TT(F,I)* FD(F,I)) + # =E= PVA(I) * DS(I) * ALPHA(F,I); + print('FDEQ(F,I)') + left = R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I]) * ( + ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) + right = ~(PVA.loc(I) * DS.loc(I) * ExprM(vars, m=ALPHA.loc[F, I])) + + FDEQ = (right - left) + + # FDEQ.test(vars.initialVals) + FDEQ.write(count, filename) + if test_values: + FDEQ.test(vars.initialVals) + # print(FDEQ) + else: + # FD of CES + # FDEQ(F,I).. (R(F,I) * RA(F)*(1 + SUM(GF,TAUFX(GF,F,I))))* (FD(F,I)**(1-RHO(I))) + # =E= PVA(I)* ALPHA(F,I)*(GAMMA(I)**RHO(I))*(DS(I)**(1-RHO(I))); + print('FDEQ(F,I)') + left = (R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I])) * ( + FD.loc(F, I) ** ExprM(vars, m=1 - RHO.loc[I])) + right = ~(PVA.loc(I) * (ExprM(vars, m=ALPHA.loc[F, I] * (GAMMA.loc[I] ** RHO.loc[I])) * ( + DS.loc(I) ** ExprM(vars, m=1 - RHO.loc[I])))) + FDEQ = (right - left) + FDEQ.setCondition(FD0.loc[F, I], 'INEQ', 0) + + # FDEQ.test(vars.initialVals) + FDEQ.write(count, filename) + if test_values: + FDEQ.test(vars.initialVals) + # print(FDEQ) + + # VEQ(I).. V(I) =E= SUM(J, AD(I,J) * DS(J) ); + + print('VEQ(I)') + line = (ExprM(vars, m=AD.loc[I, J]) * ~DS.loc(J)).sum(1) + + VEQ = (line - V.loc(I)) + VEQ.write(count, filename) + if test_values: + VEQ.test(vars.initialVals) + # print(VEQ) + + # YFEQL(F).. Y(F) =E= SUM(IG, R(F,IG) * RA(F)*FD(F,IG)); + print('YFEQL(L)') + line = (R.loc(F, IG) * RA.loc(F) * FD.loc(F, IG)).sum(IG) + + YFEQL = (line - Y.loc(F)) + YFEQL.write(count, filename) + if test_values: + YFEQL.test(vars.initialVals) + # print(YFEQL) + + # KAPFOR(K).. KPFOR(K) =E= KFOR(K) * Y(K); + print('KAPFOR(K)') + line = ExprM(vars, m=KFOR.loc[K]) * Y.loc(K) + + KAPFOR = (line - KPFOR.loc(K)) + KAPFOR.write(count, filename) + if test_values: + KAPFOR.test(vars.initialVals) + # print(KAPFOR) + + # XEQ(I).. CX(I) =E= CX0(I)*( (PD(I)*(1+SUM(GS,TAUX(GS,I)))) + # /(PW0(I)*(1+SUM(GS,TAUQ(GS,I))))) **(ETAE(I)); + print('XEQ(I)') + line = ExprM(vars, m=CX0.loc[I]) * \ + ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / ExprM(vars, m=PW0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0)))) \ + ** ExprM(vars, m=ETAE.loc[I]) + + XEQ = (line - CX.loc(I)) + XEQ.write(count, filename) + if test_values: + XEQ.test(vars.initialVals) + # print(XEQ) + + # DEQ(I)$PWM0(I).. D(I) =E= D0(I) *(PD(I)/PWM0(I))**(ETAD(I)); + print('DEQ(I)$PWM0(I)') + line = ExprM(vars, m=D0.loc[I]) * (PD.loc(I) / ExprM(vars, m=PWM0.loc[I])) ** ExprM(vars, m=ETAD.loc[I]) + + DEQ = (line - D.loc(I)) + # DEQ.setCondition(PWM0.loc[I]) + DEQ.write(count, filename) + if test_values: + DEQ.test(vars.initialVals) + # print(DEQ) + + # MEQ(I).. M(I) =E= ( 1 - D(I) ) * DD(I); + print('MEQ(I)') + line = (1 - D.loc(I)) * DD.loc(I) + + MEQ = (line - M.loc(I)) + MEQ.write(count, filename) + if test_values: + MEQ.test(vars.initialVals) + # print(MEQ) + + # PEQ(I).. P(I) =E= D(I) * PD(I) + ( 1 - D(I) ) * PWM0(I); + print('PEQ(I)') + line = (D.loc(I) * PD.loc(I) + (1 - D.loc(I)) * ExprM(vars, m=PWM0.loc[I])) + + PEQ = (line - P.loc(I)) + PEQ.write(count, filename) + if test_values: + PEQ.test(vars.initialVals) + # print(PEQ) + + # NKIEQ.. NKI =E= SUM(I, M(I) * PWM0(I) ) + # - SUM(I, CX(I) * PD(I) ) + # - SUM(H, PRIVRET(H)*HH(H)) + # - SUM(K, KPFOR(K)) + # - SUM(G, GVFOR(G)) + # - SUM(CM,CMOWAGE(CM)*CMO(CM)) + # - SUM(L,CMIWAGE(L)*CMI(L)); + + print('NKIEQ') + line1 = (M.loc(I) * ExprM(vars, m=PWM0.loc[I])).sum(I) + line2 = (CX.loc(I) * PD.loc(I)).sum(I) + line3 = (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + line5 = KPFOR.loc(K).sum(K) + line6 = GVFOR.loc(G).sum(G) + line7 = (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM)).sum(CM) + line8 = (ExprM(vars, m=CMIWAGE.loc[L]) * CMI.loc(L)).sum(L) + + NKIEQ = ((line1 - line2 - line3 - line5 - line6 - line7 - line8) - NKI) + NKIEQ.write(count, filename) + if test_values: + NKIEQ.test(vars.initialVals) + # print(NKIEQ) + + # NEQ(K,I).. N(K,I) =E= N0(K,I)*(R(K,I)/R0(K,I))**(ETAIX(K,I)); + print('NEQ(K,I)') + line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** ExprM(vars, m=ETAIX.loc[K, I]) + + NEQ = (line - N.loc(K, I)) + NEQ.write(count, filename) + if test_values: + NEQ.test(vars.initialVals) + # print(NEQ) + + # CNEQ(I).. P(I)*(1 + SUM(GS, TAUN(GS,I)))*CN(I) + # =E= SUM(IG, B(I,IG)*(SUM(K, N(K,IG)))); + print('CNEQ(I)') + left = P.loc(I) * ExprM(vars, m=1 + TAUN.loc[GS, I].sum(0)) * CN.loc(I) + right = (ExprM(vars, m=B.loc[I, IG]) * N.loc(K, IG).sum(K)).sum(IG) + + CNEQ = (right - left) + CNEQ.write(count, filename) + if test_values: + CNEQ.test(vars.initialVals) + # print(CNEQ) + + # KSEQ(K,IG).. KS(K,IG) =E= KS0(K,IG) * ( 1 - DEPR) + N(K,IG) ; + print('KSEQ(K,IG)') + line = ExprM(vars, m=KS0.loc[K, IG] * (1 - DEPR)) + N.loc(K, IG) + + KSEQ = (line - KS.loc(K, IG)) + KSEQ.write(count, filename) + if test_values: + KSEQ.test(vars.initialVals) + # print(KSEQ) + + # LSEQ1(H).. HW(H)/HH(H) =E= (HW0(H)/HH0(H)) + # *((SUM(L, RA(L) / RA0(L))/24)/ (CPI(H) / CPI0(H))*(SUM((Z,L), FD(L,Z))/(SUM(H1, HW(H1)* SUM(L, JOBCOR(H1,L)))+ SUM(CM, CMO(CM)) + SUM(L,CMI(L))))+ SUM((CM,L), EXWGEO(CM)/RA0(L))/72 *(SUM(CM, CMO(CM))/(SUM(H1, HW(H1)* SUM(L,JOBCOR(H1,L)))+ SUM(CM, CMO(CM)) +SUM(L,CMI(L)))))** (ETARA(H)) + # * ( SUM(G, TP(H,G) / CPI(H) )/ SUM(G, TP(H,G) / CPI0(H) )) ** ETAPT(H) + # * ((SUM(GI, PIT0(GI,H)* HH0(H))+ SUM(G, TAUH(G,H)*HH0(H)))/(SUM(GI, PIT(GI,H)* HH(H))+ SUM(G, TAUH(G,H)*HH(H))))**(ETAPIT(H)); + print('LSEQ1(H)') + line1 = ExprM(vars, m=HW0.loc[H] / HH0.loc[H]) + LSEQ1line2pre = FD.loc(L, Z).sum(1) + line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) \ + * (LSEQ1line2pre.sum(0) / ( + (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum(CM) + CMI.loc( + L).sum(L))) \ + + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) \ + * (CMO.loc(CM).sum(CM) / ( + (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum( + CM) + CMI.loc(L).sum(L))))) \ + ** ExprM(vars, m=ETARA.loc[H]) + line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / ( + ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) + line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + ( + ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) \ + / ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum( + G))) ** ExprM(vars, m=ETAPIT.loc[H]) + + LSEQ1 = ((line1 * line2 * line3 * line4) - HW.loc(H) / HH.loc(H)) + LSEQ1.write(count, filename) + if test_values: + LSEQ1.test(vars.initialVals) + # print(LSEQ1) + + # LSEQ2A('OUTCOM1').. CMO('OUTCOM1')=E= CMO0('OUTCOM1')* (Sum((F11,IG), FD(F11,IG))/sum((F11,IG), FD0(F11,IG)))**(-ECOMO('OUTCOM1')) ; + print('LSEQ2A') + line = ExprM(vars, m=CMO0.loc[CM1]) * ( + FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM1])) + + LSEQ2A = (line - CMO.loc(CM1)) + LSEQ2A.write(count, filename) + if test_values: + LSEQ2A.test(vars.initialVals) + # print(LSEQ2A) + + # LSEQ2B('OUTCOM2').. CMO('OUTCOM2')=E= CMO0('OUTCOM2')* (Sum((F21,IG), FD(F21,IG))/sum((F21,IG), FD0(F21,IG)))**(-ECOMO('OUTCOM2')); + print('LSEQ2B') + line = ExprM(vars, m=CMO0.loc[CM2]) * ( + FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM2])) + + LSEQ2B = (line - CMO.loc(CM2)) + LSEQ2B.write(count, filename) + if test_values: + LSEQ2B.test(vars.initialVals) + # print(LSEQ2B) + + # LSEQ2C('OUTCOM3').. CMO('OUTCOM3')=E= CMO0('OUTCOM3')* (sum((F31,IG), FD(F31,IG))/sum((F31,IG), FD0(F31,IG)))** (-ECOMO('OUTCOM3')); + print('LSEQ2C') + line = ExprM(vars, m=CMO0.loc[CM3]) * ( + FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** ( + ExprM(vars, m=(-1) * ECOMO.loc[CM3])) + + LSEQ2C = (line - CMO.loc(CM3)) + LSEQ2C.write(count, filename) + if test_values: + LSEQ2C.test(vars.initialVals) + # print(LSEQ2C) + + # LSEQ3(L).. CMI(L) =E= CMI0(L)* (Sum(FG, FD(L,FG))/Sum(FG, FD0(L,FG)))**(ECOMI(L)); + print('LSEQ3') + line = ExprM(vars, m=CMI0.loc[L]) * ( + (FD.loc(L, FG).sum(FG) / ExprM(vars, m=FD0.loc[L, FG].sum(1))) ** (ExprM(vars, m=ECOMI.loc[L]))) + + LSEQ3 = (line - CMI.loc(L)) + LSEQ3.write(count, filename) + if test_values: + LSEQ3.test(vars.initialVals) + # print(LSEQ3) + + # POPEQ(H).. HH(H) =E= HH0(H) * NRPG(H) + # + MI0(H) * ((YD(H)/HH(H))/(YD0(H)/HH0(H))/(CPI(H)/CPI0(H))) ** (ETAYD(H)) + # *((HN(H)/HH(H))/(HN0(H)/HH0(H))) ** (ETAU(H)) + # *(sum(HSD, CH(HSD,H))/sum(HSD,CH0(HSD,H)))**(1) + # - MO0(H) *((YD0(H)/HH0(H))/(YD(H)/HH(H))/(CPI0(H)/CPI(H))) ** (ETAYD(H)) + # *((HN0(H)/HH0(H))/(HN(H)/HH(H))) ** (ETAU(H)) + # *(sum(HSD, CH0(HSD,H))/sum(HSD,CH(HSD,H)))**(1) ; + + print('POPEQ(H)') + line1 = ExprM(vars, m=HH0.loc[H] * NRPG.loc[H]) + line2 = ExprM(vars, m=MI0.loc[H]) * ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / ( + CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) + line3 = ((HN.loc(H) / HH.loc(H)) / ExprM(vars, m=HN0.loc[H] / HH0.loc[H])) ** ExprM(vars, m=ETAU.loc[H]) + line4 = (CH.loc(HSD, H).sum(HSD) / ExprM(vars, m=CH0.loc[HSD, H].sum(0))) ** (1) + line5 = ExprM(vars, m=MO0.loc[H]) * (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / ( + ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) + line6 = (ExprM(vars, m=HN0.loc[H] / HH0.loc[H]) / (HN.loc(H) / HH.loc(H))) ** ExprM(vars, m=ETAU.loc[H]) + line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** (1) + + POPEQ = (line1 + line2 * line3 * line4 - line5 * line6 * line7 - HH.loc(H)) + POPEQ.write(count, filename) + if test_values: + POPEQ.test(vars.initialVals) + # print(POPEQ) + + # ANEQ(H).. HN(H) =E= HH(H) - HW(H); + print('ANEQ(H)') + line = HH.loc(H) - HW.loc(H) + + ANEQ = (line - HN.loc(H)) + ANEQ.write(count, filename) + if test_values: + ANEQ.test(vars.initialVals) + # print(ANEQ) + + # YGEQ(GX).. Y(GX) =E= SUM(I, TAUV(GX,I) * V(I) * P(I) ) + # + SUM(I, TAUX(GX,I)* CX(I) *PD(I)) + # + SUM((H,I), TAUC(GX,I) * CH(I,H) * P(I) ) + # + SUM(I, TAUN(GX,I) * CN(I) * P(I) ) + # + SUM((GN,I), TAUG(GX,I) * CG(I,GN) * P(I) ) + # + SUM((F,I), TAUFX(GX,F,I) * RA(F) * R(F,I) * TT(F,I)*FD(F,I) ) + # + SUM((F,GN), TAUFX(GX,F,GN) * RA(F) * R(F,GN) * FD(F,GN) ) + # + SUM(F, TAUFH(GX,F) * (Y(F))) + # + SUM(H, PIT0(GX,H) * Y(H) ) + # + SUM(H, TAUH(GX,H) * HH(H) ) + # + SUM(GX1, IGT(GX,GX1)); + print('YGEQ') + line1 = (ExprM(vars, m=TAUV.loc[GX, I]) * V.loc(I) * P.loc(I)).sum(I) + line2 = (ExprM(vars, m=TAUX.loc[GX, I]) * CX.loc(I) * PD.loc(I)).sum(I) + + YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) # first just set it to correct size + for label in GX: + for hlabel in H: + YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = Expr( + (ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) + + line3 = YGEQline3pre.sum(1) + line4 = (ExprM(vars, m=TAUN.loc[GX, I]) * CN.loc(I) * P.loc(I)).sum(I) + + YGEQline5pre = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) # first just set it to correct size + for label in GX: + YGEQline5pre.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) + line5 = YGEQline5pre + + line6 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) + for label in GX: + line6.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) + + line7 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) + for label in GX: + line7.m[GX.index(label)][0] = Expr( + (ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) + + line8 = (ExprM(vars, m=TAUFH.loc[GX, F]) * Y.loc(F)).sum(F) + line9 = (ExprM(vars, m=PIT0.loc[GX, H]) * Y.loc(H)).sum(H) + line10 = (ExprM(vars, m=TAUH.loc[GX, H]) * HH.loc(H)).sum(H) + line11 = IGT.loc(GX, GX1).sum(1) + + YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - Y.loc(GX)) + YGEQ.write(count, filename) + if test_values: + YGEQ.test(vars.initialVals) + # print(YGEQ) + + # YGEQ2(GT).. Y(GT) =E= SUM(GX, IGT(GT,GX)); + print('YGEQ2(GT)') + line = IGT.loc(GT, GX).sum(GX) + + YGEQ2 = (line - Y.loc(GT)) + YGEQ2.write(count, filename) + if test_values: + YGEQ2.test(vars.initialVals) + # print(YGEQ2) + + # YGEQM(GNLM).. Y(GNLM) =E= TAXS1(GNLM)*Y('CYGFM'); + print('YGEQM(GNLM)') + line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) + + YGEQM = (line - Y.loc(GNLM)) + YGEQM.write(count, filename) + if test_values: + YGEQM.test(vars.initialVals) + # print(YGEQM) + + # YGEQO(GNLO).. Y(GNLO) =E= TAXS2(GNLO)*Y('CYGFO'); + print('YGEQO(GNLO)') + line = ExprM(vars, m=TAXS2.loc[GNLO]) * Y.loc(['CYGFO']) + + YGEQO = (line - Y.loc(GNLO)) + YGEQO.write(count, filename) + if test_values: + YGEQO.test(vars.initialVals) + # print(YGEQ1) + + # GOVFOR(G).. GVFOR(G) =E= GFOR(G)*Y(G); + print('GOVFOR(G)') + line = ExprM(vars, m=GFOR.loc[G]) * Y.loc(G) + + GOVFOR = (line - GVFOR.loc(G)) + GOVFOR.write(count, filename) + if test_values: + GOVFOR.test(vars.initialVals) + # print(GOVFOR) + + # CGEQ(I,GN).. P(I)*(1 + SUM(GS, TAUG(GS,I))) * CG(I,GN) + # =E= AG(I,GN) * (Y(GN)+ GFOR(GN)*Y(GN)); + print('CGEQ(I,GN)') + left = P.loc(I) * ExprM(vars, m=1 + TAUG.loc[GS, I].sum(0)) * CG.loc(I, GN) + right = ExprM(vars, m=AG.loc[I, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) + + CGEQ = (right - left) + CGEQ.write(count, filename) + if test_values: + CGEQ.test(vars.initialVals) + # print(CGEQ) + + # GFEQ(F,GN).. FD(F,GN) * R(F,GN) * RA(F)*( 1 + SUM(GF, TAUFX(GF,F,GN))) + # =E= AG(F,GN) * (Y(GN)+ GFOR(GN)*Y(GN)); + print('GFEQ(F,GN)') + left = FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN])) + right = ExprM(vars, m=AG.loc[F, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) + + GFEQ = left - right + GFEQ.write(count, filename) + if test_values: + GFEQ.test(vars.initialVals) + # print(GFEQ) + + # GSEQL(GN).. S(GN) =E= (Y(GN)+ GVFOR(GN)) + # - SUM(I, CG(I,GN)*P(I)*(1 + SUM(GS, TAUG(GS,I)))) + # - SUM(F, FD(F,GN)*R(F,GN)*RA(F)*(1 + SUM(GF, TAUFX(GF,F,GN)))); + print('GSEQL(GN)') + line1 = Y.loc(GN) + GVFOR.loc(GN) + line2 = (CG.loc(I, GN) * P.loc(I) * (1 + ExprM(vars, m=TAUG.loc[GS, I]).sum(GS))).sum(I) + line3 = (FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN]))).sum(F) + + GSEQL = ((line1 - ~line2 - ~line3) - S.loc(GN)) + GSEQL.write(count, filename) + if test_values: + GSEQL.test(vars.initialVals) + # print(GSEQL) + + # GSEQ(GX).. S(GX) =E= (Y(GX) + GFOR(GX)*Y(GX)) - SUM(H, (TP(H,GX)*HH(H))) - SUM(G,IGT(G,GX)); + print('GSEQ(GX)') + line1 = (Y.loc(GX) + ExprM(vars, m=GFOR.loc[GX]) * Y.loc(GX)) + line2 = (ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H) + line3 = IGT.loc(G, GX).sum(G) + + GSEQ = ((line1 - ~line2 - ~line3) - S.loc(GX)) + GSEQ.write(count, filename) + if test_values: + GSEQ.test(vars.initialVals) + # print(GSEQ) + + # TDEQ(G,GX)$(IGTD(G,GX) EQ 1).. IGT(G,GX) + # =E= TAXS(G,GX)*(Y(GX) + GVFOR(GX)- SUM(H, (TP(H,GX)*HH(H)))); + print('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') + line = ExprM(vars, m=TAXS.loc[G, GX]) * ( + Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) + + TDEQ = line - IGT.loc(G, GX) + TDEQ.setCondition(IGTD.loc[G, GX], 'EQ', 1) + TDEQ.write(count, filename) + if test_values: + TDEQ.test(vars.initialVals) + # print(TDEQ) + + # SPIEQ.. SPI =E= SUM(H, Y(H)) + SUM((H,G), TP(H,G)*HH(H)) + SUM(H, PRIVRET(H)*HH(H)); + print('SPIEQ') + line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + ( + ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + + SPIEQ = (line - SPI) + SPIEQ.write(count, filename) + if test_values: + SPIEQ.test(vars.initialVals) + # print(SPIEQ) + + # LMEQ1(L).. SUM(H, HW(H)* JOBCOR(H, L))+CMI(L) =E= SUM(Z, FD(L ,Z) ) ; + print('LMEQ1(L)') + left = (ExprM(vars, m=JOBCOR.loc[H, L]) * HW.loc(H)).sum(H) + CMI.loc(L) + right = FD.loc(L, Z).sum(Z) + + LMEQ1 = (right - left) + LMEQ1.write(count, filename) + if test_values: + LMEQ1.test(vars.initialVals) + # print(LMEQ1) + + # KMEQ(K,IG).. KS(K,IG) =E= TT(K,IG)*FD(K,IG); + print('KMEQ(K,IG)') + KMEQ = ((ExprM(vars, m=TT.loc[K, IG]) * FD.loc(K, IG)) - KS.loc(K, IG)) + KMEQ.write(count, filename) + if test_values: + KMEQ.test(vars.initialVals) + # print(KMEQ) + + # GMEQ(I).. DS(I) =E= DD(I) + CX(I) - M(I); + print('GMEQ(I)') + GMEQ = (DD.loc(I) + CX.loc(I) - M.loc(I) - DS.loc(I)) + GMEQ.write(count, filename) + if test_values: + GMEQ.test(vars.initialVals) + # print(GMEQ) + + # DDEQ(I).. DD(I) =E= V(I) + SUM(H, CH(I,H) ) + SUM(G, CG(I,G) ) + CN(I); + print('DDEQ(I)') + DDEQ = (V.loc(I) + CH.loc(I, H).sum(H) + CG.loc(I, G).sum(G) + CN.loc(I) - DD.loc(I)) + DDEQ.write(count, filename) + if test_values: + DDEQ.test(vars.initialVals) + # print(DDEQ) + + # ------------------------------------------------------------------------------------------------------------- + # MODEL CLOSURE + # ------------------------------------------------------------------------------------------------------------- + + # FIX INTER GOVERNMENTAL TRANSFERS TO ZERO IF NOT IN ORIGINAL SAM + # IGT.FX(G,GX)$(NOT IGT0(G,GX))=0; + print('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') + FX1 = IGT.loc(G, GX) + FX1.setCondition(IGT0.loc[G, GX], 'EQ', 0) + FX1.write(count, filename) + # print(FX1) + + # FIX EXOGENOUS INTERGOVERNMENTAL TRANSFERS + # IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX); + print('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') + FX2 = IGT.loc(G, GX) - ExprM(vars, m=IGT0.loc[G, GX]) + FX2.setCondition(IGTD.loc[G, GX], 'EQ', 2) + FX2.write(count, filename) + # print(FX2) + + # FIX INTER SECTORAL WAGE DIFFERENTIALS + # R.FX(L,Z) = R0(L,Z); + print('R.FX(L,Z)=R0(L,Z)') + FX3 = R.loc(L, Z) - ExprM(vars, m=R0.loc[L, Z]) + FX3.write(count, filename) + # print(FX3) + + # FIX ECONOMY WIDE SCALAR + # RA.FX(K) = RA0(K); + print('RA.FX(K)=RA0(K)') + FX4 = RA.loc(K) - ExprM(vars, m=RA0.loc[K]) + FX4.write(count, filename) + # print(FX5) + + print("Objective") + obj = vars.getIndex('SPI') + + with open(filename, 'a') as f: + f.write('model.obj = Objective(expr=-1*model.x' + str(obj) + ')') + + def run_solver(cons_filename, temp_file_name="tmp.py"): + solver = 'ipopt' + solver_io = 'nl' + stream_solver = True # True prints solver output to screen + keepfiles = False # True prints intermediate file names (.nl,.sol,...) + opt = SolverFactory(solver, solver_io=solver_io) + + if opt is None: + print("") + print("ERROR: Unable to create solver plugin for %s " \ + "using the %s interface" % (solver, solver_io)) + print("") + exit(1) + + # Create the model + model = ConcreteModel() + set_variable(cons_filename) + set_equation(cons_filename) + + # read the model + exec(open(cons_filename).read()) + + # Declare all suffixes + # Ipopt bound multipliers (obtained from solution) + model.ipopt_zL_out = Suffix(direction=Suffix.IMPORT) + model.ipopt_zU_out = Suffix(direction=Suffix.IMPORT) + + # Ipopt bound multipliers (sent to solver) + model.ipopt_zL_in = Suffix(direction=Suffix.EXPORT) + model.ipopt_zU_in = Suffix(direction=Suffix.EXPORT) + + # Obtain dual solutions from first solve and send to warm start + model.dual = Suffix(direction=Suffix.IMPORT_EXPORT) + + ### Set Ipopt options for warm-start + # The current values on the ipopt_zU_out and ipopt_zL_out suffixes will be used as + # initial conditions for the bound multipliers to solve the new problem + model.ipopt_zL_in.update(model.ipopt_zL_out) + model.ipopt_zU_in.update(model.ipopt_zU_out) + opt.options['warm_start_init_point'] = 'yes' + opt.options['warm_start_bound_push'] = 1e-6 + opt.options['warm_start_mult_bound_push'] = 1e-6 + opt.options['mu_init'] = 1e-6 + + ### Send the model and suffix information to ipopt and collect the solution + # The solver plugin will scan the model for all active suffixes + # valid for importing, which it will store into the results object + + results = opt.solve(model, keepfiles=keepfiles, tee=stream_solver) + + x = [None for i in range(vars.nvars)] + + with open(temp_file_name, 'w') as f: + for i in range(vars.nvars): + f.write('x[' + str(i) + ']=value(model.x' + str(i) + ')\n') + + exec(open(temp_file_name).read()) + + soln.append(x[:]) + + return None + + + ''' + Calibrate the model + ''' + soln = [] + # filename = os.path.join(filePath, "ipopt_cons.py") + filename = 'ipopt_cons.py' + # tmp = os.path.join(filePath, "tmp.py") + tmp = 'tmp.py' + print("Calibration: ") + run_solver(filename, tmp) + + ''' + Simulation code below: + In each simulation: + + 1. Apply simulation code (for instance PI(I) = 1.02). + 2. Rewrite all equations + 3. Solve the new model with the result from last run as initial guess. + + ''' + + ############ begin shock by using tables + + # iNum = 1 # dynamic model itterations + + sims = pd.read_csv(os.path.join(filePath, 'SIMS 500.csv'), index_col=0) + iNum = 1 + # iNum = len(sims.columns) + KS00 = KS0.copy() + + for num in range(iNum): + # print("Simulation: ", num+1) + KS0.loc[K, I] = KS00.loc[K, I].mul(sims.iloc[:, num]) + run_solver(filename, tmp) + + # create output + CG0 = vars.get('CG', x=soln[0]) + CH0 = vars.get('CH', x=soln[0]) + CMI0 = vars.get('CMI', x=soln[0]) + CMO0 = vars.get('CMO', x=soln[0]) + CN0 = vars.get('CN', x=soln[0]) + CPI0 = vars.get('CPI', x=soln[0]) + CX0 = vars.get('CX', x=soln[0]) + D0 = vars.get('D', x=soln[0]) + DD0 = vars.get('DD', x=soln[0]) + DS0 = vars.get('DS', x=soln[0]) + FD0 = vars.get('FD', x=soln[0]) + IGT0 = vars.get('IGT', x=soln[0]) + KS0 = vars.get('KS', x=soln[0]) + #LAS0 = vars.get('LAS', x=soln[0]) + HH0 = vars.get('HH', x=soln[0]) + HN0 = vars.get('HN', x=soln[0]) + HW0 = vars.get('HW', x=soln[0]) + M0 = vars.get('M', x=soln[0]) + N0 = vars.get('N', x=soln[0]) + NKI0 = vars.get('NKI', x=soln[0]) + #LNFOR0 = vars.get('LNFOR', x=soln[0]) + KPFOR0 = vars.get('KPFOR', x=soln[0]) + GVFOR0 = vars.get('GVFOR', x=soln[0]) + P0 = vars.get('P', x=soln[0]) + PD0 = vars.get('PD', x=soln[0]) + PVA0 = vars.get('PVA', x=soln[0]) + RA0 = vars.get('RA', x=soln[0]) + R0 = vars.get('R', x=soln[0]) + S0 = vars.get('S', x=soln[0]) + SPI0 = vars.get('SPI', x=soln[0]) + V0 = vars.get('V', x=soln[0]) + Y0 = vars.get('Y', x=soln[0]) + YD0 = vars.get('YD', x=soln[0]) + + emplist = [] + dsrlist = [] + dsclist = [] + hhinclist = [] + miglist = [] + simlist = [] + + for i in range(iNum): + CGL = vars.get('CG', x=soln[i+1]) + CHL = vars.get('CH', x=soln[i+1]) + CMIL = vars.get('CMI', x=soln[i+1]) + CMOL = vars.get('CMO', x=soln[i+1]) + CNL = vars.get('CN', x=soln[i+1]) + CPIL = vars.get('CPI', x=soln[i+1]) + CXL = vars.get('CX', x=soln[i+1]) + DL = vars.get('D', x=soln[i+1]) + DDL = vars.get('DD', x=soln[i+1]) + DSL = vars.get('DS', x=soln[i+1]) + FDL = vars.get('FD', x=soln[i+1]) + IGTL = vars.get('IGT', x=soln[i+1]) + KSL = vars.get('KS', x=soln[i+1]) + #LASL = vars.get('LAS', x=soln[i+1]) + HHL = vars.get('HH', x=soln[i+1]) + HNL = vars.get('HN', x=soln[i+1]) + HWL = vars.get('HW', x=soln[i+1]) + ML = vars.get('M', x=soln[i+1]) + NL = vars.get('N', x=soln[i+1]) + NKIL = vars.get('NKI', x=soln[i+1]) + #LNFORL = vars.get('LNFOR', x=soln[i+1]) + KPFORL = vars.get('KPFOR', x=soln[i+1]) + GVFORL = vars.get('GVFOR', x=soln[i+1]) + PL = vars.get('P', x=soln[i+1]) + PDL = vars.get('PD', x=soln[i+1]) + PVAL = vars.get('PVA', x=soln[i+1]) + RAL = vars.get('RA', x=soln[i+1]) + RL = vars.get('R', x=soln[i+1]) + SL = vars.get('S', x=soln[i+1]) + SPIL = vars.get('SPI', x=soln[i+1]) + VL = vars.get('V', x=soln[i+1]) + YL = vars.get('Y', x=soln[i+1]) + YDL = vars.get('YD', x=soln[i+1]) + + DFCG = CGL - CG0 + DFFD = FDL - FD0 + DK = KSL - KS0 + DY = (YL/CPIL) - Y0 + DDS = DSL - DS0 + DDD = DDL - DD0 + DCX = CXL - CX0 + DCH = CHL - CH0 + DR = RL - R0 + DCMI = CMIL - CMI0 + DCMO = CMOL - CMO0 + DM = ML - M0 + DV = VL - V0 + DN = NL - N0 + + s_name = 'Simulation ' + str(i+1) + + emp = DFFD[DFFD.index.isin(['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', \ + 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', \ + 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'])].sum().sum() + dsr = DDS[DDS.index.isin(['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', \ + 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', \ + 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'])].sum() + dsc = DDS[DDS.index.isin(['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', 'OTHERD', \ + 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', 'OTHERH'])].sum() + hhinc = DY[DY.index.isin(['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', 'HH5C', \ + 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', 'HH5F', \ + 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'])].sum() + hhdiff = HHL-HH0 + mig = hhdiff.sum() + + emplist.append(emp) + dsrlist.append(dsr) + dsclist.append(dsc) + hhinclist.append(hhinc) + miglist.append(mig) + simlist.append(s_name) + + cols = {'dsc': dsclist, 'dsr': dsrlist, 'mig': miglist, 'emp': emplist, 'hhinc': hhinclist} + + df = pd.DataFrame.from_dict(cols) + df.to_csv('simulation_outputs.csv') + print("simulation_outpus.csv has been created.") + + +if __name__ == '__main__': + is_cd = False + test_values = False + main_calc(is_cd, test_values) \ No newline at end of file diff --git a/tests/pyincore/analyses/shelbycge/test_shelbycge.py b/tests/pyincore/analyses/shelbycge/test_shelbycge.py new file mode 100644 index 000000000..323625d2d --- /dev/null +++ b/tests/pyincore/analyses/shelbycge/test_shelbycge.py @@ -0,0 +1,37 @@ +from pyincore import IncoreClient +from pyincore.analyses.shelbycge import ShelbyCGEModel +import pyincore.globals as pyglobals + + +def run_base_analysis(): + client = IncoreClient(pyglobals.INCORE_API_DEV_URL) + shelby_cge = ShelbyCGEModel(client) + + # SAM + sam = "630e5906c8f8b7614f6e5c6d" + + # CAPITAL COMP + bb = "630e5ac3c8f8b7614f6e5c76" + + # MISC TABLES + employ = "630e5ba5c8f8b7614f6e5c7e" + jobcr = "630e5c59c8f8b7614f6e5c86" + hhtable = "630e5d08c8f8b7614f6e5c8e" + sims = "630e5e0bc8f8b7614f6e5c96" + # sector_shocks = "5f6123e35060967d84ab0f70" + + shelby_cge.set_parameter("print_solver_output", False) + + shelby_cge.load_remote_input_dataset("SAM", sam) + shelby_cge.load_remote_input_dataset("BB", bb) + shelby_cge.load_remote_input_dataset("EMPLOY", employ) + shelby_cge.load_remote_input_dataset("JOBCR", jobcr) + shelby_cge.load_remote_input_dataset("HHTABLE", hhtable) + shelby_cge.load_remote_input_dataset("SIMS", sims) + # seaside_cge.load_remote_input_dataset("sector_shocks", sector_shocks) + + shelby_cge.run_analysis() + + +if __name__ == '__main__': + run_base_analysis() From 6063c6d51f1be6d8d5c6d9cbf21e2e07f1b937eb Mon Sep 17 00:00:00 2001 From: Yong Wook Kim Date: Wed, 31 Aug 2022 14:47:28 -0500 Subject: [PATCH 5/8] initial working version --- pyincore/analyses/shelbycge/equationlib.py | 15 +- .../shelbycge/files/data_insertion.txt | 0 .../analyses/shelbycge/shelby/__init__.py | 0 pyincore/analyses/shelbycge/shelbycge.py | 942 +++++++----------- .../analyses/shelbycge/test_shelbycge.py | 2 - 5 files changed, 364 insertions(+), 595 deletions(-) delete mode 100644 pyincore/analyses/shelbycge/files/data_insertion.txt delete mode 100644 pyincore/analyses/shelbycge/shelby/__init__.py diff --git a/pyincore/analyses/shelbycge/equationlib.py b/pyincore/analyses/shelbycge/equationlib.py index 5c5bb0217..27c8fb8d4 100755 --- a/pyincore/analyses/shelbycge/equationlib.py +++ b/pyincore/analyses/shelbycge/equationlib.py @@ -1,4 +1,5 @@ from copy import deepcopy +from pyincore import globals as pyglobals import pandas as pd import operator as op import math @@ -6,6 +7,8 @@ import sys sys.setrecursionlimit(1500) +logger = pyglobals.LOGGER + class VarContainer: """ All matrix variable(tables) in the GAMS model is flatten to a array to make a better @@ -825,9 +828,9 @@ def write(self, count, filename): f.close() def test(self,x): - print("...testing the values....") - for i in range(self.info['height']): - for j in range(self.info['width']): - if not self.hasCondition or self.hasCondition and self.mark[i][j]: - fun = lambda x: eval( self.m[i][j].debug_test_str() ) - # print(i,j,fun(x)) + print("test") + # for i in range(self.info['height']): + # for j in range(self.info['width']): + # if not self.hasCondition or self.hasCondition and self.mark[i][j]: + # fun = lambda x: eval( self.m[i][j].debug_test_str() ) + # logger.debug(i,j,fun(x)) diff --git a/pyincore/analyses/shelbycge/files/data_insertion.txt b/pyincore/analyses/shelbycge/files/data_insertion.txt deleted file mode 100644 index e69de29bb..000000000 diff --git a/pyincore/analyses/shelbycge/shelby/__init__.py b/pyincore/analyses/shelbycge/shelby/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/pyincore/analyses/shelbycge/shelbycge.py b/pyincore/analyses/shelbycge/shelbycge.py index 6797be77e..62baf4f9c 100644 --- a/pyincore/analyses/shelbycge/shelbycge.py +++ b/pyincore/analyses/shelbycge/shelbycge.py @@ -5,15 +5,14 @@ # and is available at https://www.mozilla.org/en-US/MPL/2.0/ import os -import pandas as pd +import tempfile from pyincore import BaseAnalysis from pyincore import globals as pyglobals -from equationlib import * +from pyincore.analyses.shelbycge.equationlib import * from pyomo.environ import * from pyomo.opt import SolverFactory - logger = pyglobals.LOGGER class ShelbyCGEModel(BaseAnalysis): @@ -51,6 +50,12 @@ def get_spec(self): 'description': 'Path to ipopt package. If none is provided, it will default to your environment\'ts' 'path to the package.', 'type': str + }, + { + 'id': 'value_tests', + 'required': False, + 'description': 'Boolean for testing the values', + 'type': bool } ], 'input_datasets': [ @@ -60,7 +65,7 @@ def get_spec(self): 'description': 'Social accounting matrix (SAM) contains data for firms, ' 'households and government which are organized in a way to ' 'represent the interactions of all three entities in a typical economy.', - 'type': ['incore:SeasideCGEsam'] + 'type': ['incore:ShelbyCGEsam'] }, { 'id': 'BB', @@ -68,57 +73,53 @@ def get_spec(self): 'description': 'BB is a matrix which describes how investment in physical infrastructure is' ' transformed into functioning capital such as commercial and residential buildings.' ' These data are collected from the Bureau of Economic Analysis (BEA).', - 'type': ['incore:SeasideCGEbb'] + 'type': ['incore:ShelbyCGEbb'] }, { 'id': 'HHTABLE', 'required': True, 'description': 'HH Table.', - 'type': ['incore:SeasideCGEhhtable'] + 'type': ['incore:ShelbyCGEhhtable'] }, { 'id': 'EMPLOY', 'required': True, 'description': 'EMPLOY is a table name containing data for commercial sector employment.', - 'type': ['incore:SeasideCGEemploy'] + 'type': ['incore:ShelbyCGEemploy'] }, { 'id': 'JOBCR', 'required': True, 'description': 'JOBCR is a matrix describing the supply of workers' ' coming from each household group in the economy.', - 'type': ['incore:SeasideCGEjobcr'] + 'type': ['incore:ShelbyCGEjobcr'] }, { 'id': 'SIMS', 'required': True, 'description': 'Random numbers for the change of capital stocks in the CGE model.', - 'type': ['incore:SeasideCGEsim'] - }, - { - 'id': 'sector_shocks', - 'required': True, - 'description': 'Aggregation of building functionality states to capital shocks per sector', - 'type': ['incore:capitalShocks'] + 'type': ['incore:ShelbyCGEsim'] } ], 'output_datasets': [ { - 'id': 'Seaside_Sims', + 'id': 'Shelby_sims', 'parent_type': '', 'description': 'CSV file of Seaside cge simulations', - 'type': 'incore:SeasideCGEsims' + 'type': 'incore:ShelbyCGEsims' }, { - 'id': 'Seaside_output', + 'id': 'Shelby_output', 'parent_type': '', 'description': 'CSV file of output of Seaside cge, containing changes in employment and supply.', - 'type': 'incore:SeasideCGEEmployDS' + 'type': 'incore:ShelbyCGEEmployDS' } ] } - def run(is_cd=True, test_values=False): + def run(self): + test_values=False + is_cd=True def _(x): return ExprM(vars, m=x) @@ -325,9 +326,6 @@ def _(x): L3 = ['L3A', 'L3B', 'L3C', 'L3D', 'L3E', 'L3F', 'L3G', 'L3H'] - # LAND - # LA(F) = ['LAND'] - # CAPITAL K = ['KAP'] @@ -494,7 +492,6 @@ def _(x): # ---------------------------------------------------------------- # SET ALIASES # ---------------------------------------------------------------- - # ALIAS J = I I1 = I @@ -521,16 +518,12 @@ def _(x): # ---------------------------------------------------------------- # SAM - SAM = pd.read_csv(os.path.join(filePath, 'SAM Shelby(1202).csv'), index_col=0) + SAM = pd.read_csv(self.get_input_dataset("SAM").get_file_path('csv'), index_col=0) # CAPITAL COMP - BB = pd.read_csv(os.path.join(filePath, 'capcomshelby.csv'), index_col=0) + BB = pd.read_csv(self.get_input_dataset("BB").get_file_path('csv'), index_col=0) # MISC TABLES - ''' - - ''' - TPC = pd.DataFrame(index=H, columns=G).fillna(0.0) IGTD = pd.DataFrame(index=G, columns=G1).fillna(0.0) TAUFF = pd.DataFrame(index=G, columns=F).fillna(0.0) @@ -539,17 +532,13 @@ def _(x): MISC = pd.DataFrame(index=Z, columns=ETAMISC).fillna(0.0) MISCH = pd.DataFrame(index=H, columns=ETAMISCH).fillna(0.0) - # EMPLOY0 = pd.read_csv(os.path.join(miscPath, 'EMPLOY0(Z,F).csv'), index_col=0) - EMPLOY = pd.read_csv(os.path.join(miscPath, 'EMPLOY(Z,F).csv'), index_col=0) - JOBCR = pd.read_csv(os.path.join(miscPath, 'JOBCR(H,L).csv'), index_col=0) - # JOBCR1 = pd.read_csv(os.path.join(miscPath, 'JOBCR1(H,L).csv'), index_col=0) - HHTABLE = pd.read_csv(os.path.join(miscPath, 'HHTABLE(H,).csv'), index_col=0) - # OUTCR = pd.read_csv(os.path.join(miscPath, 'OUTCR(H,CM).csv'), index_col=0) + EMPLOY = pd.read_csv(self.get_input_dataset("EMPLOY").get_file_path('csv'), index_col=0) + JOBCR = pd.read_csv(self.get_input_dataset("JOBCR").get_file_path('csv'), index_col=0) + HHTABLE = pd.read_csv(self.get_input_dataset("HHTABLE").get_file_path('csv'), index_col=0) # ---------------------------------------------------------------- # PARAMETER DECLARATION # ---------------------------------------------------------------- - # these are data frames with zeros to be filled during calibration A = pd.DataFrame(index=Z, columns=Z).fillna(0.0) AD = pd.DataFrame(index=Z, columns=Z).fillna(0.0) @@ -592,7 +581,6 @@ def _(x): TAXS2 = pd.Series(index=GNLO, dtype=float).fillna(0.0) # ELASTICITIES AND TAX DATA IMPOSED - BETA = pd.DataFrame(index=I, columns=H).fillna(0.0) BETAH = pd.DataFrame(index=HSD, columns=H).fillna(0.0) ETAD = pd.Series(index=I, dtype=float).fillna(0.0) @@ -619,23 +607,18 @@ def _(x): ECOMO = pd.Series(index=CM, dtype=float).fillna(0.0) HOUSECOR = pd.DataFrame(index=H, columns=HSD).fillna(0.0) JOBCOR = pd.DataFrame(index=H, columns=L).fillna(0.0) - LAMBDA = pd.DataFrame(index=I, columns=I).fillna(0.0) LAMBDAH = pd.DataFrame(index=HSD, columns=HSD1).fillna(0.0) - NRPG = pd.Series(index=H, dtype=float).fillna(0.0) RHO = pd.Series(index=I, dtype=float).fillna(0.0) TT = pd.DataFrame(index=Z, columns=IG).fillna(0.0) - depr = pd.Series(index=IG, dtype=float).fillna(0.1) # ARRAYS BUILT TO EXPORT RESULTS TO SEPARATE FILE - R1 = pd.DataFrame(index=R1H, columns=SM).fillna(0.0) R2 = pd.DataFrame(index=R2H, columns=SM).fillna(0.0) # INITIAL VALUES OF ENDOGENOUS VARIABLES - CG0 = pd.DataFrame(index=I, columns=G).fillna(0.0) CG0T = pd.DataFrame(index=I, columns=G).fillna(0.0) CH0 = pd.DataFrame(index=I, columns=H).fillna(0.0) @@ -652,7 +635,6 @@ def _(x): DD0 = pd.Series(index=Z, dtype=float).fillna(0.0) DS0 = pd.Series(index=Z, dtype=float).fillna(0.0) DQ0 = pd.Series(index=Z, dtype=float).fillna(0.0) - FD0 = pd.DataFrame(index=F, columns=Z).fillna(0.0) IGT0 = pd.DataFrame(index=G, columns=GX).fillna(0.0) KS0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) @@ -669,7 +651,6 @@ def _(x): N0 = pd.DataFrame(index=K, columns=IG).fillna(0.0) # NKIO - KPFOR01 = pd.Series(index=K, dtype=float).fillna(0.0) KPFOR0 = pd.Series(index=K, dtype=float).fillna(0.0) # LNFOR0 = pd.Series(index=LA, dtype=float).fillna(0.0) @@ -688,14 +669,12 @@ def _(x): S0 = pd.Series(index=Z, dtype=float).fillna(0.0) # SPIO - V0 = pd.Series(index=I, dtype=float).fillna(0.0) V0T = pd.Series(index=I, dtype=float).fillna(0.0) V10 = pd.DataFrame(index=I, columns=I).fillna(0.0) TP = pd.DataFrame(index=H, columns=G).fillna(0.0) # TAUF0 = Table(G,F,Z) - YD0 = pd.Series(index=H, dtype=float).fillna(0.0) Y0 = pd.Series(index=Z, dtype=float).fillna(0.0) Y01 = pd.Series(index=H, dtype=float).fillna(0.0) @@ -703,7 +682,6 @@ def _(x): GCP10 = pd.Series(index=I, dtype=float).fillna(0.0) # GCP0 - DDCX = pd.Series(index=I, dtype=float).fillna(0.0) TESTA1 = None @@ -714,10 +692,9 @@ def _(x): TESTA2 = pd.DataFrame(index=F, columns=I).fillna(0.0) TESTA3 = pd.DataFrame(index=F, columns=I).fillna(0.0) - # =============================================================================== + # =============================================================================== # SIMPLIFYING TABLES AND DOING AWAY WITH MISC FILES # =============================================================================== - for label in G1: out.loc[label, label] = 0 out.loc['MEMPHIS', 'CYGFM'] = 1 @@ -774,34 +751,7 @@ def _(x): IOUT.loc[label, label] = 0 IOUT.loc['MEMPHIS', 'CYGFM'] = 1 IOUT.loc['OTHER', 'CYGFO'] = 1 - LANDCAP.loc[IG, ETALANDCAP] = 1 - ''' - LANDCAP.loc['CONST1', 'ETAL1'] = 0.5 - LANDCAP.loc['RETAIL1', 'ETAL1'] = 2 - LANDCAP.loc['SERV1', 'ETAL1'] = 1.4 - LANDCAP.loc['HC1', 'ETAL1'] = 1.4 - LANDCAP.loc['ACCOM1', 'ETAL1'] = 0.5 - LANDCAP.loc['REST1', 'ETAL1'] = 0.5 - LANDCAP.loc['AG2', 'ETAL1'] = 0.5 - LANDCAP.loc['CONST2', 'ETAL1'] = 0.5 - LANDCAP.loc['MANUF2', 'ETAL1'] = 0.5 - LANDCAP.loc['RETAIL2', 'ETAL1'] = 2 - LANDCAP.loc['SERV2', 'ETAL1'] = 0.5 - LANDCAP.loc['HC2', 'ETAL1'] = 0.5 - LANDCAP.loc['ACCOM2', 'ETAL1'] = 0.5 - LANDCAP.loc['REST2', 'ETAL1'] = 0.5 - LANDCAP.loc['AG3', 'ETAL1'] = 0.5 - LANDCAP.loc['UTIL', 'ETAL1'] = 1.4 - LANDCAP.loc['CONST3', 'ETAL1'] = 1.4 - LANDCAP.loc['RETAIL3', 'ETAL1'] = 2 - LANDCAP.loc['SERV3', 'ETAL1'] = 1.4 - LANDCAP.loc['HC3', 'ETAL1'] = 2 - LANDCAP.loc['HS1', 'ETAL1'] = 2 - LANDCAP.loc['HS2', 'ETAL1'] = 2 - LANDCAP.loc['HS3', 'ETAL1'] = 2 - ''' - MISCH.loc[H, ETAMISCH] = 0 MISCH.loc[HH1, 'ETAPT'] = -0.5 MISCH.loc[HH2, 'ETAPIT'] = -0.15 @@ -810,46 +760,20 @@ def _(x): MISCH.loc[HH5, 'ETAPIT'] = -0.35 MISCH.loc[H, 'NRPG'] = 1 - # MISCH.loc[H, 'ETARA'] = 1 - ''' - # DRAM - MISCH.loc[HH2, 'ETARA'] = 0.2 - MISCH.loc[HH3, 'ETARA'] = 0.3 - MISCH.loc[HH4, 'ETARA'] = 0.5 - MISCH.loc[HH5, 'ETARA'] = 0.8 - - MISCH.loc[HH1, 'ETAYD'] = 1.3 - MISCH.loc[HH2, 'ETAYD'] = 1.6 - MISCH.loc[HH3, 'ETAYD'] = 1.8 - MISCH.loc[HH4, 'ETAYD'] = 2.0 - MISCH.loc[HH5, 'ETAYD'] = 2.1 - - MISCH.loc[HH1, 'ETAU'] = -0.8 - MISCH.loc[HH2, 'ETAU'] = -0.6 - MISCH.loc[HH3, 'ETAU'] = -0.5 - MISCH.loc[HH4, 'ETAU'] = -0.4 - MISCH.loc[HH5, 'ETAU'] = -0.3 - ''' - MISC.loc[IG, ETAMISC] = 0 + MISC.loc[IG, 'ETAMISC'] = 0 MISC.loc[IP, 'ETAM'] = 1 - # MISC.loc[IP, 'ETAE'] = -3.65 MISC.loc[I, 'ETAY'] = 1 MISC.loc[I, 'ETAOP'] = -1 # =============================================================================== # PARAMETERS AND ELASTICITIES # =============================================================================== - out.loc[G1, G1] = IOUT.loc[G1, G1]; BETA.loc[I, H] = MISC.loc[I, 'ETAY']; BETAH.loc[HSD, H] = MISC.loc[HSD, 'ETAY']; for label in I: LAMBDA.loc[label, label] = MISC.loc[label, 'ETAOP']; - ''' - for label in HD: - LAMBDAH.loc[label,label] = MISC.loc[label,'ETAOP']; - ''' ETAE.loc[I] = MISC.loc[I, 'ETAE']; ETAM.loc[I] = MISC.loc[I, 'ETAM']; ETARA.loc[H] = MISCH.loc[H, 'ETARA']; @@ -862,56 +786,32 @@ def _(x): ETAI.loc[IG] = LANDCAP.loc[IG, 'ETAI1']; ETAIX.loc['KAP', IG] = ETAI.loc[IG]; - ''' - ETAIX.loc['KAP',IG] = LANDCAP.loc[IG,'ETAI1']; - ETAL.loc['LAND',IG] = LANDCAP.loc[IG,'ETAL1']; - ETALB.loc[L,IG] = LANDCAP.loc[IG,'ETALB1']; - ''' - # ======================================================================================================== # ====================play with elasticities============================================================== # ======================================================================================================== # EXPERIMENTAL ELASTICITIES - ECOMI.loc[L] = 1; - ECOMO.loc[CM] = 1; - EXWGEO.loc[CM] = 1; - EXWGEI.loc[L] = 1; - ETAE.loc[IP] = -0.4; - ETAIX.loc['KAP', IG] = 0.1; - ETARA.loc[H] = 1.5; - ETAYDO.loc[H] = 1.0; - ETAYDI.loc[H] = 1.5; - ETAUI.loc[H] = -0.72; - ETAUO.loc[HH1] = -0.8; - ETAUO.loc[HH2] = -0.6; - ETAUO.loc[HH3] = -0.4; - ETAUO.loc[HH4] = -0.2; - ETAUO.loc[HH5] = -0.2; - ETAU.loc[H] = -0.1; - ETAYD.loc[H] = 1; - ''' - #ETARA[H] = 2.0; - #ETAIX['KAP',IG] = 0.1*ETAIX['KAP',IG]; - ETAIX.loc['KAP',IG] = 0.1; - ETAE.loc[IP] = -1.5; - - # DRAM ELASTICITIES - #ETAUO[H] = MISCH[H, 'ETAU']; - #ETAUI[H] = MISCH[H, 'ETAU']; - #ETAE[IP] = -1.65; - #ETAYDO[H] = ETAYD[H]; - #ETAYDI[H] = ETAYD[H]; - #ETAUI[H] = ETAU[H]; - #ETAUO[H] = ETAU[H]; - - SIGMA.loc[I] = 0.67; - ''' + ECOMI.loc[L] = 1 + ECOMO.loc[CM] = 1 + EXWGEO.loc[CM] = 1 + EXWGEI.loc[L] = 1 + ETAE.loc[IP] = -0.4 + ETAIX.loc['KAP', IG] = 0.1 + ETARA.loc[H] = 1.5 + ETAYDO.loc[H] = 1.0 + ETAYDI.loc[H] = 1.5 + ETAUI.loc[H] = -0.72 + ETAUO.loc[HH1] = -0.8 + ETAUO.loc[HH2] = -0.6 + ETAUO.loc[HH3] = -0.4 + ETAUO.loc[HH4] = -0.2 + ETAUO.loc[HH5] = -0.2 + ETAU.loc[H] = -0.1 + ETAYD.loc[H] = 1 # =============================================================================== # CALIBRATION # =============================================================================== - # Column Totals of SAM table Q10.loc[Z] = SAM.loc[Z, Z].sum(1) @@ -977,18 +877,14 @@ def _(x): TAUFXgx[GX[i]] = pd.DataFrame(TAUFarray[i], index=F, columns=Z).fillna(0.0) # SS TAX RATES - # TAUFH(GF,F)$(TAUFF(GF,F)) =SAM(GF,F) / SUM(Z, SAM(Z,F)); for i in GF: for j in F: if TAUFF.loc[i, j] != 0: - # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[Z, F].sum(0).loc[j]) TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[Z, F].sum(0).at[j] - # TAUFH(GFUS,L) =SAM(GFUS,L) / SUM(IG, SAM(L,IG)); for i in GFUS: for j in L: if TAUFF.loc[i, j] != 0: - # TAUFH.set_value(i, j, SAM.loc[i, j] / SAM.loc[L, IG].sum(1).loc[j]) TAUFH.at[i, j] = SAM.at[i, j] / SAM.loc[L, IG].sum(1).at[j] # EMPLOYEE PORTION OF FACTOR TAXES @@ -1046,9 +942,6 @@ def _(x): # A = INPUT OUTPUT COEFICIENTS A.loc[Z, Z] = SAM.loc[Z, Z].div(Q0.loc[Z], axis='columns') - # SS PAYMENTS FROM IN-COMMUTERS - # A(GFUSC, LCOM) = TAUFL(GFUSC, LCOM); - # AGFS: LABOR PAYMENTS BY G SECTOR + USSOC PAYMENTS BY LABOR (GROSS LABOR PAYMENTS) AGFS.loc['L1A', G] = SAM.loc['L1A', G] + SAM.loc['USSOCL1A', G] AGFS.loc['L2A', G] = SAM.loc['L2A', G] + SAM.loc['USSOCL2A', G] @@ -1155,8 +1048,6 @@ def _(x): RA0.loc[F] = 1.0 # CALIBRATION OF PRODUCTION EXPONENTS FOR COBB DOUGLAS - # a = pd.Series(index=I, dtype=float).fillna(0.0) - # a = SAM.loc[GFUS, I].append(a, ignore_index=True).append(SAM.loc[GL, I]) # labor, capital a = SAM.loc['MEMPROPTAX', I] + SAM.loc['OTHERPROPTAX', I] a_new_row = pd.DataFrame([a]) a = pd.concat([SAM.loc[GFUS, I], a_new_row]) @@ -1180,10 +1071,8 @@ def _(x): SIGMA.loc[I] = 0.67 RHO.loc[I] = (SIGMA.loc[I] - 1) / SIGMA.loc[I] TESTA1.loc[F, I] = 0.0 - # TESTA1(F,I) = R0(F,I) * RA0(F)*(1 + SUM(GF,TAUFX(GF,F,I)))*((FD0(F,I))**(1-RHO(I))); TESTA1.loc[F, I] = R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( FD0.loc[F, I] ** (1 - RHO.loc[I])) - # TESTA2(F,I) = SUM(F1, R0(F1,I) * RA0(F1) * (1 + SUM(GF,TAUFX(GF,F1,I)))*((FD0(F1,I))**(1-RHO(I)))); TESTA2_pre = (R0.loc[F, I].mul(RA0.loc[F], axis='index') * (1 + TAUFX_SUM.loc[F, I]) * ( FD0.loc[F, I] ** (1 - RHO.loc[I]))).sum(0) TESTA2.loc[F, I] = 1 @@ -1214,14 +1103,6 @@ def _(x): # NOMINAL GOVERNMENT OUTFLOWS GVFOR0.loc[G] = SAM.loc[G, ["ROW"]].sum(1) - ''' - GVFOR0.loc[GT] = SAM.loc[Z, GT].sum(0) - ( - SAM.loc[GT, I].sum(1) - + SAM.loc[GT, F].sum(1) - + SAM.loc[GT, H].sum(1) - + SAM.loc[GT, G].sum(1) - ) - ''' # ORIGINAL EQUATION A.loc[H, L] = SAM.loc[H, L].div(HW0.loc[H], axis='index') / ( @@ -1299,7 +1180,6 @@ def _(x): ########################################### # VARIABLE DECLARATION ########################################### - vars = VarContainer() # PUBLIC CONSUMPTION @@ -1416,13 +1296,9 @@ def _(x): # AFTER TAX TOTAL HOUSEHOLD INCOMES YD = vars.add('YD', rows=H) - # GOV INCOME - # YT = vars.add('YT', rows=G, cols=G) - ########################################### # INITIALIZE VARIABLES FOR SOLVER ########################################### - vars.init('CG', CG0.loc[I, G]) vars.init('CH', CH0.loc[I, H]) vars.init('CMI', CMI0.loc[L]) @@ -1443,11 +1319,9 @@ def _(x): vars.init('HW', HW0.loc[H]) vars.init('IGT', IGT0.loc[G, GX]) vars.init('KS', KS0.loc[K, IG]) - # vars.init('LAS', LAS0.loc[LA, IG]) vars.init('M', M0.loc[I]) vars.init('N', N0.loc[K, IG]) vars.init('NKI', NKI0) - # vars.init('LNFOR', LNFOR0.loc[LA]) vars.init('KPFOR', KPFOR0.loc[K]) vars.init('GVFOR', GVFOR0.loc[G]) vars.init('P', P0.loc[I]) @@ -1460,67 +1334,59 @@ def _(x): vars.init('V', V0.loc[I]) vars.init('V1', V10.loc[I, I]) vars.init('Y', Y0.loc[Z]) - # vars.init('Y1') - # vars.init('Y2') - # vars.init('Y3') vars.init('YD', YD0.loc[H]) - # vars.init('YT') - # ------------------------------------------------------------------------------------------------------------- # DEFINE BOUNDS FOR VARIABLES # ------------------------------------------------------------------------------------------------------------- - - vars.lo('P', vars.get('P') / 1000); + vars.lo('P', vars.get('P') / 1000) vars.up('P', vars.get('P') * 1000) - vars.lo('PD', vars.get('PD') / 1000); + vars.lo('PD', vars.get('PD') / 1000) vars.up('PD', vars.get('PD') * 1000) - vars.lo('PVA', vars.get('PVA') / 1000); + vars.lo('PVA', vars.get('PVA') / 1000) vars.up('PVA', vars.get('PVA') * 1000) - vars.lo('RA', vars.get('RA') / 1000); + vars.lo('RA', vars.get('RA') / 1000) vars.up('RA', vars.get('RA') * 1000) - vars.lo('CPI', vars.get('CPI') / 1000); + vars.lo('CPI', vars.get('CPI') / 1000) vars.up('CPI', vars.get('CPI') * 1000) - vars.lo('CMI', vars.get('CMI') / 1000); + vars.lo('CMI', vars.get('CMI') / 1000) vars.up('CMI', vars.get('CMI') * 1000) - vars.lo('CMO', vars.get('CMO') / 1000); + vars.lo('CMO', vars.get('CMO') / 1000) vars.up('CMO', vars.get('CMO') * 1000) - vars.lo('DS', vars.get('DS') / 1000); + vars.lo('DS', vars.get('DS') / 1000) vars.up('DS', vars.get('DS') * 1000) - vars.lo('DD', vars.get('DD') / 1000); + vars.lo('DD', vars.get('DD') / 1000) vars.up('DD', vars.get('DD') * 1000) - vars.lo('D', vars.get('D') / 1000); + vars.lo('D', vars.get('D') / 1000) vars.up('D', vars.get('D') * 1000) - vars.lo('V', vars.get('V') / 1000); + vars.lo('V', vars.get('V') / 1000) vars.up('V', vars.get('V') * 1000) - vars.lo('FD', vars.get('FD') / 1000); + vars.lo('FD', vars.get('FD') / 1000) vars.up('FD', vars.get('FD') * 1000) - vars.lo('HH', vars.get('HH') / 1000); + vars.lo('HH', vars.get('HH') / 1000) vars.up('HH', vars.get('HH') * 1000) - vars.lo('HW', vars.get('HW') / 1000); + vars.lo('HW', vars.get('HW') / 1000) vars.up('HW', vars.get('HW') * 1000) - vars.lo('HN', vars.get('HN') / 1000); + vars.lo('HN', vars.get('HN') / 1000) vars.up('HN', vars.get('HN') * 1000) - vars.lo('KS', vars.get('KS') / 1000); + vars.lo('KS', vars.get('KS') / 1000) vars.up('KS', vars.get('KS') * 1000) - # vars.lo('LAS',vars.get('LAS')/1000); vars.up('LAS',vars.get('LAS')*1000) - vars.lo('M', vars.get('M') / 1000); + vars.lo('M', vars.get('M') / 1000) vars.up('M', vars.get('M') * 1000) - vars.lo('Y', vars.get('Y') / 1000); + vars.lo('Y', vars.get('Y') / 1000) vars.up('Y', vars.get('Y') * 1000) - vars.lo('YD', vars.get('YD') / 1000); + vars.lo('YD', vars.get('YD') / 1000) vars.up('YD', vars.get('YD') * 1000) - vars.lo('CH', vars.get('CH') / 1000); + vars.lo('CH', vars.get('CH') / 1000) vars.up('CH', vars.get('CH') * 1000) - vars.lo('CG', vars.get('CG') / 1000); + vars.lo('CG', vars.get('CG') / 1000) vars.up('CG', vars.get('CG') * 1000) - vars.lo('CX', vars.get('CX') / 1000); + vars.lo('CX', vars.get('CX') / 1000) vars.up('CX', vars.get('CX') * 1000) - vars.lo('R', vars.get('R') / 1000); + vars.lo('R', vars.get('R') / 1000) vars.up('R', vars.get('R') * 1000) - vars.lo('N', 0); - vars.lo('CN', 0); - + vars.lo('N', 0) + vars.lo('CN', 0) def set_variable(filename): # clear the file before write the variables @@ -1535,46 +1401,29 @@ def set_variable(filename): def set_equation(filename): count = [0] - # CPIEQ(H).. - # CPI(H)=E= - # SUM(I, P(I) * ( 1 + SUM(GS, TAUC(GS,I) ) ) * CH(I,H) ) - # / SUM(I, P0(I) * ( 1 + SUM(GS, TAUQ(GS,I) ) ) * CH(I,H) ); - print('CPIEQ(H)') + logger.debug('CPIEQ(H)') line1 = (P.loc(I) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0)) * CH.loc(I, H)).sum(I) line2 = (ExprM(vars, m=P0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0))) * CH.loc(I, H)).sum(I) CPIEQ = (line1 / line2 - ~CPI.loc(H)) - if test_values: - CPIEQ.test(vars.initialVals) + logger.debug(CPIEQ.test(vars.initialVals)) CPIEQ.write(count, filename) - # YEQ(H).. - # YEQ(H).. Y(H) =E= SUM(L, A(H,L) * HW(H) / SUM(H1, A(H1,L) * HW(H1) ) * (Y(L) * ( 1 - SUM(G, TAUFL(G,L))) - RA(L)*CMIWAGE(L)*CMI(L))) - # + SUM(CM, A(H,CM)*(CMOWAGE(CM)*CMO(CM))) - # + SUM(K, A(H,K) * HW(H) / SUM(H1, A(H1,K) * HW(H1)) - # * (Y(K) + KPFOR(K)) * ( 1 - SUM(G, TAUFK(G,K) ) ) ); - - print('YEQ(H)') - line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * ( - Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * ExprM(vars, - m=CMIWAGE.loc[L]) * CMI.loc( - L))).sum(L) + logger.debug('YEQ(H)') + line1 = (ExprM(vars, m=A.loc[H, L]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, L]) * HW.loc(H1)).sum(H1) * + (Y.loc(L) * ExprM(vars, m=1 - TAUFL.loc[G, L].sum(0)) - RA.loc(L) * + ExprM(vars, m=CMIWAGE.loc[L]) * CMI.loc(L))).sum(L) line2 = (ExprM(vars, m=A.loc[H, CM]) * (ExprM(vars, m=CMOWAGE.loc[CM]) * CMO.loc(CM))).sum(CM) - # line3 = (ExprM(vars, m= A.loc[H,LA]) * HW.loc(H) / (ExprM(vars, m= A.loc[H1,LA]) * HW.loc(H1)).sum(H1) * (Y.loc(LA) + LNFOR.loc(LA) ) * ExprM(vars, m= 1 - TAUFLA.loc[G,LA].sum(0))).sum(LA) - line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * ( - Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) + line4 = (ExprM(vars, m=A.loc[H, K]) * HW.loc(H) / (ExprM(vars, m=A.loc[H1, K]) * HW.loc(H1)).sum(H1) * + (Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) YEQ = ((line1 + line2 + line4) - Y.loc(H)) if test_values: YEQ.test(vars.initialVals) YEQ.write(count, filename) - # print(YEQ) - # YDEQ(H).. YD(H) =E= Y(H) + (PRIVRET(H) * HH(H)) - # + SUM(G, TP(H,G) * HH(H)) - # - SUM(GI, PIT0(GI,H) * Y(H)) - # - SUM(G, TAUH(G,H) * HH(H)); - print('YDEQ(H)') + + logger.debug('YDEQ(H)') line1 = Y.loc(H) + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)) line2 = (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum(G) line3 = ~(ExprM(vars, m=PIT0.loc[GI, H]) * Y.loc(H)).sum(GI) @@ -1582,186 +1431,125 @@ def set_equation(filename): YDEQ = ((line1 + line2 - line3 - line4) - YD.loc(H)) YDEQ.write(count, filename) - if test_values: - YDEQ.test(vars.initialVals) - # print(YDEQ) - - # CHEQ(I,H).. CH(I,H) =E= CH0(I,H)* ((YD(H) / YD0(H)) / ( CPI(H) / CPI0(H)))**(BETA(I,H)) - # * PROD(J, ((P(J)*( 1 + SUM(GS, TAUC(GS,J))))/ (P0(J)*(1 + SUM(GS, TAUQ(GS,J)))))** (LAMBDA(J,I))); - print('CHEQ(I,H)') - line1 = ExprM(vars, m=CH0.loc[I, H]) * ( - (YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m= - BETA.loc[I, H]) - line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / ( - ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** ExprM(vars, m=LAMBDA.loc[ - J, I])).prod(0) + logger.debug(YDEQ.test(vars.initialVals)) + + logger.debug('CHEQ(I,H)') + line1 = ExprM(vars, m=CH0.loc[I, H]) * \ + ((YD.loc(H) / ExprM(vars, m=YD0.loc[H])) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** \ + ExprM(vars, m=BETA.loc[I, H]) + line2 = (((P.loc(J) * ExprM(vars, m=1 + TAUC.loc[GS, J].sum(0))) / + (ExprM(vars, m=P0.loc[J]) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0)))) ** + ExprM(vars, m=LAMBDA.loc[J, I])).prod(0) CHEQ = ((line1 * line2) - CH.loc(I, H)) CHEQ.write(count, filename) - if test_values: - CHEQ.test(vars.initialVals) - # print(CHEQ) + logger.debug(CHEQ.test(vars.initialVals)) - # SHEQ(H).. S(H) =E= YD(H) - SUM(I, P(I) * CH(I,H) * ( 1 + SUM(GS, TAUC(GS,I)))); - print('SHEQ(H)') + logger.debug('SHEQ(H)') line = YD.loc(H) - ~((P.loc(I) * CH.loc(I, H) * ExprM(vars, m=1 + TAUC.loc[GS, I].sum(0))).sum(I)) SHEQ = (line - S.loc(H)) SHEQ.write(count, filename) - if test_values: - SHEQ.test(vars.initialVals) - # print(SHEQ) + logger.debug(SHEQ.test(vars.initialVals)) - # PVAEQ(I).. PVA(I) =E= PD(I) - SUM(J, AD(J,I) * P(J) * (1 + SUM(GS, TAUQ(GS, J)))); - print('PVAEQ(I)') - line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) + logger.debug('PVAEQ(I)') + line = PD.loc(I) - ~((ExprM(vars, m=AD.loc[J, I]) * P.loc(J) * + ExprM(vars, m=1 + TAUQ.loc[GS, J].sum(0))).sum(0)) PVAEQ = (line - PVA.loc(I)) PVAEQ.write(count, filename) - if test_values: - PVAEQ.test(vars.initialVals) - # print(PVAEQ) + logger.debug(PVAEQ.test(vars.initialVals)) - # PFEQ(I)..DS(I) =E= DELTA(I)*PROD(F$ALPHA(F,I),(TT(F,I)*FD(F,I))**ALPHA(F,I)); if is_cd: - print('PFEQ(I)') - line = ExprM(vars, m=DELTA.loc[I]) * ( - (ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) ** ExprM(vars, m=ALPHA.loc[F, I])).prod(F) + logger.debug('PFEQ(I)') + line = ExprM(vars, m=DELTA.loc[I]) * \ + ((ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) ** ExprM(vars, m=ALPHA.loc[F, I])).prod(F) PFEQ = (line - DS.loc(I)) PFEQ.write(count, filename) - if test_values: - PFEQ.test(vars.initialVals) - # print(PFEQ) + logger.debug(PFEQ.test(vars.initialVals)) else: - # CES - # PFEQ(I)..DS(I) =E= GAMMA(I)*(SUM(F, ALPHA(F,I)*(FD(F,I)**(RHO(I)))))**(1/RHO(I)); - print('PFEQ(I)') + logger.debug('PFEQ(I)') line = ExprM(vars, m=GAMMA.loc[I]) * \ - ((ExprM(vars, m=ALPHA.loc[F, I]) * (FD.loc(F, I) ** ExprM(vars, m=RHO.loc[I]))).sum(F)) \ - ** ExprM(vars, m=1 / RHO.loc[I]) + ((ExprM(vars, m=ALPHA.loc[F, I]) * (FD.loc(F, I) ** ExprM(vars, m=RHO.loc[I]))).sum(F)) ** \ + ExprM(vars, m=1 / RHO.loc[I]) PFEQ = (line - DS.loc(I)) PFEQ.write(count, filename) - if test_values: - PFEQ.test(vars.initialVals) - # print(PFEQ) + logger.debug(PFEQ.test(vars.initialVals)) if is_cd: - # FDEQ(F,I).. R(F,I) * RA(F) * (1 + SUM(GF,TAUFX(GF,F,I) ) )* (TT(F,I)* FD(F,I)) - # =E= PVA(I) * DS(I) * ALPHA(F,I); - print('FDEQ(F,I)') - left = R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I]) * ( - ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) + logger.debug('FDEQ(F,I)') + left = R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I]) * \ + (ExprM(vars, m=TT.loc[F, I]) * FD.loc(F, I)) right = ~(PVA.loc(I) * DS.loc(I) * ExprM(vars, m=ALPHA.loc[F, I])) FDEQ = (right - left) - # FDEQ.test(vars.initialVals) FDEQ.write(count, filename) - if test_values: - FDEQ.test(vars.initialVals) - # print(FDEQ) + logger.debug(FDEQ.test(vars.initialVals)) else: - # FD of CES - # FDEQ(F,I).. (R(F,I) * RA(F)*(1 + SUM(GF,TAUFX(GF,F,I))))* (FD(F,I)**(1-RHO(I))) - # =E= PVA(I)* ALPHA(F,I)*(GAMMA(I)**RHO(I))*(DS(I)**(1-RHO(I))); - print('FDEQ(F,I)') - left = (R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I])) * ( - FD.loc(F, I) ** ExprM(vars, m=1 - RHO.loc[I])) - right = ~(PVA.loc(I) * (ExprM(vars, m=ALPHA.loc[F, I] * (GAMMA.loc[I] ** RHO.loc[I])) * ( - DS.loc(I) ** ExprM(vars, m=1 - RHO.loc[I])))) + logger.debug('FDEQ(F,I)') + left = (R.loc(F, I) * RA.loc(F) * ExprM(vars, m=1 + TAUFX_SUM.loc[F, I])) * \ + (FD.loc(F, I) ** ExprM(vars, m=1 - RHO.loc[I])) + right = ~(PVA.loc(I) * (ExprM(vars, m=ALPHA.loc[F, I] * (GAMMA.loc[I] ** RHO.loc[I])) * + (DS.loc(I) ** ExprM(vars, m=1 - RHO.loc[I])))) FDEQ = (right - left) FDEQ.setCondition(FD0.loc[F, I], 'INEQ', 0) - # FDEQ.test(vars.initialVals) FDEQ.write(count, filename) - if test_values: - FDEQ.test(vars.initialVals) - # print(FDEQ) + logger.debug(FDEQ.test(vars.initialVals)) - # VEQ(I).. V(I) =E= SUM(J, AD(I,J) * DS(J) ); - - print('VEQ(I)') + logger.debug('VEQ(I)') line = (ExprM(vars, m=AD.loc[I, J]) * ~DS.loc(J)).sum(1) VEQ = (line - V.loc(I)) VEQ.write(count, filename) - if test_values: - VEQ.test(vars.initialVals) - # print(VEQ) + logger.debug(VEQ.test(vars.initialVals)) - # YFEQL(F).. Y(F) =E= SUM(IG, R(F,IG) * RA(F)*FD(F,IG)); - print('YFEQL(L)') + logger.debug('YFEQL(L)') line = (R.loc(F, IG) * RA.loc(F) * FD.loc(F, IG)).sum(IG) YFEQL = (line - Y.loc(F)) YFEQL.write(count, filename) - if test_values: - YFEQL.test(vars.initialVals) - # print(YFEQL) + logger.debug(YFEQL.test(vars.initialVals)) - # KAPFOR(K).. KPFOR(K) =E= KFOR(K) * Y(K); - print('KAPFOR(K)') + logger.debug('KAPFOR(K)') line = ExprM(vars, m=KFOR.loc[K]) * Y.loc(K) KAPFOR = (line - KPFOR.loc(K)) KAPFOR.write(count, filename) - if test_values: - KAPFOR.test(vars.initialVals) - # print(KAPFOR) + logger.debug(KAPFOR.test(vars.initialVals)) - # XEQ(I).. CX(I) =E= CX0(I)*( (PD(I)*(1+SUM(GS,TAUX(GS,I)))) - # /(PW0(I)*(1+SUM(GS,TAUQ(GS,I))))) **(ETAE(I)); - print('XEQ(I)') + logger.debug('XEQ(I)') line = ExprM(vars, m=CX0.loc[I]) * \ - ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / ExprM(vars, m=PW0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0)))) \ - ** ExprM(vars, m=ETAE.loc[I]) + ((PD.loc(I) * ExprM(vars, m=1 + TAUX.loc[GS, I].sum(0))) / + ExprM(vars, m=PW0.loc[I] * (1 + TAUQ.loc[GS, I].sum(0)))) ** ExprM(vars, m=ETAE.loc[I]) XEQ = (line - CX.loc(I)) XEQ.write(count, filename) - if test_values: - XEQ.test(vars.initialVals) - # print(XEQ) + logger.debug(XEQ.test(vars.initialVals)) - # DEQ(I)$PWM0(I).. D(I) =E= D0(I) *(PD(I)/PWM0(I))**(ETAD(I)); - print('DEQ(I)$PWM0(I)') + logger.debug('DEQ(I)$PWM0(I)') line = ExprM(vars, m=D0.loc[I]) * (PD.loc(I) / ExprM(vars, m=PWM0.loc[I])) ** ExprM(vars, m=ETAD.loc[I]) DEQ = (line - D.loc(I)) - # DEQ.setCondition(PWM0.loc[I]) DEQ.write(count, filename) - if test_values: - DEQ.test(vars.initialVals) - # print(DEQ) + logger.debug(DEQ.test(vars.initialVals)) - # MEQ(I).. M(I) =E= ( 1 - D(I) ) * DD(I); - print('MEQ(I)') + logger.debug('MEQ(I)') line = (1 - D.loc(I)) * DD.loc(I) MEQ = (line - M.loc(I)) MEQ.write(count, filename) - if test_values: - MEQ.test(vars.initialVals) - # print(MEQ) + logger.debug(MEQ.test(vars.initialVals)) - # PEQ(I).. P(I) =E= D(I) * PD(I) + ( 1 - D(I) ) * PWM0(I); - print('PEQ(I)') + logger.debug('PEQ(I)') line = (D.loc(I) * PD.loc(I) + (1 - D.loc(I)) * ExprM(vars, m=PWM0.loc[I])) PEQ = (line - P.loc(I)) PEQ.write(count, filename) - if test_values: - PEQ.test(vars.initialVals) - # print(PEQ) - - # NKIEQ.. NKI =E= SUM(I, M(I) * PWM0(I) ) - # - SUM(I, CX(I) * PD(I) ) - # - SUM(H, PRIVRET(H)*HH(H)) - # - SUM(K, KPFOR(K)) - # - SUM(G, GVFOR(G)) - # - SUM(CM,CMOWAGE(CM)*CMO(CM)) - # - SUM(L,CMIWAGE(L)*CMI(L)); - - print('NKIEQ') + logger.debug(PEQ.test(vars.initialVals)) + + logger.debug('NKIEQ') line1 = (M.loc(I) * ExprM(vars, m=PWM0.loc[I])).sum(I) line2 = (CX.loc(I) * PD.loc(I)).sum(I) line3 = (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) @@ -1772,405 +1560,306 @@ def set_equation(filename): NKIEQ = ((line1 - line2 - line3 - line5 - line6 - line7 - line8) - NKI) NKIEQ.write(count, filename) - if test_values: - NKIEQ.test(vars.initialVals) - # print(NKIEQ) + logger.debug(NKIEQ.test(vars.initialVals)) - # NEQ(K,I).. N(K,I) =E= N0(K,I)*(R(K,I)/R0(K,I))**(ETAIX(K,I)); - print('NEQ(K,I)') - line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** ExprM(vars, m=ETAIX.loc[K, I]) + logger.debug('NEQ(K,I)') + line = ExprM(vars, m=N0.loc[K, I]) * (R.loc(K, I) / ExprM(vars, m=R0.loc[K, I])) ** \ + ExprM(vars, m=ETAIX.loc[K, I]) NEQ = (line - N.loc(K, I)) NEQ.write(count, filename) - if test_values: - NEQ.test(vars.initialVals) - # print(NEQ) + logger.debug(NEQ.test(vars.initialVals)) - # CNEQ(I).. P(I)*(1 + SUM(GS, TAUN(GS,I)))*CN(I) - # =E= SUM(IG, B(I,IG)*(SUM(K, N(K,IG)))); - print('CNEQ(I)') + logger.debug('CNEQ(I)') left = P.loc(I) * ExprM(vars, m=1 + TAUN.loc[GS, I].sum(0)) * CN.loc(I) right = (ExprM(vars, m=B.loc[I, IG]) * N.loc(K, IG).sum(K)).sum(IG) CNEQ = (right - left) CNEQ.write(count, filename) - if test_values: - CNEQ.test(vars.initialVals) - # print(CNEQ) + logger.debug(CNEQ.test(vars.initialVals)) - # KSEQ(K,IG).. KS(K,IG) =E= KS0(K,IG) * ( 1 - DEPR) + N(K,IG) ; - print('KSEQ(K,IG)') + logger.debug('KSEQ(K,IG)') line = ExprM(vars, m=KS0.loc[K, IG] * (1 - DEPR)) + N.loc(K, IG) KSEQ = (line - KS.loc(K, IG)) KSEQ.write(count, filename) - if test_values: - KSEQ.test(vars.initialVals) - # print(KSEQ) - - # LSEQ1(H).. HW(H)/HH(H) =E= (HW0(H)/HH0(H)) - # *((SUM(L, RA(L) / RA0(L))/24)/ (CPI(H) / CPI0(H))*(SUM((Z,L), FD(L,Z))/(SUM(H1, HW(H1)* SUM(L, JOBCOR(H1,L)))+ SUM(CM, CMO(CM)) + SUM(L,CMI(L))))+ SUM((CM,L), EXWGEO(CM)/RA0(L))/72 *(SUM(CM, CMO(CM))/(SUM(H1, HW(H1)* SUM(L,JOBCOR(H1,L)))+ SUM(CM, CMO(CM)) +SUM(L,CMI(L)))))** (ETARA(H)) - # * ( SUM(G, TP(H,G) / CPI(H) )/ SUM(G, TP(H,G) / CPI0(H) )) ** ETAPT(H) - # * ((SUM(GI, PIT0(GI,H)* HH0(H))+ SUM(G, TAUH(G,H)*HH0(H)))/(SUM(GI, PIT(GI,H)* HH(H))+ SUM(G, TAUH(G,H)*HH(H))))**(ETAPIT(H)); - print('LSEQ1(H)') + logger.debug(KSEQ.test(vars.initialVals)) + + logger.debug('LSEQ1(H)') line1 = ExprM(vars, m=HW0.loc[H] / HH0.loc[H]) LSEQ1line2pre = FD.loc(L, Z).sum(1) - line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) \ - * (LSEQ1line2pre.sum(0) / ( - (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum(CM) + CMI.loc( - L).sum(L))) \ - + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) \ - * (CMO.loc(CM).sum(CM) / ( - (HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + CMO.loc(CM).sum( - CM) + CMI.loc(L).sum(L))))) \ - ** ExprM(vars, m=ETARA.loc[H]) - line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / ( - ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) - line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + ( - ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) \ - / ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum( - G))) ** ExprM(vars, m=ETAPIT.loc[H]) + line2 = (((RA.loc(L) / ExprM(vars, m=RA0.loc[L])).sum(L) / 24) / (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H])) * + (LSEQ1line2pre.sum(0) / + ((HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + + CMO.loc(CM).sum(CM) + CMI.loc(L).sum(L))) + + (ExprM(vars, m=EXWGEO.loc[CM].sum(0) * RA0.loc[L].sum(0) / 72) * + (CMO.loc(CM).sum(CM) / + ((HW.loc(H1) * ExprM(vars, m=JOBCOR.loc[H1, L].sum(1))).sum(H1) + + CMO.loc(CM).sum(CM) + CMI.loc(L).sum(L))))) ** ExprM(vars, m=ETARA.loc[H]) + line3 = ((ExprM(vars, m=TP.loc[H, G]) / CPI.loc(H)).sum(G) / + (ExprM(vars, m=TP.loc[H, G]) / ExprM(vars, m=CPI0.loc[H])).sum(G)) ** ExprM(vars, m=ETAPT.loc[H]) + line4 = (((ExprM(vars, m=PIT0.loc[GI, H]) * ExprM(vars, m=HH0.loc[H])).sum(GI) + + (ExprM(vars, m=TAUH.loc[G, H]) * ExprM(vars, m=HH0.loc[H])).sum(G)) / + ((ExprM(vars, m=PIT.loc[GI, H]) * HH.loc(H)).sum(GI) + + (ExprM(vars, m=TAUH.loc[G, H]) * HH.loc(H)).sum(G))) ** ExprM(vars, m=ETAPIT.loc[H]) LSEQ1 = ((line1 * line2 * line3 * line4) - HW.loc(H) / HH.loc(H)) LSEQ1.write(count, filename) - if test_values: - LSEQ1.test(vars.initialVals) - # print(LSEQ1) + logger.debug(LSEQ1.test(vars.initialVals)) - # LSEQ2A('OUTCOM1').. CMO('OUTCOM1')=E= CMO0('OUTCOM1')* (Sum((F11,IG), FD(F11,IG))/sum((F11,IG), FD0(F11,IG)))**(-ECOMO('OUTCOM1')) ; - print('LSEQ2A') - line = ExprM(vars, m=CMO0.loc[CM1]) * ( - FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM1])) + logger.debug('LSEQ2A') + line = ExprM(vars, m=CMO0.loc[CM1]) * \ + (FD.loc(F11, IG).sum(IG).sum(F11) / ExprM(vars, m=FD0.loc[F11, IG].sum(1).sum(0))) ** \ + (ExprM(vars, m=(-1) * ECOMO.loc[CM1])) LSEQ2A = (line - CMO.loc(CM1)) LSEQ2A.write(count, filename) - if test_values: - LSEQ2A.test(vars.initialVals) - # print(LSEQ2A) + logger.debug(LSEQ2A.test(vars.initialVals)) - # LSEQ2B('OUTCOM2').. CMO('OUTCOM2')=E= CMO0('OUTCOM2')* (Sum((F21,IG), FD(F21,IG))/sum((F21,IG), FD0(F21,IG)))**(-ECOMO('OUTCOM2')); - print('LSEQ2B') - line = ExprM(vars, m=CMO0.loc[CM2]) * ( - FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM2])) + logger.debug('LSEQ2B') + line = ExprM(vars, m=CMO0.loc[CM2]) * \ + (FD.loc(F21, IG).sum(IG).sum(F21) / ExprM(vars, m=FD0.loc[F21, IG].sum(1).sum(0))) ** \ + (ExprM(vars, m=(-1) * ECOMO.loc[CM2])) LSEQ2B = (line - CMO.loc(CM2)) LSEQ2B.write(count, filename) - if test_values: - LSEQ2B.test(vars.initialVals) - # print(LSEQ2B) + logger.debug(LSEQ2B.test(vars.initialVals)) - # LSEQ2C('OUTCOM3').. CMO('OUTCOM3')=E= CMO0('OUTCOM3')* (sum((F31,IG), FD(F31,IG))/sum((F31,IG), FD0(F31,IG)))** (-ECOMO('OUTCOM3')); - print('LSEQ2C') - line = ExprM(vars, m=CMO0.loc[CM3]) * ( - FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** ( - ExprM(vars, m=(-1) * ECOMO.loc[CM3])) + logger.debug('LSEQ2C') + line = ExprM(vars, m=CMO0.loc[CM3]) * \ + (FD.loc(F31, IG).sum(IG).sum(F31) / ExprM(vars, m=FD0.loc[F31, IG].sum(1).sum(0))) ** \ + (ExprM(vars, m=(-1) * ECOMO.loc[CM3])) LSEQ2C = (line - CMO.loc(CM3)) LSEQ2C.write(count, filename) - if test_values: - LSEQ2C.test(vars.initialVals) - # print(LSEQ2C) + logger.debug(LSEQ2C.test(vars.initialVals)) - # LSEQ3(L).. CMI(L) =E= CMI0(L)* (Sum(FG, FD(L,FG))/Sum(FG, FD0(L,FG)))**(ECOMI(L)); - print('LSEQ3') + logger.debug('LSEQ3') line = ExprM(vars, m=CMI0.loc[L]) * ( (FD.loc(L, FG).sum(FG) / ExprM(vars, m=FD0.loc[L, FG].sum(1))) ** (ExprM(vars, m=ECOMI.loc[L]))) LSEQ3 = (line - CMI.loc(L)) LSEQ3.write(count, filename) - if test_values: - LSEQ3.test(vars.initialVals) - # print(LSEQ3) - - # POPEQ(H).. HH(H) =E= HH0(H) * NRPG(H) - # + MI0(H) * ((YD(H)/HH(H))/(YD0(H)/HH0(H))/(CPI(H)/CPI0(H))) ** (ETAYD(H)) - # *((HN(H)/HH(H))/(HN0(H)/HH0(H))) ** (ETAU(H)) - # *(sum(HSD, CH(HSD,H))/sum(HSD,CH0(HSD,H)))**(1) - # - MO0(H) *((YD0(H)/HH0(H))/(YD(H)/HH(H))/(CPI0(H)/CPI(H))) ** (ETAYD(H)) - # *((HN0(H)/HH0(H))/(HN(H)/HH(H))) ** (ETAU(H)) - # *(sum(HSD, CH0(HSD,H))/sum(HSD,CH(HSD,H)))**(1) ; - - print('POPEQ(H)') + logger.debug(LSEQ3.test(vars.initialVals)) + + logger.debug('POPEQ(H)') line1 = ExprM(vars, m=HH0.loc[H] * NRPG.loc[H]) - line2 = ExprM(vars, m=MI0.loc[H]) * ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / ( - CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) + line2 = ExprM(vars, m=MI0.loc[H]) * \ + ((YD.loc(H) / HH.loc(H)) / ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / + (CPI.loc(H) / ExprM(vars, m=CPI0.loc[H]))) ** ExprM(vars, m=ETAYD.loc[H]) line3 = ((HN.loc(H) / HH.loc(H)) / ExprM(vars, m=HN0.loc[H] / HH0.loc[H])) ** ExprM(vars, m=ETAU.loc[H]) line4 = (CH.loc(HSD, H).sum(HSD) / ExprM(vars, m=CH0.loc[HSD, H].sum(0))) ** (1) - line5 = ExprM(vars, m=MO0.loc[H]) * (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / ( - ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) + line5 = ExprM(vars, m=MO0.loc[H]) * \ + (ExprM(vars, m=YD0.loc[H] / HH0.loc[H]) / (YD.loc(H) / HH.loc(H)) / + (ExprM(vars, m=CPI0.loc[H]) / CPI.loc(H))) ** ExprM(vars, m=ETAYD.loc[H]) line6 = (ExprM(vars, m=HN0.loc[H] / HH0.loc[H]) / (HN.loc(H) / HH.loc(H))) ** ExprM(vars, m=ETAU.loc[H]) - line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** (1) + line7 = (ExprM(vars, m=CH0.loc[HSD, H].sum(0)) / CH.loc(HSD, H).sum(HSD)) ** 1 POPEQ = (line1 + line2 * line3 * line4 - line5 * line6 * line7 - HH.loc(H)) POPEQ.write(count, filename) - if test_values: - POPEQ.test(vars.initialVals) - # print(POPEQ) + logger.debug(POPEQ.test(vars.initialVals)) - # ANEQ(H).. HN(H) =E= HH(H) - HW(H); - print('ANEQ(H)') + logger.debug('ANEQ(H)') line = HH.loc(H) - HW.loc(H) ANEQ = (line - HN.loc(H)) ANEQ.write(count, filename) - if test_values: - ANEQ.test(vars.initialVals) - # print(ANEQ) - - # YGEQ(GX).. Y(GX) =E= SUM(I, TAUV(GX,I) * V(I) * P(I) ) - # + SUM(I, TAUX(GX,I)* CX(I) *PD(I)) - # + SUM((H,I), TAUC(GX,I) * CH(I,H) * P(I) ) - # + SUM(I, TAUN(GX,I) * CN(I) * P(I) ) - # + SUM((GN,I), TAUG(GX,I) * CG(I,GN) * P(I) ) - # + SUM((F,I), TAUFX(GX,F,I) * RA(F) * R(F,I) * TT(F,I)*FD(F,I) ) - # + SUM((F,GN), TAUFX(GX,F,GN) * RA(F) * R(F,GN) * FD(F,GN) ) - # + SUM(F, TAUFH(GX,F) * (Y(F))) - # + SUM(H, PIT0(GX,H) * Y(H) ) - # + SUM(H, TAUH(GX,H) * HH(H) ) - # + SUM(GX1, IGT(GX,GX1)); - print('YGEQ') + logger.debug(ANEQ.test(vars.initialVals)) + + logger.debug('YGEQ') line1 = (ExprM(vars, m=TAUV.loc[GX, I]) * V.loc(I) * P.loc(I)).sum(I) line2 = (ExprM(vars, m=TAUX.loc[GX, I]) * CX.loc(I) * PD.loc(I)).sum(I) - YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) # first just set it to correct size + # first just set it to correct size + YGEQline3pre = ExprM(vars, m=pd.DataFrame(index=GX, columns=H).fillna(0.0)) for label in GX: for hlabel in H: - YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = Expr( - (ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) + YGEQline3pre.m[GX.index(label)][H.index(hlabel)] = \ + Expr((ExprM(vars, m=TAUC.loc[[label], I]) * CH.loc(I, [hlabel]) * P.loc(I)).sum().m[0][0]) line3 = YGEQline3pre.sum(1) line4 = (ExprM(vars, m=TAUN.loc[GX, I]) * CN.loc(I) * P.loc(I)).sum(I) YGEQline5pre = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) # first just set it to correct size for label in GX: - YGEQline5pre.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) + YGEQline5pre.m[GX.index(label)][0] = \ + Expr((ExprM(vars, m=TAUG.loc[[label], I]) * CG.loc(I, GN) * P.loc(I)).sum().m[0][0]) line5 = YGEQline5pre line6 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) for label in GX: - line6.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) + line6.m[GX.index(label)][0] = \ + Expr((ExprM(vars, m=TAUFXgx[label].loc[F, I]) * RA.loc(F) * + R.loc(F, I) * FD.loc(F, I)).sum().m[0][0]) line7 = ExprM(vars, m=TAUG.loc[GX, I]).sum(I) for label in GX: - line7.m[GX.index(label)][0] = Expr( - (ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) + line7.m[GX.index(label)][0] = \ + Expr((ExprM(vars, m=TAUFXgx[label].loc[F, GN]) * RA.loc(F) * + R.loc(F, GN) * FD.loc(F, GN)).sum().m[0][0]) line8 = (ExprM(vars, m=TAUFH.loc[GX, F]) * Y.loc(F)).sum(F) line9 = (ExprM(vars, m=PIT0.loc[GX, H]) * Y.loc(H)).sum(H) line10 = (ExprM(vars, m=TAUH.loc[GX, H]) * HH.loc(H)).sum(H) line11 = IGT.loc(GX, GX1).sum(1) - YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - Y.loc(GX)) + YGEQ = ((line1 + line2 + line3 + line4 + line5 + line6 + line7 + line8 + line9 + line10 + line11) - + Y.loc(GX)) YGEQ.write(count, filename) - if test_values: - YGEQ.test(vars.initialVals) - # print(YGEQ) + logger.debug(YGEQ.test(vars.initialVals)) - # YGEQ2(GT).. Y(GT) =E= SUM(GX, IGT(GT,GX)); - print('YGEQ2(GT)') + logger.debug('YGEQ2(GT)') line = IGT.loc(GT, GX).sum(GX) YGEQ2 = (line - Y.loc(GT)) YGEQ2.write(count, filename) if test_values: YGEQ2.test(vars.initialVals) - # print(YGEQ2) - # YGEQM(GNLM).. Y(GNLM) =E= TAXS1(GNLM)*Y('CYGFM'); - print('YGEQM(GNLM)') + logger.debug('YGEQM(GNLM)') line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) YGEQM = (line - Y.loc(GNLM)) YGEQM.write(count, filename) - if test_values: - YGEQM.test(vars.initialVals) - # print(YGEQM) + logger.debug(YGEQM.test(vars.initialVals)) - # YGEQO(GNLO).. Y(GNLO) =E= TAXS2(GNLO)*Y('CYGFO'); - print('YGEQO(GNLO)') + logger.debug('YGEQO(GNLO)') line = ExprM(vars, m=TAXS2.loc[GNLO]) * Y.loc(['CYGFO']) YGEQO = (line - Y.loc(GNLO)) YGEQO.write(count, filename) - if test_values: - YGEQO.test(vars.initialVals) - # print(YGEQ1) + logger.debug(YGEQO.test(vars.initialVals)) - # GOVFOR(G).. GVFOR(G) =E= GFOR(G)*Y(G); - print('GOVFOR(G)') + logger.debug('GOVFOR(G)') line = ExprM(vars, m=GFOR.loc[G]) * Y.loc(G) GOVFOR = (line - GVFOR.loc(G)) GOVFOR.write(count, filename) - if test_values: - GOVFOR.test(vars.initialVals) - # print(GOVFOR) + logger.debug(GOVFOR.test(vars.initialVals)) - # CGEQ(I,GN).. P(I)*(1 + SUM(GS, TAUG(GS,I))) * CG(I,GN) - # =E= AG(I,GN) * (Y(GN)+ GFOR(GN)*Y(GN)); - print('CGEQ(I,GN)') + logger.debug('CGEQ(I,GN)') left = P.loc(I) * ExprM(vars, m=1 + TAUG.loc[GS, I].sum(0)) * CG.loc(I, GN) right = ExprM(vars, m=AG.loc[I, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) CGEQ = (right - left) CGEQ.write(count, filename) - if test_values: - CGEQ.test(vars.initialVals) - # print(CGEQ) + logger.debug(CGEQ.test(vars.initialVals)) - # GFEQ(F,GN).. FD(F,GN) * R(F,GN) * RA(F)*( 1 + SUM(GF, TAUFX(GF,F,GN))) - # =E= AG(F,GN) * (Y(GN)+ GFOR(GN)*Y(GN)); - print('GFEQ(F,GN)') + logger.debug('GFEQ(F,GN)') left = FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN])) right = ExprM(vars, m=AG.loc[F, GN]) * (Y.loc(GN) + ExprM(vars, m=GFOR.loc[GN]) * Y.loc(GN)) GFEQ = left - right GFEQ.write(count, filename) - if test_values: - GFEQ.test(vars.initialVals) - # print(GFEQ) + logger.debug(GFEQ.test(vars.initialVals)) - # GSEQL(GN).. S(GN) =E= (Y(GN)+ GVFOR(GN)) - # - SUM(I, CG(I,GN)*P(I)*(1 + SUM(GS, TAUG(GS,I)))) - # - SUM(F, FD(F,GN)*R(F,GN)*RA(F)*(1 + SUM(GF, TAUFX(GF,F,GN)))); - print('GSEQL(GN)') + logger.debug('GSEQL(GN)') line1 = Y.loc(GN) + GVFOR.loc(GN) line2 = (CG.loc(I, GN) * P.loc(I) * (1 + ExprM(vars, m=TAUG.loc[GS, I]).sum(GS))).sum(I) line3 = (FD.loc(F, GN) * R.loc(F, GN) * RA.loc(F) * (1 + ExprM(vars, m=TAUFX_SUM.loc[F, GN]))).sum(F) GSEQL = ((line1 - ~line2 - ~line3) - S.loc(GN)) GSEQL.write(count, filename) - if test_values: - GSEQL.test(vars.initialVals) - # print(GSEQL) + logger.debug(GSEQL.test(vars.initialVals)) - # GSEQ(GX).. S(GX) =E= (Y(GX) + GFOR(GX)*Y(GX)) - SUM(H, (TP(H,GX)*HH(H))) - SUM(G,IGT(G,GX)); - print('GSEQ(GX)') + logger.debug('GSEQ(GX)') line1 = (Y.loc(GX) + ExprM(vars, m=GFOR.loc[GX]) * Y.loc(GX)) line2 = (ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H) line3 = IGT.loc(G, GX).sum(G) GSEQ = ((line1 - ~line2 - ~line3) - S.loc(GX)) GSEQ.write(count, filename) - if test_values: - GSEQ.test(vars.initialVals) - # print(GSEQ) + logger.debug(GSEQ.test(vars.initialVals)) - # TDEQ(G,GX)$(IGTD(G,GX) EQ 1).. IGT(G,GX) - # =E= TAXS(G,GX)*(Y(GX) + GVFOR(GX)- SUM(H, (TP(H,GX)*HH(H)))); - print('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') - line = ExprM(vars, m=TAXS.loc[G, GX]) * ( - Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) + logger.debug('TDEQ(G,GX)$(IGTD(G,GX) EQ 1)') + line = ExprM(vars, m=TAXS.loc[G, GX]) * \ + (Y.loc(GX) + GVFOR.loc(GX) - ~(ExprM(vars, m=TP.loc[H, GX]) * HH.loc(H)).sum(H)) TDEQ = line - IGT.loc(G, GX) TDEQ.setCondition(IGTD.loc[G, GX], 'EQ', 1) TDEQ.write(count, filename) - if test_values: - TDEQ.test(vars.initialVals) - # print(TDEQ) + logger.debug(TDEQ.test(vars.initialVals)) - # SPIEQ.. SPI =E= SUM(H, Y(H)) + SUM((H,G), TP(H,G)*HH(H)) + SUM(H, PRIVRET(H)*HH(H)); - print('SPIEQ') - line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + ( - ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) + logger.debug('SPIEQ') + line = Y.loc(H).sum(H) + (ExprM(vars, m=TP.loc[H, G]) * HH.loc(H)).sum() + \ + (ExprM(vars, m=PRIVRET.loc[H]) * HH.loc(H)).sum(H) SPIEQ = (line - SPI) SPIEQ.write(count, filename) - if test_values: - SPIEQ.test(vars.initialVals) - # print(SPIEQ) + logger.debug(SPIEQ.test(vars.initialVals)) - # LMEQ1(L).. SUM(H, HW(H)* JOBCOR(H, L))+CMI(L) =E= SUM(Z, FD(L ,Z) ) ; - print('LMEQ1(L)') + logger.debug('LMEQ1(L)') left = (ExprM(vars, m=JOBCOR.loc[H, L]) * HW.loc(H)).sum(H) + CMI.loc(L) right = FD.loc(L, Z).sum(Z) LMEQ1 = (right - left) LMEQ1.write(count, filename) - if test_values: - LMEQ1.test(vars.initialVals) - # print(LMEQ1) + logger.debug(LMEQ1.test(vars.initialVals)) - # KMEQ(K,IG).. KS(K,IG) =E= TT(K,IG)*FD(K,IG); - print('KMEQ(K,IG)') + logger.debug('KMEQ(K,IG)') KMEQ = ((ExprM(vars, m=TT.loc[K, IG]) * FD.loc(K, IG)) - KS.loc(K, IG)) KMEQ.write(count, filename) - if test_values: - KMEQ.test(vars.initialVals) - # print(KMEQ) + logger.debug(KMEQ.test(vars.initialVals)) - # GMEQ(I).. DS(I) =E= DD(I) + CX(I) - M(I); - print('GMEQ(I)') + logger.debug('GMEQ(I)') GMEQ = (DD.loc(I) + CX.loc(I) - M.loc(I) - DS.loc(I)) GMEQ.write(count, filename) - if test_values: - GMEQ.test(vars.initialVals) - # print(GMEQ) + logger.debug(GMEQ.test(vars.initialVals)) - # DDEQ(I).. DD(I) =E= V(I) + SUM(H, CH(I,H) ) + SUM(G, CG(I,G) ) + CN(I); - print('DDEQ(I)') + logger.debug('DDEQ(I)') DDEQ = (V.loc(I) + CH.loc(I, H).sum(H) + CG.loc(I, G).sum(G) + CN.loc(I) - DD.loc(I)) DDEQ.write(count, filename) - if test_values: - DDEQ.test(vars.initialVals) - # print(DDEQ) + logger.debug(DDEQ.test(vars.initialVals)) # ------------------------------------------------------------------------------------------------------------- # MODEL CLOSURE # ------------------------------------------------------------------------------------------------------------- - # FIX INTER GOVERNMENTAL TRANSFERS TO ZERO IF NOT IN ORIGINAL SAM - # IGT.FX(G,GX)$(NOT IGT0(G,GX))=0; - print('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') + logger.debug('IGT.FX(G,GX)$(NOT IGT0(G,GX))=0') FX1 = IGT.loc(G, GX) FX1.setCondition(IGT0.loc[G, GX], 'EQ', 0) FX1.write(count, filename) - # print(FX1) # FIX EXOGENOUS INTERGOVERNMENTAL TRANSFERS - # IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX); - print('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') + logger.debug('IGT.FX(G,GX)$(IGTD(G,GX) EQ 2)=IGT0(G,GX)') FX2 = IGT.loc(G, GX) - ExprM(vars, m=IGT0.loc[G, GX]) FX2.setCondition(IGTD.loc[G, GX], 'EQ', 2) FX2.write(count, filename) - # print(FX2) # FIX INTER SECTORAL WAGE DIFFERENTIALS - # R.FX(L,Z) = R0(L,Z); - print('R.FX(L,Z)=R0(L,Z)') + logger.debug('R.FX(L,Z)=R0(L,Z)') FX3 = R.loc(L, Z) - ExprM(vars, m=R0.loc[L, Z]) FX3.write(count, filename) - # print(FX3) # FIX ECONOMY WIDE SCALAR - # RA.FX(K) = RA0(K); - print('RA.FX(K)=RA0(K)') + logger.debug('RA.FX(K)=RA0(K)') FX4 = RA.loc(K) - ExprM(vars, m=RA0.loc[K]) FX4.write(count, filename) - # print(FX5) - print("Objective") + logger.debug("Objective") obj = vars.getIndex('SPI') with open(filename, 'a') as f: f.write('model.obj = Objective(expr=-1*model.x' + str(obj) + ')') def run_solver(cons_filename, temp_file_name="tmp.py"): + logger.info("running solver...") solver = 'ipopt' solver_io = 'nl' - stream_solver = True # True prints solver output to screen + stream_solver = self.get_parameter("print_solver_output") \ + if self.get_parameter("print_solver_output") is not None else False # print solver output if True keepfiles = False # True prints intermediate file names (.nl,.sol,...) - opt = SolverFactory(solver, solver_io=solver_io) + + executable_path = self.get_parameter("solver_path") \ + if self.get_parameter("solver_path") is not None else pyglobals.IPOPT_PATH + if not os.path.exists(executable_path): + print("Invalid executable path, please make sure you have Pyomo installed.") + + opt = SolverFactory(solver, solver_io=solver_io, executable=executable_path) if opt is None: - print("") - print("ERROR: Unable to create solver plugin for %s " \ + logger.error("ERROR: Unable to create solver plugin for %s " \ "using the %s interface" % (solver, solver_io)) - print("") exit(1) # Create the model @@ -2207,7 +1896,7 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): # The solver plugin will scan the model for all active suffixes # valid for importing, which it will store into the results object - results = opt.solve(model, keepfiles=keepfiles, tee=stream_solver) + opt.solve(model, keepfiles=keepfiles, tee=stream_solver) x = [None for i in range(vars.nvars)] @@ -2226,11 +1915,20 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): Calibrate the model ''' soln = [] - # filename = os.path.join(filePath, "ipopt_cons.py") - filename = 'ipopt_cons.py' - # tmp = os.path.join(filePath, "tmp.py") - tmp = 'tmp.py' - print("Calibration: ") + + # create CGE tmp folder, solverconstants + # TODO: we need to generate the "solverconstatnt" folder with username since it uses system tmp + # TODO: there is a situation that multiple users on system can run this together + + cge_tmp_folder = os.path.join(tempfile.gettempdir(), "solverconstants") + if not os.path.isdir(cge_tmp_folder): # create the folder if there is no folder + os.mkdir(cge_tmp_folder) + logger.debug(cge_tmp_folder) + + filename = os.path.join(cge_tmp_folder, "ipopt_cons.py") + tmp = os.path.join(cge_tmp_folder, "tmp.py") + + logger.info("Calibration: ") run_solver(filename, tmp) ''' @@ -2243,21 +1941,17 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): ''' - ############ begin shock by using tables - - # iNum = 1 # dynamic model itterations - - sims = pd.read_csv(os.path.join(filePath, 'SIMS 500.csv'), index_col=0) + # begin shock by using tables + sims = pd.read_csv(self.get_input_dataset("SIMS").get_file_path('csv'), index_col=0) iNum = 1 - # iNum = len(sims.columns) KS00 = KS0.copy() for num in range(iNum): - # print("Simulation: ", num+1) KS0.loc[K, I] = KS00.loc[K, I].mul(sims.iloc[:, num]) run_solver(filename, tmp) # create output + logger.info("Create sims") CG0 = vars.get('CG', x=soln[0]) CH0 = vars.get('CH', x=soln[0]) CMI0 = vars.get('CMI', x=soln[0]) @@ -2271,14 +1965,12 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): FD0 = vars.get('FD', x=soln[0]) IGT0 = vars.get('IGT', x=soln[0]) KS0 = vars.get('KS', x=soln[0]) - #LAS0 = vars.get('LAS', x=soln[0]) HH0 = vars.get('HH', x=soln[0]) HN0 = vars.get('HN', x=soln[0]) HW0 = vars.get('HW', x=soln[0]) M0 = vars.get('M', x=soln[0]) N0 = vars.get('N', x=soln[0]) NKI0 = vars.get('NKI', x=soln[0]) - #LNFOR0 = vars.get('LNFOR', x=soln[0]) KPFOR0 = vars.get('KPFOR', x=soln[0]) GVFOR0 = vars.get('GVFOR', x=soln[0]) P0 = vars.get('P', x=soln[0]) @@ -2320,7 +2012,6 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): ML = vars.get('M', x=soln[i+1]) NL = vars.get('N', x=soln[i+1]) NKIL = vars.get('NKI', x=soln[i+1]) - #LNFORL = vars.get('LNFOR', x=soln[i+1]) KPFORL = vars.get('KPFOR', x=soln[i+1]) GVFORL = vars.get('GVFOR', x=soln[i+1]) PL = vars.get('P', x=soln[i+1]) @@ -2374,12 +2065,89 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): cols = {'dsc': dsclist, 'dsr': dsrlist, 'mig': miglist, 'emp': emplist, 'hhinc': hhinclist} - df = pd.DataFrame.from_dict(cols) - df.to_csv('simulation_outputs.csv') - print("simulation_outpus.csv has been created.") - - -if __name__ == '__main__': - is_cd = False - test_values = False - main_calc(is_cd, test_values) \ No newline at end of file + sims_result = pd.DataFrame.from_dict(cols) + + self.set_result_csv_data("Shelby_sims", sims_result, name="Shelby_sims", source="dataframe") + logger.info("Output sims has been created.") + + # Prepare cge output + total_employment_original = FD0.loc[L, I].sum(0).sum(0) + total_employment_change = vars.get('FD', x=soln[-1]).loc[L, I].sum(0).sum(0) - total_employment_original + total_employment_percentage = total_employment_change / total_employment_original + + domestic_supply_original = DS0.sum(0) + domestic_supply_change = vars.get('DS', x=soln[-1]).sum(0) - domestic_supply_original + domestic_supply_percentage = domestic_supply_change / domestic_supply_original + + DY = vars.get('Y', x=soln[-1]) - Y0 + DY.loc[H] = pd.Series(vars.get('Y', x=soln[-1]).loc[H] / vars.get('CPI', x=soln[-1]).loc[H] - Y0.loc[H]) + + HH1_change = DY['HH1'] + HH1_percentage = HH1_change / Y0.loc['HH1'] + + HH2_change = DY['HH2'] + HH2_percentage = HH2_change / Y0.loc['HH2'] + + HH3_change = DY.loc['HH3'] + HH3_percentage = HH3_change / Y0.loc['HH3'] + + HH4_change = DY.loc['HH4'] + HH4_percentage = HH4_change / Y0.loc['HH4'] + + HH5_change = DY.loc['HH5'] + HH5_percentage = HH5_change / Y0.loc['HH5'] + + HH_total_change = HH1_change + HH2_change + HH3_change + HH4_change + HH5_change + HH_total_original = Y0.loc[H].sum(0) + HH_total_percentage = HH_total_change / HH_total_original + + LOCTAX_original = Y0.loc['LOCTAX'] + LOCTAX_change = DY.loc['LOCTAX'] + LOCTAX_percentage = LOCTAX_change / LOCTAX_original + + PROPTX_original = Y0.loc['PROPTX'] + PROPTX_change = DY.loc['PROPTX'] + PROPTX_percentage = PROPTX_change / PROPTX_original + + ACCTAX_original = Y0.loc['ACCTAX'] + ACCTAX_change = DY.loc['ACCTAX'] + ACCTAX_percentage = ACCTAX_change / ACCTAX_original + + TAX_total_change = LOCTAX_change + PROPTX_change + ACCTAX_change + TAX_total_original = LOCTAX_original + PROPTX_original + ACCTAX_original + TAX_total_percentage = TAX_total_change / TAX_total_original + + cge_output = pd.DataFrame({'Seaside': ['Total Employment', 'Domestic Supply($)', + 'Real Household Income($)', 'HH1', 'HH2', 'HH3', 'HH4', 'HH5', + 'Total', + 'Local Tax Revenue($)', 'LOCTAX', 'PROPTX', 'ACCTAX', + 'Total'], + 'Amount of Change': ['{:.2f}'.format(total_employment_change), + '{:.2f}'.format(domestic_supply_change), '', + '{:.2f}'.format(HH1_change), '{:.2f}'.format(HH2_change), + '{:.2f}'.format(HH3_change), '{:.2f}'.format(HH4_change), + '{:.2f}'.format(HH5_change), + '{:.2f}'.format(HH_total_change), + '', + '{:.2f}'.format(LOCTAX_change), + '{:.2f}'.format(PROPTX_change), + '{:.2f}'.format(ACCTAX_change), + '{:.2f}'.format(TAX_total_change)], + 'Percent Change': ['{:.2f}%'.format(total_employment_percentage * 100), + '{:.2f}%'.format(domestic_supply_percentage * 100), '', + '{:.2f}%'.format(HH1_percentage * 100), + '{:.2f}%'.format(HH2_percentage * 100), + '{:.2f}%'.format(HH3_percentage * 100), + '{:.2f}%'.format(HH4_percentage * 100), + '{:.2f}%'.format(HH5_percentage * 100), + '{:.2f}%'.format(HH_total_percentage * 100), '', + '{:.2f}%'.format(LOCTAX_percentage * 100), + '{:.2f}%'.format(PROPTX_percentage * 100), + '{:.2f}%'.format(ACCTAX_percentage * 100), + '{:.2f}%'.format(TAX_total_percentage * 100)] + }) + + self.set_result_csv_data("Shelby_output", cge_output, name="Shelby_output", source="dataframe") + logger.info("CGE output has been created.") + + return True \ No newline at end of file diff --git a/tests/pyincore/analyses/shelbycge/test_shelbycge.py b/tests/pyincore/analyses/shelbycge/test_shelbycge.py index 323625d2d..5001e68a8 100644 --- a/tests/pyincore/analyses/shelbycge/test_shelbycge.py +++ b/tests/pyincore/analyses/shelbycge/test_shelbycge.py @@ -18,7 +18,6 @@ def run_base_analysis(): jobcr = "630e5c59c8f8b7614f6e5c86" hhtable = "630e5d08c8f8b7614f6e5c8e" sims = "630e5e0bc8f8b7614f6e5c96" - # sector_shocks = "5f6123e35060967d84ab0f70" shelby_cge.set_parameter("print_solver_output", False) @@ -28,7 +27,6 @@ def run_base_analysis(): shelby_cge.load_remote_input_dataset("JOBCR", jobcr) shelby_cge.load_remote_input_dataset("HHTABLE", hhtable) shelby_cge.load_remote_input_dataset("SIMS", sims) - # seaside_cge.load_remote_input_dataset("sector_shocks", sector_shocks) shelby_cge.run_analysis() From 52cba465be09d342992fe9e6ba9d63ad35d7602b Mon Sep 17 00:00:00 2001 From: Yong Wook Kim Date: Wed, 31 Aug 2022 15:20:20 -0500 Subject: [PATCH 6/8] added cd / ces selector --- pyincore/analyses/shelbycge/equationlib.py | 11 +++++------ pyincore/analyses/shelbycge/shelbycge.py | 17 ++++++++++------- 2 files changed, 15 insertions(+), 13 deletions(-) diff --git a/pyincore/analyses/shelbycge/equationlib.py b/pyincore/analyses/shelbycge/equationlib.py index 27c8fb8d4..85586f472 100755 --- a/pyincore/analyses/shelbycge/equationlib.py +++ b/pyincore/analyses/shelbycge/equationlib.py @@ -828,9 +828,8 @@ def write(self, count, filename): f.close() def test(self,x): - print("test") - # for i in range(self.info['height']): - # for j in range(self.info['width']): - # if not self.hasCondition or self.hasCondition and self.mark[i][j]: - # fun = lambda x: eval( self.m[i][j].debug_test_str() ) - # logger.debug(i,j,fun(x)) + for i in range(self.info['height']): + for j in range(self.info['width']): + if not self.hasCondition or self.hasCondition and self.mark[i][j]: + fun = lambda x: eval( self.m[i][j].debug_test_str() ) + logger.debug(i,j,fun(x)) diff --git a/pyincore/analyses/shelbycge/shelbycge.py b/pyincore/analyses/shelbycge/shelbycge.py index 62baf4f9c..dfe2e0f55 100644 --- a/pyincore/analyses/shelbycge/shelbycge.py +++ b/pyincore/analyses/shelbycge/shelbycge.py @@ -52,9 +52,11 @@ def get_spec(self): 'type': str }, { - 'id': 'value_tests', + 'id': 'is_cd_model', 'required': False, - 'description': 'Boolean for testing the values', + 'description': 'Boolean for running either CD (Cobb Douglas) or CES. If it is true, ' + 'it will be CD other wise CES will be selected. ' + 'The default is True so it will run CD as a default.', 'type': bool } ], @@ -118,8 +120,11 @@ def get_spec(self): } def run(self): - test_values=False + # decide if the model is CD or CES is_cd=True + if self.get_parameter("is_cd_model") is not None: + is_cd = self.get_parameter("is_cd_model") + def _(x): return ExprM(vars, m=x) @@ -1418,8 +1423,7 @@ def set_equation(filename): (Y.loc(K) + KPFOR.loc(K)) * ExprM(vars, m=1 - TAUFK.loc[G, K].sum(0))).sum(K) YEQ = ((line1 + line2 + line4) - Y.loc(H)) - if test_values: - YEQ.test(vars.initialVals) + logger.debug(YEQ.test(vars.initialVals)) YEQ.write(count, filename) @@ -1713,8 +1717,7 @@ def set_equation(filename): YGEQ2 = (line - Y.loc(GT)) YGEQ2.write(count, filename) - if test_values: - YGEQ2.test(vars.initialVals) + logger.debug(YGEQ2.test(vars.initialVals)) logger.debug('YGEQM(GNLM)') line = ExprM(vars, m=TAXS1.loc[GNLM]) * Y.loc(['CYGFM']) From cc3948bbb8078fb4fbc7010eebe2eab3903c86a3 Mon Sep 17 00:00:00 2001 From: Yong Wook Kim Date: Wed, 31 Aug 2022 15:37:13 -0500 Subject: [PATCH 7/8] removed unnecessary lines --- pyincore/analyses/shelbycge/shelbycge.py | 80 ------------------- .../analyses/shelbycge/test_shelbycge.py | 1 + 2 files changed, 1 insertion(+), 80 deletions(-) diff --git a/pyincore/analyses/shelbycge/shelbycge.py b/pyincore/analyses/shelbycge/shelbycge.py index dfe2e0f55..5b1088d29 100644 --- a/pyincore/analyses/shelbycge/shelbycge.py +++ b/pyincore/analyses/shelbycge/shelbycge.py @@ -2073,84 +2073,4 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): self.set_result_csv_data("Shelby_sims", sims_result, name="Shelby_sims", source="dataframe") logger.info("Output sims has been created.") - # Prepare cge output - total_employment_original = FD0.loc[L, I].sum(0).sum(0) - total_employment_change = vars.get('FD', x=soln[-1]).loc[L, I].sum(0).sum(0) - total_employment_original - total_employment_percentage = total_employment_change / total_employment_original - - domestic_supply_original = DS0.sum(0) - domestic_supply_change = vars.get('DS', x=soln[-1]).sum(0) - domestic_supply_original - domestic_supply_percentage = domestic_supply_change / domestic_supply_original - - DY = vars.get('Y', x=soln[-1]) - Y0 - DY.loc[H] = pd.Series(vars.get('Y', x=soln[-1]).loc[H] / vars.get('CPI', x=soln[-1]).loc[H] - Y0.loc[H]) - - HH1_change = DY['HH1'] - HH1_percentage = HH1_change / Y0.loc['HH1'] - - HH2_change = DY['HH2'] - HH2_percentage = HH2_change / Y0.loc['HH2'] - - HH3_change = DY.loc['HH3'] - HH3_percentage = HH3_change / Y0.loc['HH3'] - - HH4_change = DY.loc['HH4'] - HH4_percentage = HH4_change / Y0.loc['HH4'] - - HH5_change = DY.loc['HH5'] - HH5_percentage = HH5_change / Y0.loc['HH5'] - - HH_total_change = HH1_change + HH2_change + HH3_change + HH4_change + HH5_change - HH_total_original = Y0.loc[H].sum(0) - HH_total_percentage = HH_total_change / HH_total_original - - LOCTAX_original = Y0.loc['LOCTAX'] - LOCTAX_change = DY.loc['LOCTAX'] - LOCTAX_percentage = LOCTAX_change / LOCTAX_original - - PROPTX_original = Y0.loc['PROPTX'] - PROPTX_change = DY.loc['PROPTX'] - PROPTX_percentage = PROPTX_change / PROPTX_original - - ACCTAX_original = Y0.loc['ACCTAX'] - ACCTAX_change = DY.loc['ACCTAX'] - ACCTAX_percentage = ACCTAX_change / ACCTAX_original - - TAX_total_change = LOCTAX_change + PROPTX_change + ACCTAX_change - TAX_total_original = LOCTAX_original + PROPTX_original + ACCTAX_original - TAX_total_percentage = TAX_total_change / TAX_total_original - - cge_output = pd.DataFrame({'Seaside': ['Total Employment', 'Domestic Supply($)', - 'Real Household Income($)', 'HH1', 'HH2', 'HH3', 'HH4', 'HH5', - 'Total', - 'Local Tax Revenue($)', 'LOCTAX', 'PROPTX', 'ACCTAX', - 'Total'], - 'Amount of Change': ['{:.2f}'.format(total_employment_change), - '{:.2f}'.format(domestic_supply_change), '', - '{:.2f}'.format(HH1_change), '{:.2f}'.format(HH2_change), - '{:.2f}'.format(HH3_change), '{:.2f}'.format(HH4_change), - '{:.2f}'.format(HH5_change), - '{:.2f}'.format(HH_total_change), - '', - '{:.2f}'.format(LOCTAX_change), - '{:.2f}'.format(PROPTX_change), - '{:.2f}'.format(ACCTAX_change), - '{:.2f}'.format(TAX_total_change)], - 'Percent Change': ['{:.2f}%'.format(total_employment_percentage * 100), - '{:.2f}%'.format(domestic_supply_percentage * 100), '', - '{:.2f}%'.format(HH1_percentage * 100), - '{:.2f}%'.format(HH2_percentage * 100), - '{:.2f}%'.format(HH3_percentage * 100), - '{:.2f}%'.format(HH4_percentage * 100), - '{:.2f}%'.format(HH5_percentage * 100), - '{:.2f}%'.format(HH_total_percentage * 100), '', - '{:.2f}%'.format(LOCTAX_percentage * 100), - '{:.2f}%'.format(PROPTX_percentage * 100), - '{:.2f}%'.format(ACCTAX_percentage * 100), - '{:.2f}%'.format(TAX_total_percentage * 100)] - }) - - self.set_result_csv_data("Shelby_output", cge_output, name="Shelby_output", source="dataframe") - logger.info("CGE output has been created.") - return True \ No newline at end of file diff --git a/tests/pyincore/analyses/shelbycge/test_shelbycge.py b/tests/pyincore/analyses/shelbycge/test_shelbycge.py index 5001e68a8..2f2f978f0 100644 --- a/tests/pyincore/analyses/shelbycge/test_shelbycge.py +++ b/tests/pyincore/analyses/shelbycge/test_shelbycge.py @@ -20,6 +20,7 @@ def run_base_analysis(): sims = "630e5e0bc8f8b7614f6e5c96" shelby_cge.set_parameter("print_solver_output", False) + shelby_cge.set_parameter("is_cd_model", False) shelby_cge.load_remote_input_dataset("SAM", sam) shelby_cge.load_remote_input_dataset("BB", bb) From f8f14c168fb25a410141ff86040a11e5d0a027e8 Mon Sep 17 00:00:00 2001 From: Yong Wook Kim Date: Thu, 3 Nov 2022 12:40:33 -0500 Subject: [PATCH 8/8] added more result files outputs --- pyincore/analyses/shelbycge/shelbycge.py | 97 +++++++++++++++--------- 1 file changed, 61 insertions(+), 36 deletions(-) diff --git a/pyincore/analyses/shelbycge/shelbycge.py b/pyincore/analyses/shelbycge/shelbycge.py index 5b1088d29..f18d0bfe5 100644 --- a/pyincore/analyses/shelbycge/shelbycge.py +++ b/pyincore/analyses/shelbycge/shelbycge.py @@ -105,16 +105,34 @@ def get_spec(self): ], 'output_datasets': [ { - 'id': 'Shelby_sims', + 'id': 'domestic-supply', 'parent_type': '', - 'description': 'CSV file of Seaside cge simulations', - 'type': 'incore:ShelbyCGEsims' + 'description': 'CSV file of resulting domestic supply', + 'type': 'incore:Employment' }, { - 'id': 'Shelby_output', + 'id': 'gross-income', 'parent_type': '', - 'description': 'CSV file of output of Seaside cge, containing changes in employment and supply.', - 'type': 'incore:ShelbyCGEEmployDS' + 'description': 'CSV file of resulting gross income', + 'type': 'incore:Employment' + }, + { + 'id': 'pre-disaster-factor-demand', + 'parent_type': '', + 'description': 'CSV file of factor demand before disaster', + 'type': 'incore:FactorDemand' + }, + { + 'id': 'post-disaster-factor-demand', + 'parent_type': '', + 'description': 'CSV file of resulting factor-demand', + 'type': 'incore:FactorDemand' + }, + { + 'id': 'household-count', + 'parent_type': '', + 'description': 'CSV file of household count', + 'type': 'incore:HouseholdCount' } ] } @@ -2044,33 +2062,40 @@ def run_solver(cons_filename, temp_file_name="tmp.py"): DN = NL - N0 s_name = 'Simulation ' + str(i+1) - - emp = DFFD[DFFD.index.isin(['L1A', 'L2A', 'L3A', 'L1B', 'L2B', 'L3B', 'L1C', 'L2C', 'L3C', \ - 'L1D', 'L2D', 'L3D', 'L1E', 'L2E', 'L3E', 'L1F', 'L2F', 'L3F', \ - 'L1G', 'L2G', 'L3G', 'L1H', 'L2H', 'L3H'])].sum().sum() - dsr = DDS[DDS.index.isin(['HS1A', 'HS1B', 'HS1C', 'HS1D', 'HS1E', 'HS1F', 'HS1G', 'HS1H', \ - 'HS2A', 'HS2B', 'HS2C', 'HS2D', 'HS2E', 'HS2F', 'HS2G', 'HS2H', \ - 'HS3A', 'HS3B', 'HS3C', 'HS3D', 'HS3E', 'HS3F', 'HS3G', 'HS3H'])].sum() - dsc = DDS[DDS.index.isin(['GOODSA', 'TRADEA', 'OTHERA', 'GOODSB', 'TRADEB', 'OTHERB', 'GOODSC', 'TRADEC', 'OTHERC', 'GOODSD', 'TRADED', 'OTHERD', \ - 'GOODSE', 'TRADEE', 'OTHERE', 'GOODSF', 'TRADEF', 'OTHERF', 'GOODSG', 'TRADEG', 'OTHERG', 'GOODSH', 'TRADEH', 'OTHERH'])].sum() - hhinc = DY[DY.index.isin(['HH1A', 'HH2A', 'HH3A', 'HH4A', 'HH5A', 'HH1B', 'HH2B', 'HH3B', 'HH4B', 'HH5B', 'HH1C', 'HH2C', 'HH3C', 'HH4C', 'HH5C', \ - 'HH1D', 'HH2D', 'HH3D', 'HH4D', 'HH5D', 'HH1E', 'HH2E', 'HH3E', 'HH4E', 'HH5E', 'HH1F', 'HH2F', 'HH3F', 'HH4F', 'HH5F', \ - 'HH1G', 'HH2G', 'HH3G', 'HH4G', 'HH5G', 'HH1H', 'HH2H', 'HH3H', 'HH4H', 'HH5H'])].sum() - hhdiff = HHL-HH0 - mig = hhdiff.sum() - - emplist.append(emp) - dsrlist.append(dsr) - dsclist.append(dsc) - hhinclist.append(hhinc) - miglist.append(mig) - simlist.append(s_name) - - cols = {'dsc': dsclist, 'dsr': dsrlist, 'mig': miglist, 'emp': emplist, 'hhinc': hhinclist} - - sims_result = pd.DataFrame.from_dict(cols) - - self.set_result_csv_data("Shelby_sims", sims_result, name="Shelby_sims", source="dataframe") - logger.info("Output sims has been created.") - - return True \ No newline at end of file + ''' + export domestic supply, household income (gross income), number of household, and factor demand + ''' + # domestic supply + cols = {'DS0': DS0, 'DSL': DSL} + domestic_supply = pd.DataFrame.from_dict(cols) + domestic_supply.index.name = 'Sectors' + self.set_result_csv_data("domestic-supply", domestic_supply, name="domestic-supply", source="dataframe") + logger.info("Output domestic-supply has been created.") + + # gross income + cols = {'Y0': Y0.loc[H], 'YL': YL.loc[H]} + gross_income = pd.DataFrame.from_dict(cols) + gross_income.index.name = 'Household Group' + self.set_result_csv_data("gross-income", gross_income, name="gross-income", source="dataframe") + logger.info("Output gross-income has been created.") + + # household count + cols = {'HH0': HH0, 'HHL': HHL} + household_count = pd.DataFrame.from_dict(cols) + household_count.index.name = 'Household Group' + self.set_result_csv_data("household-count", household_count, name="household-count", source="dataframe") + logger.info("Output household-count has been created.") + + # pre-disaster-factor-demand + pre_disaster = FD0.loc[L] + pre_disaster.index.name = 'Labor Group' + self.set_result_csv_data("pre-disaster-factor-demand", pre_disaster, + name="pre-disaster-factor-demand", source="dataframe") + logger.info("Output pre-disaster-factor-demand has been created.") + + # post-disaster-factor-demand + post_disaster = FDL.loc[L] + post_disaster.index.name = 'Labor Group' + self.set_result_csv_data("post-disaster-factor-demand", pre_disaster, + name="post-disaster-factor-demand", source="dataframe") + logger.info("Output post-disaster-factor-demand has been created.") \ No newline at end of file