Repository: TAMUparametric/energiapy (language: python)

Issue:
the demand dict does not need to include locations where resource isn…
…t discharged


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index a97b5c9a..9779b66e 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -5,9 +5,9 @@ name: Python package
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "test" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "test" ]
 
 jobs:
   build:
@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
     steps:
     - uses: actions/checkout@v3
@@ -35,4 +35,6 @@ jobs:
         flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
         # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
         flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
-
+    - name: Run tests
+      shell: bash -l {0}
+      run: pytest --disable-pytest-warnings
diff --git a/README.md b/README.md
index e2293995..10a803e5 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,6 @@
-# energiapy
+
+![alt text](https://github.com/TAMUparametric/energiapy/blob/main/docs/logo.jpg?raw=true)
+
 
 [![Documentation Status](https://readthedocs.org/projects/energiapy/badge/)](https://energiapy.readthedocs.io/en/latest/)
 [![PyPI](https://img.shields.io/pypi/v/energiapy.svg)](https://pypi.org/project/energiapy)
diff --git a/docs/index.rst b/docs/index.rst
index 68f38f28..645c519a 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -16,11 +16,14 @@ Tutorial
    :caption: Example Implementation:
 
    notebooks/small/small
+   notebooks/supermarket/supermarket
    notebooks/sl-sp-milp/sl-sp-milp
    notebooks/ml-sp-milp/ml-sp-milp
    notebooks/material/material
    notebooks/mplp/mpLP
    example_ahc
+   notebooks/fetch_nsrdb/fetch_nsrdb_data
+   notebooks/sl-mp-milp/sl-mp-milp
    
 API
 ---
diff --git a/docs/logo.jpg b/docs/logo.jpg
new file mode 100644
index 00000000..e41f6c3e
Binary files /dev/null and b/docs/logo.jpg differ
diff --git a/docs/logo2.png b/docs/logo2.png
new file mode 100644
index 00000000..8a548742
Binary files /dev/null and b/docs/logo2.png differ
diff --git a/docs/notebooks/fetch_nsrdb/fetch_nsrdb_data.ipynb b/docs/notebooks/fetch_nsrdb/fetch_nsrdb_data.ipynb
new file mode 100644
index 00000000..54f33659
--- /dev/null
+++ b/docs/notebooks/fetch_nsrdb/fetch_nsrdb_data.ipynb
@@ -0,0 +1,523 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fetching Weather Data From NSRDB"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "__author__ = \"Rahul Kakodkar\"\n",
+    "__copyright__ = \"Copyright 2023, Multi-parametric Optimization & Control Lab\"\n",
+    "__credits__ = [\"Rahul Kakodkar\", \"Efstratios N. Pistikopoulos\"]\n",
+    "__license__ = \"MIT\"\n",
+    "__version__ = \"1.0.7\"\n",
+    "__maintainer__ = \"Rahul Kakodkar\"\n",
+    "__email__ = \"cacodcar@tamu.edu\"\n",
+    "__status__ = \"Production\""
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The fetch_nsrdb function accesses the [National Solar Radiation Database (NSRDB)](https://nsrdb.nrel.gov/) hosted by NREL on a Amazon Web Services (AWS) cloud through the h5py module To access large datasets, an API key can be requested from NREL. Instructions on how to set up the API key can be found here : https://github.com/NREL/hsds-examples/blob/master/notebooks/03_NSRDB_introduction.ipynb. Download data at any latitude longitude (globally) or state-county (because of repetition of county names) pairs within the US. While HSDS allows you to splice datasets, the script allows you to also find means within ranges. Arrange data in a dataframe for multiscale analysis, with the temporal indices as tuples. [Can be saved as .csv/.txt/.json/.pkl]. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas\n",
+    "from energiapy.utils.nsrdb_utils import fetch_nsrdb_data"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using coordinates"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Coordinates can be used to download required data as shown below. An attrs list can be provided to download specific data such as: air_temperature, clearsky_dhi, clearsky_dni, clearsky_ghi, cloud_type, coordinates, dew_point, dhi, dni, fill_flag, ghi, meta, relative_humidity, solar_zenith_angle, surface_albedo, surface_pressure, time_index, total_precipitable_water, wind_direction, wind_speed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates, weather_data = fetch_nsrdb_data(attrs=['ghi', 'wind_speed'], year=2020 , resolution= 'hourly', lat_lon= (29.56999969482422, -95.05999755859375))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ghi</th>\n",
+       "      <th>wind_speed</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2020-01-01 00:00:00+00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-01-01 01:00:00+00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-01-01 02:00:00+00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-01-01 03:00:00+00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.40</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-01-01 04:00:00+00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.50</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-12-31 19:00:00+00:00</th>\n",
+       "      <td>74.5</td>\n",
+       "      <td>7.35</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-12-31 20:00:00+00:00</th>\n",
+       "      <td>62.0</td>\n",
+       "      <td>7.35</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-12-31 21:00:00+00:00</th>\n",
+       "      <td>45.0</td>\n",
+       "      <td>7.55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-12-31 22:00:00+00:00</th>\n",
+       "      <td>95.5</td>\n",
+       "      <td>7.05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020-12-31 23:00:00+00:00</th>\n",
+       "      <td>33.5</td>\n",
+       "      <td>6.80</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>8784 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                            ghi  wind_speed\n",
+       "2020-01-01 00:00:00+00:00   0.0        0.55\n",
+       "2020-01-01 01:00:00+00:00   0.0        0.25\n",
+       "2020-01-01 02:00:00+00:00   0.0        0.20\n",
+       "2020-01-01 03:00:00+00:00   0.0        0.40\n",
+       "2020-01-01 04:00:00+00:00   0.0        0.50\n",
+       "...                         ...         ...\n",
+       "2020-12-31 19:00:00+00:00  74.5        7.35\n",
+       "2020-12-31 20:00:00+00:00  62.0        7.35\n",
+       "2020-12-31 21:00:00+00:00  45.0        7.55\n",
+       "2020-12-31 22:00:00+00:00  95.5        7.05\n",
+       "2020-12-31 23:00:00+00:00  33.5        6.80\n",
+       "\n",
+       "[8784 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "weather_data"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example we will download weather data for every county at an hourly resolution in Texas using the fetch_nsrd_utils function. The centroids of each county can be downloaded from the following link: https://data.texas.gov/dataset/Texas-Counties-Centroid-Map/ups3-9e8m/data_preview. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "county_df = pandas.read_csv('Texas_Counties_Centroid_Map.csv')\n",
+    "county_list = county_df['CNTY_NM']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for county in county_list:\n",
+    "    fetch_nsrdb_data(attrs=['ghi', 'wind_speed'], year=2020 , resolution= 'hourly', lat_lon= (county_df[county_df['CNTY_NM'] == county]['X (Lat)'].values[0], county_df[county_df['CNTY_NM'] == county]['Y (Long)'].values[0]))[1].to_csv(f'{county}.csv')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using Attributes"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "fetch_nsrdb_data also allows you to skim and fetch data which match different specifications, e.g. wind data for collection point at the highest elevation in the county. The total list of specifications inclue 'max-population', 'max-elevation', 'max-landcover' 'min-population', 'min-elevation', 'min-landcover'. The state and county needs to be specified. Here we are downloading data for the year 2019 for Harris county in Texas at the collection point with minimum elevation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates, weather_data = fetch_nsrdb_data(attrs=['dni', 'dhi', 'wind_speed', 'ghi', 'air_temperature', 'dew_point', 'relative_humidity', 'surface_pressure'], year=2019, state='Texas',\n",
+    "                                   county='Harris', resolution='hourly', get='min-elevation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>dni</th>\n",
+       "      <th>dhi</th>\n",
+       "      <th>wind_speed</th>\n",
+       "      <th>ghi</th>\n",
+       "      <th>air_temperature</th>\n",
+       "      <th>dew_point</th>\n",
+       "      <th>relative_humidity</th>\n",
+       "      <th>surface_pressure</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2019-01-01 00:00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>12.40</td>\n",
+       "      <td>9.55</td>\n",
+       "      <td>82.775</td>\n",
+       "      <td>1015.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-01-01 01:00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>12.10</td>\n",
+       "      <td>9.60</td>\n",
+       "      <td>84.935</td>\n",
+       "      <td>1016.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-01-01 02:00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>11.65</td>\n",
+       "      <td>9.80</td>\n",
+       "      <td>88.555</td>\n",
+       "      <td>1016.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-01-01 03:00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.25</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>11.00</td>\n",
+       "      <td>9.90</td>\n",
+       "      <td>92.810</td>\n",
+       "      <td>1016.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-01-01 04:00:00</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.30</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>10.35</td>\n",
+       "      <td>9.70</td>\n",
+       "      <td>95.890</td>\n",
+       "      <td>1017.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-12-31 19:00:00</th>\n",
+       "      <td>456.0</td>\n",
+       "      <td>179.5</td>\n",
+       "      <td>1.95</td>\n",
+       "      <td>450.5</td>\n",
+       "      <td>15.45</td>\n",
+       "      <td>-0.60</td>\n",
+       "      <td>33.290</td>\n",
+       "      <td>1021.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-12-31 20:00:00</th>\n",
+       "      <td>16.0</td>\n",
+       "      <td>174.5</td>\n",
+       "      <td>1.75</td>\n",
+       "      <td>183.0</td>\n",
+       "      <td>15.55</td>\n",
+       "      <td>-0.60</td>\n",
+       "      <td>33.085</td>\n",
+       "      <td>1021.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-12-31 21:00:00</th>\n",
+       "      <td>17.0</td>\n",
+       "      <td>122.0</td>\n",
+       "      <td>1.45</td>\n",
+       "      <td>128.5</td>\n",
+       "      <td>15.10</td>\n",
+       "      <td>-0.60</td>\n",
+       "      <td>34.155</td>\n",
+       "      <td>1020.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-12-31 22:00:00</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>47.5</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>14.25</td>\n",
+       "      <td>1.80</td>\n",
+       "      <td>42.885</td>\n",
+       "      <td>1020.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019-12-31 23:00:00</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>9.5</td>\n",
+       "      <td>0.80</td>\n",
+       "      <td>9.5</td>\n",
+       "      <td>13.20</td>\n",
+       "      <td>1.70</td>\n",
+       "      <td>45.440</td>\n",
+       "      <td>1020.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>8760 rows × 8 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                       dni    dhi  wind_speed    ghi  air_temperature  \\\n",
+       "2019-01-01 00:00:00    0.0    0.0        0.85    0.0            12.40   \n",
+       "2019-01-01 01:00:00    0.0    0.0        0.85    0.0            12.10   \n",
+       "2019-01-01 02:00:00    0.0    0.0        1.00    0.0            11.65   \n",
+       "2019-01-01 03:00:00    0.0    0.0        1.25    0.0            11.00   \n",
+       "2019-01-01 04:00:00    0.0    0.0        1.30    0.0            10.35   \n",
+       "...                    ...    ...         ...    ...              ...   \n",
+       "2019-12-31 19:00:00  456.0  179.5        1.95  450.5            15.45   \n",
+       "2019-12-31 20:00:00   16.0  174.5        1.75  183.0            15.55   \n",
+       "2019-12-31 21:00:00   17.0  122.0        1.45  128.5            15.10   \n",
+       "2019-12-31 22:00:00    2.0   47.5        1.00   48.0            14.25   \n",
+       "2019-12-31 23:00:00    3.0    9.5        0.80    9.5            13.20   \n",
+       "\n",
+       "                     dew_point  relative_humidity  surface_pressure  \n",
+       "2019-01-01 00:00:00       9.55             82.775            1015.5  \n",
+       "2019-01-01 01:00:00       9.60             84.935            1016.0  \n",
+       "2019-01-01 02:00:00       9.80             88.555            1016.0  \n",
+       "2019-01-01 03:00:00       9.90             92.810            1016.5  \n",
+       "2019-01-01 04:00:00       9.70             95.890            1017.0  \n",
+       "...                        ...                ...               ...  \n",
+       "2019-12-31 19:00:00      -0.60             33.290            1021.5  \n",
+       "2019-12-31 20:00:00      -0.60             33.085            1021.0  \n",
+       "2019-12-31 21:00:00      -0.60             34.155            1020.0  \n",
+       "2019-12-31 22:00:00       1.80             42.885            1020.0  \n",
+       "2019-12-31 23:00:00       1.70             45.440            1020.0  \n",
+       "\n",
+       "[8760 rows x 8 columns]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "weather_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(29.56999969482422, -95.05999755859375)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "coordinates"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Data can be concatenated for longer temporal periods"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weather_houston = pandas.concat([fetch_nsrdb_data(attrs=['dni', 'dhi', 'wind_speed', 'ghi', 'air_temperature', 'dew_point', 'relative_humidity', 'surface_pressure'], year=2016+i, state='Texas',\n",
+    "                                   county='Harris', resolution='hourly', get='min-elevation')[1] for i in range(5)])\n",
+    "weather_houston = p\n",
+    "weather_houston.index = pandas.to_datetime(weather_houston.index, utc = True)\n",
+    "weather_houston.index = weather_houston.index.strftime('%m/%d/%Y, %r')\n",
+    "weather_houston = weather_houston[~weather_houston.index.str.contains('02/29')]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Resolutions"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The base resolution is 'half-hourly'. 'hourly' and 'daily' resolutions average out the data over their respective time periods."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/sl-mp-milp/sl-mp-milp.ipynb b/docs/notebooks/sl-mp-milp/sl-mp-milp.ipynb
new file mode 100644
index 00000000..ebc25b0a
--- /dev/null
+++ b/docs/notebooks/sl-mp-milp/sl-mp-milp.ipynb
@@ -0,0 +1,880 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Multi-period Energy Systems MILP"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "__author__ = \"Rahul Kakodkar\"\n",
+    "__copyright__ = \"Copyright 2023, Multi-parametric Optimization & Control Lab\"\n",
+    "__credits__ = [\"Rahul Kakodkar\", \"Efstratios N. Pistikopoulos\"]\n",
+    "__license__ = \"MIT\"\n",
+    "__version__ = \"1.0.7\"\n",
+    "__maintainer__ = \"Rahul Kakodkar\"\n",
+    "__email__ = \"cacodcar@tamu.edu\"\n",
+    "__status__ = \"Production\"\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This example provides the code for the publication:\n",
+    "\n",
+    "Kakodkar R, Allen RC, Demirhan CD, Fu X, Pappas I, Mutlu M, Pistikopoulos EN. Multiperiod Modeling and Optimization of Hydrogen-Based Dense Energy Carrier Supply Chains. Processes. 2024 Feb 25;12(3):469.\n",
+    "\n",
+    "Which can be accessed here: \n",
+    "https://www.mdpi.com/2227-9717/12/3/469#app1-processes-12-00469"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import Modules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from energiapy.components import *\n",
+    "from energiapy.plot import *\n",
+    "from energiapy.aggregation import *\n",
+    "import pandas\n",
+    "from itertools import product\n",
+    "from matplotlib import rc\n",
+    "import matplotlib.pyplot as plt\n",
+    "from energiapy.model.solve import solve\n",
+    "from energiapy.utils.nsrdb_utils import fetch_nsrdb_data\n",
+    "from energiapy.model.formulate import formulate, Constraints, Objective\n",
+    "from energiapy.model.bounds import CapacityBounds\n",
+    "from energiapy.utils.data_utils import get_data, make_henry_price_df, remove_outliers, load_results, calculate_hourly\n",
+    "import numpy\n",
+    "from energiapy.conversion.photovoltaic import solar_power_output\n",
+    "from energiapy.conversion.windmill import wind_power_output\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Import"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following data is needed for the model\n",
+    "\n",
+    "- solar and wind profiles : energiapy.fetch_nsrdb_data imports data from the NREL NSRDB database\n",
+    "- power demand : ERCOT for Houston\n",
+    "- Natural Gas prices: Henry Hub \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "horizon = 1"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Weather data"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The fetch_nsrdb function accesses the [National Solar Radiation Database (NSRDB)](https://nsrdb.nrel.gov/) hosted by NREL on a Amazon Web Services (AWS) cloud through the h5py module To access large datasets, an API key can be requested from NREL. Instructions on how to set up the API key can be found here : https://github.com/NREL/hsds-examples/blob/master/notebooks/03_NSRDB_introduction.ipynb. Download data at any latitude longitude (globally) or state-county (because of repetition of county names) pairs within the US. Skim and fetch data which match different specifications, e.g. wind data for collection point at the highest elevation in the county. While HSDS allows you to splice datasets, the script allows you to also find means within ranges. Arrange data in a dataframe for multiscale analysis, with the temporal indices as tuples. [Can be saved as .csv/.txt/.json/.pkl]. Here, we import solar data as dni and wind data as wind speed for most populated data point in Harris county (TX) at an hourly resolution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coord_houston = (29.56999969482422, -95.05999755859375)\n",
+    "weather_houston = pandas.read_csv('weather_houston.csv', index_col=0)\n",
+    "weather_houston.index = pandas.to_datetime(weather_houston.index, utc = True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solar_houston = solar_power_output(data= weather_houston, coord=coord_houston, sam = 'cecmod', module_params= 'Canadian_Solar_Inc__CS5P_220M', \n",
+    "                                   inverter = 'cecinverter', inverter_params= 'ABB__MICRO_0_25_I_OUTD_US_208__208V_', \n",
+    "                                   temperature_params= 'open_rack_glass_glass', aoi_model= 'no_loss', ac_model= 'sandia', spectral_model= 'no_loss')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wind_houston = wind_power_output(data= weather_houston, roughness_length= 0.1, turbine_type= 'V100/1800', hub_height= 92, \n",
+    "                                 wind_speed_model= 'logarithmic', density_model = 'ideal_gas', temperature_model = 'linear_gradient', \n",
+    "                                 power_output_model = 'power_coefficient_curve', density_correction = True, obstacle_height = 0, \n",
+    "                                 observation_height = 10)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Natural gas prices\n",
+    "\n",
+    "Natural gas prices are from the Henry price index at a daily temporal resolution.\n",
+    "\n",
+    "The energia.make_henry_price_df function implicitly fills in gaps in data such as weekends and public holidays by repeating the last recorded prices For e.g. if the 4th of July will use the price for the 3rd of July a typical saturday and sunday will take the values for the last friday.\n",
+    "\n",
+    "The stretch functionality stretches the values over the hourly temporal scale (8760) from a daily temporal scale (365), again through repetition.\n",
+    "\n",
+    "Moreover, we can remove outliers usig the remove_outliers features in data_utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ng_price_df = pandas.concat(\n",
+    "    [make_henry_price_df(file_name='Henry_Hub_Natural_Gas_Spot_Price_Daily.csv', year=2016 +i, stretch= True) for i in range(5)])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Demand data\n",
+    "\n",
+    "Get [hourly power demand data](https://www.ercot.com/gridinfo/load/load_hist)  for Houston from ERCOT Coastal region"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ercot = pandas.read_csv('ercot.csv', index_col=0)\n",
+    "ercot.index = pandas.to_datetime(ercot.index, utc = True)\n",
+    "ercot.loc['2016-11-06 23:00:00'] = ercot.loc['2016-11-06 22:00:00'] #random missing value"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Technology cost"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "NREL [Annual Technology Baseline (ATB)](https://atb.nrel.gov/) is a good source for technology cost and their expected trajectories. The annualy updated list categorizes trajectories based on the appetite for research and policy push and proposes three distinct scenarios:\n",
+    "\n",
+    "- Advanced\n",
+    "- Moderate\n",
+    "- Conservative\n",
+    "\n",
+    "The data for technologies not covered by ATB are drawn from literature. The trajectories for these technologies (mostly conventional) are set with only modest reduction rates as these have already stagnated in terms of cost, having witness generations of utility scale application; e.g. steam methane reforming (SMR). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url = 'https://oedi-data-lake.s3.amazonaws.com/ATB/electricity/parquet/2022/ATBe.parquet'\n",
+    "raw_data = pandas.read_parquet(url)\n",
+    "raw_data = raw_data.astype(\n",
+    "    dtype={\n",
+    "        'core_metric_key': 'string',\n",
+    "        'core_metric_parameter': 'string',\n",
+    "        'core_metric_case': 'string',\n",
+    "        'crpyears': 'string',\n",
+    "        'technology': 'string',\n",
+    "        'technology_alias': 'string',\n",
+    "        'techdetail': 'string',\n",
+    "        'display_name': 'string',\n",
+    "        'scenario': 'string',\n",
+    "        'units': 'string'\n",
+    "    })\n",
+    "raw_data['technology'].unique()\n",
+    "\n",
+    "def atb_gttr(core_metric_parameters, core_metric_case, crpyear, technology, techdetail, scenario):\n",
+    "    df_out = pandas.DataFrame()\n",
+    "    for i in core_metric_parameters:\n",
+    "        df = pandas.DataFrame(raw_data[\n",
+    "            (raw_data.core_metric_parameter == i) &\n",
+    "            (raw_data.core_metric_case == core_metric_case) &\n",
+    "            (raw_data.crpyears == str(crpyear)) &\n",
+    "            (raw_data.technology == technology) &\n",
+    "            (raw_data.techdetail == techdetail) &\n",
+    "            (raw_data.scenario == scenario)\n",
+    "        ][['value']])\n",
+    "        df = df.rename({'value': i}, axis='columns')\n",
+    "        df = df.reset_index()\n",
+    "        df_out = pandas.concat([df_out, df], axis='columns')\n",
+    "        df_out = df_out.loc[:, ~df_out.columns.duplicated()].copy()\n",
+    "        df_out = df_out.fillna(0)\n",
+    "        df_out = df_out.drop(columns=['index'])\n",
+    "    return df_out"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We define some trajectories for technologies at different TRLs (high, medium, low) under different scenarios (Advanced, Moderate, Conservative)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "hig_trl_adv = [(1 - i/(31*15)) for i in range(31)]\n",
+    "hig_trl_mod = [(1 - i/(31*10)) for i in range(31)]\n",
+    "hig_trl_con = [(1 - i/(31*5)) for i in range(31)]\n",
+    "\n",
+    "med_trl_adv = [(1 - i/(31*40)) for i in range(31)]\n",
+    "med_trl_mod = [(1 - i/(31*30)) for i in range(31)]\n",
+    "med_trl_con = [(1 - i/(31*20)) for i in range(31)]\n",
+    "\n",
+    "low_trl_adv = [(1 - i/(31*70)) for i in range(31)]\n",
+    "low_trl_mod = [(1 - i/(31*50)) for i in range(31)]\n",
+    "low_trl_con = [(1 - i/(31*30)) for i in range(31)]\n",
+    "\n",
+    "hig_trl_adv_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': hig_trl_adv, 'Fixed O&M': hig_trl_adv, 'Variable O&M': hig_trl_adv})\n",
+    "hig_trl_mod_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': hig_trl_mod, 'Fixed O&M': hig_trl_mod, 'Variable O&M': hig_trl_mod})\n",
+    "hig_trl_con_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': hig_trl_con, 'Fixed O&M': hig_trl_con, 'Variable O&M': hig_trl_con})\n",
+    "med_trl_adv_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': med_trl_adv, 'Fixed O&M': med_trl_adv, 'Variable O&M': med_trl_adv})\n",
+    "med_trl_mod_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': med_trl_mod, 'Fixed O&M': med_trl_mod, 'Variable O&M': med_trl_mod})\n",
+    "med_trl_con_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': med_trl_con, 'Fixed O&M': med_trl_con, 'Variable O&M': med_trl_con})\n",
+    "low_trl_adv_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': low_trl_adv, 'Fixed O&M': low_trl_adv, 'Variable O&M': low_trl_adv})\n",
+    "low_trl_mod_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': low_trl_mod, 'Fixed O&M': low_trl_mod, 'Variable O&M': low_trl_mod})\n",
+    "low_trl_con_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': low_trl_con, 'Fixed O&M': low_trl_con, 'Variable O&M': low_trl_con})\n",
+    "constant_df = pandas.DataFrame(\n",
+    "    data={'CAPEX': [1]*31, 'Fixed O&M': [1]*31, 'Variable O&M': [1]*31})\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We define different cost trajectories for different technologies under the three cost scenarios"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "param_list = ['CAPEX', 'Fixed O&M', 'Variable O&M']\n",
+    "advanced_dict = {\n",
+    "    'RPV': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='ResPV', techdetail='Class5', scenario='Advanced'),\n",
+    "    'PV': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='UtilityPV', techdetail='Class1', scenario='Advanced'),\n",
+    "    'WF': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='LandbasedWind', techdetail='Class1', scenario='Advanced'),\n",
+    "    'LiI': atb_gttr(core_metric_parameters=param_list, core_metric_case='R&D', crpyear=30, technology='Commercial Battery Storage', techdetail='8Hr Battery Storage', scenario='Advanced'),\n",
+    "    'LII_discharge': constant_df,\n",
+    "    'PSH': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Pumped Storage Hydropower', techdetail='NatlClass10', scenario='Advanced'),\n",
+    "    'PSH_discharge': constant_df,\n",
+    "    'ASMR': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Nuclear', techdetail='NuclearSMR', scenario='Moderate'),\n",
+    "    'NPP': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Nuclear', techdetail='Nuclear', scenario='Advanced'),\n",
+    "    'NGCC': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='NaturalGas_FE', techdetail='CCCCSHFrame95%', scenario='Conservative'),\n",
+    "    'SMR': hig_trl_adv_df,\n",
+    "    'SMRH': hig_trl_adv_df,\n",
+    "    'AqOff': hig_trl_adv_df,\n",
+    "    'DAC': low_trl_adv_df,\n",
+    "    'PEM': low_trl_adv_df,\n",
+    "    'H2_Comp': med_trl_adv_df,\n",
+    "}\n",
+    "\n",
+    "\n",
+    "moderate_dict = {\n",
+    "    'PV': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='UtilityPV', techdetail='Class1', scenario='Moderate'),\n",
+    "    'WF': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='LandbasedWind', techdetail='Class1', scenario='Moderate'),\n",
+    "    'LiI': atb_gttr(core_metric_parameters=param_list, core_metric_case='R&D', crpyear=30, technology='Commercial Battery Storage', techdetail='8Hr Battery Storage', scenario='Moderate'),\n",
+    "    'LII_discharge': constant_df,\n",
+    "    'PSH': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Pumped Storage Hydropower', techdetail='NatlClass10', scenario='Moderate'),\n",
+    "    'PSH_discharge': constant_df,\n",
+    "    'ASMR': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Nuclear', techdetail='NuclearSMR', scenario='Moderate'),\n",
+    "    'NPP': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Nuclear', techdetail='Nuclear', scenario='Moderate'),\n",
+    "    'NGCC': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='NaturalGas_FE', techdetail='CCCCSHFrame95%', scenario='Conservative'),\n",
+    "    'SMR': hig_trl_mod_df,\n",
+    "    'SMRH': hig_trl_mod_df,\n",
+    "    'AqOff': hig_trl_mod_df,\n",
+    "    'DAC': low_trl_mod_df,\n",
+    "    'PEM': low_trl_mod_df,\n",
+    "    'H2_Comp': med_trl_mod_df,\n",
+    "}\n",
+    "\n",
+    "\n",
+    "conservative_dict = {\n",
+    "    'PV': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='UtilityPV', techdetail='Class1', scenario='Conservative'),\n",
+    "    'WF': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='LandbasedWind', techdetail='Class1', scenario='Conservative'),\n",
+    "    'LiI': atb_gttr(core_metric_parameters=param_list, core_metric_case='R&D', crpyear=30, technology='Commercial Battery Storage', techdetail='8Hr Battery Storage', scenario='Conservative'),\n",
+    "    'LII_discharge': constant_df,\n",
+    "    'PSH': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Pumped Storage Hydropower', techdetail='NatlClass10', scenario='Conservative'),\n",
+    "    'PSH_discharge': constant_df,\n",
+    "    # no cons, adv\n",
+    "    'ASMR': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Nuclear', techdetail='NuclearSMR', scenario='Moderate'),\n",
+    "    'NPP': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='Nuclear', techdetail='Nuclear', scenario='Conservative'),\n",
+    "    'NGCC': atb_gttr(core_metric_parameters=param_list, core_metric_case='Market', crpyear=30, technology='NaturalGas_FE', techdetail='CCCCSHFrame95%', scenario='Conservative'),\n",
+    "    'SMR': hig_trl_con_df,\n",
+    "    'SMRH': hig_trl_con_df,\n",
+    "    'AqOff': hig_trl_con_df,\n",
+    "    'DAC': low_trl_con_df,\n",
+    "    'PEM': low_trl_con_df,\n",
+    "    'H2_Comp': med_trl_con_df,\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define temporal scale\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The variabilities of energy systems are best captured over a discretized spatio-temporal scale. In energiapy, the first declaration is the temporal scale. \n",
+    "\n",
+    "For e.g.: Here we declare three temporal scales at different levels from right to left. The interpretation of these scales is merely symentic. Scales can be declared as the problem demands.\n",
+    "- 0, annual, with 1 discretization\n",
+    "- 1, daily with 365 discretization\n",
+    "- 2, hourly with 24 discretization\n",
+    "\n",
+    "In essence, we are creating a temporal scale of 8760 points."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scales = TemporalScale(discretization_list=[horizon, 365, 24])\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Additional Parameters"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**For Convinience**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bigM = 10**5\n",
+    "smallM = 10"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Tax credits per 45Q**"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "https://www.whitehouse.gov/briefing-room/statements-releases/2021/03/31/fact-sheet-the-american-jobs-plan/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "credit = {'DAC': {0: 31.77, 1: 31.77, 2: 31.77, 3: 31.77, 4: 31.77, 5: 50.00, 6: 50.00, 7: 50.00, 8: 50.00, 9: 50.00},\n",
+    "          'AqOff': {0: 20.22, 1: 20.22, 2: 20.22, 3: 20.22, 4: 20.22, 5: 35.00, 6: 35.00, 7: 35.00, 8: 35.00, 9: 35.00}\n",
+    "}\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define single period model"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "The following processes are considered - \n",
+    "\n",
+    "- Modular nuclear reactors (ASMR)\n",
+    "- Proton Exchange Membrane Electrolyzers (PEM)\n",
+    "- Hydrogen Storage (H2_L_c/H2_L_d)\n",
+    "- Natural Gas Combined Cycle with 95% carbon capture (NGCC)\n",
+    "- Pumped Storage Hydropower (PSH/PSH_discharge)\n",
+    "- Lithium-ion batteries (LiI/LiI_discharge)\n",
+    "- Solar Photovoltaics (PV) \n",
+    "- Wind Farms (WF)\n",
+    "- Steam Methane Reforming (SMR)\n",
+    "- SMR + Carbon Capture Utilization and Storage (SMRH)\n",
+    "- Hydrogen Fuel Cells (H2FC)\n",
+    "- Direct Air Capture (DAC)\n",
+    "- Offshore Aquifers (AQoff)\n",
+    "\n",
+    "The stated processes utilize the following resources:\n",
+    "\n",
+    "- Methane (CH4)\n",
+    "- Carbon Dioxide (CO2)\n",
+    "- CO2 in aquifer (CO2_AQoff)\n",
+    "- CO2 Captured from air (CO2_DAC)\n",
+    "- Vented CO2 (CO2_Vent)\n",
+    "- Hydrogen (H2)\n",
+    "- Water (H2O)\n",
+    "- Stored hydrogen (H2_L)\n",
+    "- Power stored in LiI (LiI_Power)\n",
+    "- Oxygen (O2)\n",
+    "- Power stored in PSH (PSH_Power)\n",
+    "- Power\n",
+    "- Solar\n",
+    "- Uranium\n",
+    "- Wind\n",
+    "\n",
+    "We presuppose different pathways, the caveat here is that we only consider renewable power generation:\n",
+    "\n",
+    "1. full: contains all technologies \n",
+    "2. green: hydrogen production through electrolysis\n",
+    "3. blue: hydrogen production through methane reforming with carbon capture enforced\n",
+    "4. gray: hydrogen production through methane reforming, and carbon emission vented\n",
+    "5. There is an option of providing credits under any of the aforementioned scenarios\n",
+    "\n",
+    "All the resources needed for the processes need to be defined along with thier characterists (refer to examples 'Small Energy Systems Example' and 'Multiscale Energy Systems MILP'). \n",
+    "\n",
+    "The location specific varying parameter data is provided through the location object. \n",
+    "\n",
+    "The single location scenario is then reduced using agglomerative hierarchial clustering (AHC) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def model(name: str, year:int, cost_dict:dict, credit: dict = None, pathway: str = None):\n",
+    "    \n",
+    "    if pathway is None:\n",
+    "        pathway = 'full'\n",
+    "    \n",
+    "    #*---------------- Resources---------------------------------\n",
+    "\n",
+    "    Solar = Resource(name='Solar', cons_max=100, basis='MW', label='Solar Power')\n",
+    "\n",
+    "    Wind = Resource(name='Wind', cons_max=100, basis='MW', label='Wind Power')\n",
+    "\n",
+    "    Power = Resource(name='Power', basis='MW', label='Power generated')#, demand = True)\n",
+    "\n",
+    "    Uranium = Resource(name='Uranium', cons_max=100,\n",
+    "                    price=42.70/(250/2), basis='kg', label='Uranium')\n",
+    "\n",
+    "    H2 = Resource(name='H2', basis='tons', label='Hydrogen')\n",
+    "\n",
+    "    H2_C = Resource(name='H2(C)', basis='tons', label='Hydrogen(C)', demand=True, revenue= 0.005)\n",
+    "\n",
+    "    CO2_AQoff = Resource(name='CO2_AQoff', basis='tons',\n",
+    "                        label='Carbon dioxide - sequestered', sell=True)\n",
+    "\n",
+    "    H2O = Resource(name='H2O', cons_max=1000,\n",
+    "                price=3.00, basis='tons', label='Water', block='Resource')\n",
+    "\n",
+    "    CH4 = Resource(name='CH4', cons_max=1000, price=max(ng_price_df['CH4'])*1000, basis='tons',\n",
+    "                label='Natural gas', varying=[VaryingResource.DETERMINISTIC_PRICE])\n",
+    "\n",
+    "    CO2 = Resource(name='CO2', basis='tons',\n",
+    "                label='Carbon dioxide', block='Resource')\n",
+    "\n",
+    "    CO2_Vent = Resource(name='CO2_Vent', sell=True, basis='tons',\n",
+    "                        label='Carbon dioxide - Vented')\n",
+    "\n",
+    "    O2 = Resource(name='O2', sell=True, basis='tons', label='Oxygen')\n",
+    "\n",
+    "    CO2_DAC = Resource(name='CO2_DAC', basis='tons',\n",
+    "                    label='Carbon dioxide - captured')\n",
+    "\n",
+    "    LiI_Power = Resource(name='LiI_Power', basis='MW',\n",
+    "                        label='Power in LiI', store_max=10000, store_min=smallM)\n",
+    "\n",
+    "    PSH_Power = Resource(name='PSH_Power', basis='MW',\n",
+    "                        label='Power in PSH', store_max=10000, store_min=smallM)\n",
+    "\n",
+    "    #*---------------- Processes---------------------------------\n",
+    "\n",
+    "\n",
+    "    PEM = Process(name='PEM', conversion={Power: -1, H2: 0.3537, O2: 2.8302, H2O: -3.1839}, capex= cost_dict['PEM']['CAPEX'][year]*1.55*10**6, \n",
+    "                 fopex=0, vopex=0, cap_max=100, cap_min = 0, basis = 'tons', label = 'PEM' )\n",
+    "\n",
+    "    # LiI = Process(name='LiI', storage=Power, capex=1302182, fopex=41432, vopex=2000,\n",
+    "    #             cap_max=100, cap_min=0, store_max=10000, label='Lithium-ion battery', basis='MW')\n",
+    "\n",
+    "\n",
+    "    LiI = Process(name='LiI', conversion={Power: -1, LiI_Power: 1}, capex= cost_dict['LiI']['CAPEX'][year]*1000, \n",
+    "                 fopex=cost_dict['LiI']['Fixed O&M'][year]*1000, vopex=cost_dict['LiI']['Variable O&M'][year]*1000,\n",
+    "                store_max=10000, store_min=smallM, cap_max=bigM, cap_min=smallM, label='Lithium-ion battery', basis='MW', block='energy_storage')\n",
+    "\n",
+    "    LiI_discharge = Process(name='LiI', conversion={Power: 1, LiI_Power: -1}, capex=0.1,\n",
+    "                            fopex=0.01, vopex=0, cap_max=bigM, cap_min=smallM,  label='Lithium-ion battery (d)', basis='MW')\n",
+    "\n",
+    "    WF = Process(name='WF', conversion={Wind: -1, Power: 1}, capex= cost_dict['WF']['CAPEX'][year]*1000, \n",
+    "                 fopex=cost_dict['WF']['Fixed O&M'][year]*1000, vopex=cost_dict['WF']['Variable O&M'][year]*1000, land = 10800/1800,\n",
+    "                cap_max=100, cap_min=0, label='Wind mill array', varying=[VaryingProcess.DETERMINISTIC_CAPACITY], basis='MW')\n",
+    "\n",
+    "    PV = Process(name='PV', conversion={Solar: -1, Power: 1}, capex= cost_dict['PV']['CAPEX'][year]*1000, \n",
+    "                 fopex=cost_dict['PV']['Fixed O&M'][year]*1000, vopex=cost_dict['PV']['Variable O&M'][year]*1000,  land = 10000/1800,\n",
+    "                cap_max=100, cap_min=0,  varying= [VaryingProcess.DETERMINISTIC_CAPACITY], label='Solar PV', basis='MW')\n",
+    "\n",
+    "    H2_Comp = Process(name='H2_Comp', conversion={Power: -0.417, H2_C: 1, H2: -1}, capex= cost_dict['H2_Comp']['CAPEX'][year]*1.6 *\n",
+    "                 10**6, fopex= 0, vopex= 0, cap_max=100, cap_min=0,  label='Hydrogen Compression')\n",
+    "\n",
+    "    SMRH = Process(name='SMRH', conversion={Power: -1.11, CH4: -3.76, H2O: -23.7, H2: 1, CO2_Vent: 1.03, CO2: 9.332}, capex= cost_dict['SMRH']['CAPEX'][year]*252000, \n",
+    "                 fopex=cost_dict['SMRH']['Fixed O&M'][year]*945000, vopex=cost_dict['SMRH']['Variable O&M'][year]*51.5,\n",
+    "                cap_max=bigM, cap_min=smallM,  label='Steam methane reforming + CCUS', block='h2_prod')\n",
+    "\n",
+    "    NGCC = Process(name='NGCC', conversion={Power: 1, CH4: -0.108, CO2_Vent: 0.297*0.05, CO2: 0.297 *\n",
+    "                0.95},capex= cost_dict['NGCC']['CAPEX'][year]*1000, \n",
+    "                 fopex=cost_dict['NGCC']['Fixed O&M'][year]*1000, vopex=cost_dict['NGCC']['Variable O&M'][year]*1000, cap_max=bigM, cap_min=smallM,  label='NGCC + 95% CC', block='power_gen')\n",
+    "\n",
+    "\n",
+    "    NG = Process(name='NG', conversion={Power: 1, CH4: -0.108, CO2_Vent: 0.297},capex= 0.3*cost_dict['NGCC']['CAPEX'][year]*1000, \n",
+    "                 fopex= 0.3*cost_dict['NGCC']['Fixed O&M'][year]*1000, vopex= 0.3*cost_dict['NGCC']['Variable O&M'][year]*1000, cap_max=bigM, cap_min=smallM,  label='NGCC + 95% CC', block='power_gen')\n",
+    "\n",
+    "\n",
+    "    SMR = Process(name='SMR', capex= cost_dict['SMR']['CAPEX'][year]*240000, \n",
+    "                 fopex=cost_dict['SMR']['Fixed O&M'][year]*800000, vopex=cost_dict['SMR']['Variable O&M'][year]*30,  conversion={\n",
+    "                Power: -1.11, CH4: -3.76, H2O: -23.7, H2: 1, CO2_Vent: 9.4979}, cap_max=bigM, cap_min=0.01,  label='Steam methane reforming', block='h2_prod')\n",
+    "\n",
+    "\n",
+    "    PSH = Process(name='PSH', conversion={Power: -1, PSH_Power: 1}, capex= cost_dict['PSH']['CAPEX'][year]*1000, \n",
+    "                 fopex=cost_dict['PSH']['Fixed O&M'][year]*1000, vopex=cost_dict['PSH']['Variable O&M'][year]*1000, cap_max=bigM, cap_min=smallM, store_min=smallM, store_max=1000, label='Pumped storage hydropower', basis='MW', block='energy_storage')\n",
+    "\n",
+    "    PSH_discharge = Process(name='PSH_discharge', conversion={Power: 1, PSH_Power: -1},  capex=0.1,\n",
+    "                            fopex=0.01, vopex=0, cap_max=bigM, cap_min=smallM,  label='Pumped storage hydropower (d)', basis='MW')\n",
+    "\n",
+    "    ASMR = Process(name='ASMR', conversion={Uranium: -4.17*10**(-5), H2O: -3.364, Power: 1}, capex= cost_dict['ASMR']['CAPEX'][year]*1000, \n",
+    "                 fopex=cost_dict['ASMR']['Fixed O&M'][year]*1000, vopex=cost_dict['ASMR']['Variable O&M'][year]*1000, cap_max=bigM, cap_min=smallM, label='Small modular reactors (SMRs)', block='power_gen')\n",
+    "\n",
+    "    AqOff = Process(name='AqOff', conversion={Power: -1.28, CO2_AQoff: 1, CO2: -1}, capex= cost_dict['AqOff']['CAPEX'][year]*552000, \n",
+    "                fopex=0, vopex=cost_dict['AqOff']['Variable O&M'][year]*4.140, cap_max=bigM, cap_min=smallM,\n",
+    "                label='Offshore aquifer CO2 sequestration (SMR)', block='ccus')\n",
+    "    \n",
+    "    DAC = Process(name='DAC', capex= cost_dict['DAC']['CAPEX'][year]*1000, \n",
+    "                fopex=cost_dict['DAC']['Fixed O&M'][year]*1000, vopex=cost_dict['DAC']['Variable O&M'][year]*1000, conversion={\n",
+    "                Power: -0.193, H2O: -4.048, CO2_DAC: 1}, cap_max=bigM, cap_min=smallM,  label='Direct air capture', block='ccus')\n",
+    "\n",
+    "    \n",
+    "    if pathway == 'full':\n",
+    "        \n",
+    "        process_set = {LiI, WF, ASMR, PEM, H2_Comp, NGCC, AqOff, PSH, SMR, SMRH, PV}\n",
+    "    \n",
+    "    if pathway == 'green':\n",
+    "        \n",
+    "        process_set = {LiI, WF, ASMR, PEM, H2_Comp, PSH, PV}\n",
+    "    \n",
+    "    if pathway == 'blue':\n",
+    "         \n",
+    "        process_set = {LiI, WF, H2_Comp, NGCC, AqOff, PSH, SMRH, PV}\n",
+    "    \n",
+    "    if pathway == 'grey':\n",
+    "        \n",
+    "        process_set = {LiI, H2_Comp, NG, PSH, SMR}\n",
+    "    \n",
+    "    #*---------------- Location---------------------------------\n",
+    "    \n",
+    "    if credit is not None:\n",
+    "        houston= Location(name='HO', processes=process_set, capacity_factor={PV: solar_houston[:8760*horizon], WF: wind_houston[:8760*horizon]}, price_factor={\n",
+    "                   CH4: ng_price_df[:8760*horizon]}, scales=scales, label='Houston (conservative)', expenditure_scale_level=0, demand_scale_level=2, capacity_scale_level=2, \n",
+    "                          price_scale_level=2, land_cost = 10000, credit = {AqOff: credit['AqOff'][year], DAC: credit['DAC'][year]})\n",
+    "    else:\n",
+    "        houston= Location(name='HO', processes=process_set, capacity_factor={PV: solar_houston[:8760*horizon], WF: wind_houston[:8760*horizon]}, price_factor={\n",
+    "                   CH4: ng_price_df[:8760*horizon]}, scales=scales, label='Houston (conservative)', expenditure_scale_level=0, demand_scale_level=2, capacity_scale_level=2, price_scale_level=2, land_cost = 10000)\n",
+    "\n",
+    "    #*---------------- Scenario---------------------------------\n",
+    "    \n",
+    "    scenario = Scenario(name=name, network=houston, scales=scales,  expenditure_scale_level=0, scheduling_scale_level=2,\n",
+    "                    network_scale_level=0, demand_scale_level=1, purchase_scale_level=2, capacity_scale_level = 2, label='full_case', demand={houston: {H2_C: 0.2740}}, annualization_factor = 0.1)\n",
+    "\n",
+    "    scenario_reduced =  reduce_scenario(scenario=scenario, periods=40, scale_level=1, method=Clustermethod.AHC, include = [IncludeAHC.CAPACITY, IncludeAHC.PRICE])\n",
+    "\n",
+    "    \n",
+    "    return scenario_reduced\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define multiperiod case studies"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Multiperiod casetudies can be defined using the CaseStudy object which conviniently generates a multiperiod scenario from single scenarios. \n",
+    "\n",
+    "What differs between each single period scenario is primarily the cost of technology. Similarly, the conversion efficiency can also be augmented. \n",
+    "\n",
+    "The seven case studies defined are as follows:\n",
+    "\n",
+    "1. Moderate cost trajectory scenario with carbon credits and all technologies available\n",
+    "2. Moderate cost trajectory scenario with only the green pathway available\n",
+    "3. Moderate cost trajectory scenario with only the grey pathway available\n",
+    "4. Moderate cost trajectory scenario with only the blue pathway available\n",
+    "5. Advanced cost trajectory scenario with all technologies available\n",
+    "6. Conservative cost trajectory scenario with all technologies available\n",
+    "7. Moderate cost trajectory scenario with all technologies available\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "span_ = 10\n",
+    "moderate_credit = CaseStudy(name = 'moderate_credit', scenarios= [model(name = f'scenario{i}', year= i, cost_dict= moderate_dict, credit = credit) for i in range(span_)])\n",
+    "moderate_green = CaseStudy(name = 'moderate_green', scenarios= [model(name = f'scenario{i}', year= i, cost_dict= moderate_dict, pathway = 'green') for i in range(span_)])\n",
+    "moderate_grey = CaseStudy(name = 'moderate_grey', scenarios= [model(name = f'scenario{i}', year= i, cost_dict= moderate_dict, pathway = 'grey') for i in range(span_)])\n",
+    "moderate_blue = CaseStudy(name = 'moderate_blue', scenarios= [model(name = f'scenario{i}', year= i, cost_dict= moderate_dict, pathway = 'blue') for i in range(span_)])\n",
+    "\n",
+    "advanced = CaseStudy(name = 'advanced', scenarios= [model(name = f'scenario{i}', year= i, cost_dict= advanced_dict) for i in range(span_)])\n",
+    "conservative = CaseStudy(name = 'conservative', scenarios= [model(name = f'scenario{i}', year= i, cost_dict=  conservative_dict) for i in range(span_)])\n",
+    "moderate = CaseStudy(name = 'moderate', scenarios= [model(name = f'scenario{i}', year= i, cost_dict= moderate_dict) for i in range(span_)])\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Formulate MIPs"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "MILPs can be formulated based on these scenarios.\n",
+    "\n",
+    "The considered constraints are:\n",
+    "\n",
+    "1. Cost: these evaluate the cash flows through the system. This includes, capital expenditure, fixed and variable operational expenditure, resource purchase cost\n",
+    "2. Inventory: Manages the storage of resources.\n",
+    "3. Production: Capacitates the production at the scheduling scale to the available network production capacities\n",
+    "4. Resource Balance: Arguably forms the core of the formulation by managing the resource balance in each time period in the scheduling scale\n",
+    "5. Network: These are binary constraints which decide whether a production or storage process is established or not\n",
+    "6. Demand: Ensures that the resource demand is met\n",
+    "7. Land: Calculates land use by processes\n",
+    "8. Credit: Calculates carbon credits earned by the use of processes\n",
+    "\n",
+    "The objective is to minimize cost\n",
+    "\n",
+    "For the full formulation refer: https://www.mdpi.com/article/10.3390/pr12030469/s1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moderate_credit.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND, Constraints.CREDIT}, objective=Objective.COST)\n",
+    "advanced.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND}, objective=Objective.COST)\n",
+    "conservative.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND}, objective=Objective.COST)\n",
+    "\n",
+    "moderate.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND}, objective=Objective.COST)\n",
+    "moderate_green.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND}, objective=Objective.COST)\n",
+    "moderate_blue.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND}, objective=Objective.COST)\n",
+    "\n",
+    "moderate_grey.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,\n",
+    "                      Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.LAND}, objective=Objective.COST)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solve the problems"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The choice of solver here is GUROBI (https://www.gurobi.com/). This problem was solved on an academic licence. The solution can be saved as either a .txt, .json, or .pkl file. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moderate_credit.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "advanced.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "conservative.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "moderate.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "moderate_green.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "moderate_blue.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "moderate_grey.solve(solver='gurobi', print_solversteps=True, saveformat = '.pkl')\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The results are discussed in the publication: https://www.mdpi.com/2227-9717/12/3/469#app1-processes-12-00469"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cite Us"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "@article{kakodkar2024multiperiod,\n",
+    "  title={Multiperiod Modeling and Optimization of Hydrogen-Based Dense Energy Carrier Supply Chains},\n",
+    "  author={Kakodkar, Rahul and Allen, R Cory and Demirhan, C Doga and Fu, Xiao and Pappas, Iosif and Mutlu, Mete and Pistikopoulos, Efstratios N},\n",
+    "  journal={Processes},\n",
+    "  volume={12},\n",
+    "  number={3},\n",
+    "  pages={469},\n",
+    "  year={2024},\n",
+    "  publisher={MDPI}\n",
+    "}"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.5 ('ki': venv)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "a4a97498e3c1bfef05f70a75d4fcafcb7b5c9c4ed86429a4e7bee46eaa890f24"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/small/small.ipynb b/docs/notebooks/small/small.ipynb
index c08b841f..bcc316e2 100644
--- a/docs/notebooks/small/small.ipynb
+++ b/docs/notebooks/small/small.ipynb
@@ -5,7 +5,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Small energy systems example"
+    "# Small Energy Systems Example"
    ]
   },
   {
diff --git a/docs/notebooks/supermarket/supermarket.ipynb b/docs/notebooks/supermarket/supermarket.ipynb
new file mode 100644
index 00000000..dd8a5388
--- /dev/null
+++ b/docs/notebooks/supermarket/supermarket.ipynb
@@ -0,0 +1,845 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "546ec2c2",
+   "metadata": {},
+   "source": [
+    "# Supermarket Example"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "bcd20eb8",
+   "metadata": {},
+   "source": [
+    "__author__ = \"Rahul Kakodkar\"\n",
+    "__copyright__ = \"Copyright 2023, Multi-parametric Optimization & Control Lab\"\n",
+    "__credits__ = [\"Rahul Kakodkar\", \"Efstratios N. Pistikopoulos\"]\n",
+    "__license__ = \"MIT\"\n",
+    "__version__ = \"1.0.7\"\n",
+    "__maintainer__ = \"Rahul Kakodkar\"\n",
+    "__email__ = \"cacodcar@tamu.edu\"\n",
+    "__status__ = \"Complete\"\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d7cfeabc",
+   "metadata": {},
+   "source": [
+    "A chunk of the following code was submitted as part of the course requirement for ICPE 604 Energy Systems Engineering I offered as a part of the Master in Energy program at Texas A&M University by a team comprising of Cheonseong Lee, Ricardo Aragon, Andrew Houston, Kevin Klingaman, Riham Saoui"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "dd5c373f",
+   "metadata": {},
+   "source": [
+    "## Problem Statement"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "abb820c3",
+   "metadata": {},
+   "source": [
+    "Given is a supermarket comprising of on-site energy conversion blocks and energy demands. The expected operating horizon of the supermarket is 20 years. The energy demands are listed in Table 1."
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "09b02a2f",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "278c0b51",
+   "metadata": {},
+   "source": [
+    "Primary energy resources include natural gas and biomass. Prices of the primary energy resources and grid electricity as well as their associated CO2 production is given in Table 2 – it should be noted that 1 [GJ] is approximately equal to 277.78 [KWh].\n"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "9702eed4",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "96aee85f",
+   "metadata": {},
+   "source": [
+    "The on-site energy generation section involves two electricity generation technologies, one heat generation technology, and one co-production technology. The electrical efficiency (ηE), heating efficiency (ηH), minimum capacity if constructed (LB), maximum capacity if constructed (UB), capital cost (CAPEX), and operational cost (OPEX) are give in Table 3. Table 3: Technical and economic parameters of on-site energy generation technologies\n"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "bcbaf1ee",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "772864cc",
+   "metadata": {},
+   "source": [
+    "Two electricity driven energy conversion technologies and one heat driven energy conversion technologies is given in order to meet the demands of lighting, refrigeration, and space heating. The efficiency (or coefficient of performance, COP), types of energy input, types of utility output, capital cost and operational cost of these technologies are summarized in Table 4."
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "d896ba7a",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a90440d3",
+   "metadata": {},
+   "source": [
+    "Determine system configurations for optimal cost, energy efficiency, and emission"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "bec99404",
+   "metadata": {},
+   "source": [
+    "## Import modules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c279b795",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas\n",
+    "import numpy\n",
+    "from energiapy.components import *\n",
+    "from energiapy.model.formulate import formulate, Constraints, Objective\n",
+    "from energiapy.plot import plot_results, plot_scenario\n",
+    "from energiapy.plot.plot_results import CostY, CostX\n",
+    "from energiapy.model.solve import solve"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c593b5f8",
+   "metadata": {},
+   "source": [
+    "## Temporal Scale"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "274652bb",
+   "metadata": {},
+   "source": [
+    "We will conside a single temporal scale representing the 20 year horizon"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12c1143b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scales=TemporalScale(discretization_list=[1]) "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "7a54554f",
+   "metadata": {},
+   "source": [
+    "## Resources"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c2d1edb7",
+   "metadata": {},
+   "source": [
+    "Resources can be declared along with thier attributes such as maximum allowed consumption, dischargeablity, base price, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "42e49131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Biomass= Resource(name='Biomass', price=36.11, cons_max= 10**10, basis='GJ', label='Biomass') #table 2\n",
+    "\n",
+    "GridPower = Resource(name='GridPower', cons_max = 10**10, price=9.72, basis='GJ', label='Grid Electricity')\n",
+    "\n",
+    "NG = Resource(name='NG', price= 8.89, cons_max= 10*10, basis='GJ', label='Natural gas')\n",
+    "Power=Resource(name='Power', basis='kW',label='Electrical Power')\n",
+    "Heat=Resource(name='Heat', basis='kW',label='Heat Power')\n",
+    "\n",
+    "CO2_Vent = Resource(name='CO2_Vent', sell=True, basis='tons', label='Carbon dioxide')\n",
+    "\n",
+    "Solar = Resource(name = 'Solar', cons_max=10**10, basis ='GJ', label ='Solar energy') \n",
+    "Wind = Resource(name = 'Wind', cons_max=10**10, basis ='GJ', label ='Wind energy')\n",
+    "\n",
+    "Lighting = Resource(name='Lighting', demand=True, basis='kW',label='Lighting')\n",
+    "Refrigeration = Resource(name='Refrigeration', demand=True, basis='kW',label='Refrigeration') \n",
+    "Heating = Resource(name='Heating', demand=True, basis='kW',label='Heating')\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "9db1df3f",
+   "metadata": {},
+   "source": [
+    "## Processes"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a8cec5e8",
+   "metadata": {},
+   "source": [
+    "Processes convert one resource to another with a particular conversion efficiency while incurring a cost for setup (capital expenditure) and operation (operational expenditure)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f584e041",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ST= Process(name='BM_ST', conversion={Biomass: -1, Power: 277.78*0.68, CO2_Vent:100},capex=250, fopex=15,\n",
+    "            cap_min=100, cap_max=1000000, label='Biomass ST', basis='PJ') #table 3 \n",
+    "\n",
+    "\n",
+    "CHP= Process(name='NG_CHP', conversion={NG: -1, Power: 277.78*0.44, CO2_Vent: 56, Heat: 277.78*0.28},\n",
+    "             capex=500, fopex=15, cap_max=1000000, cap_min=800, label='Natural Gas CHP', basis='PJ')\n",
+    "\n",
+    "\n",
+    "PV= Process(name='PV', conversion={Solar: -1, Power: 277.78*0.09}, capex=2000, fopex = 500, \n",
+    "             cap_max=300, cap_min=10, label='Solar PV',  basis='kW')\n",
+    "\n",
+    "\n",
+    "WF= Process(name='WF',conversion={Wind: -1, Power: 277.78*0.22}, capex=2000, fopex=1200,\n",
+    "             cap_max=500, cap_min=10, label='Wind Farm', basis='kW') \n",
+    "\n",
+    "\n",
+    "Grid = Process(name = 'Grid', conversion = {GridPower:-1, Power:277.78, CO2_Vent:90}, \n",
+    "               basis = 'PJ', label = 'Grid Electricity', cap_max = 1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a648956",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Refrigerator = Process(name = 'Refrigerator', conversion = {Power:-1, Refrigeration:1*3}, capex = 70, vopex = 4, \n",
+    "             basis = 'kW', label = 'Refrigerator', cap_max = 1000)\n",
+    "\n",
+    "LED = Process(name = 'LED', conversion = {Power:-1, Lighting:1*0.8}, capex = 10, vopex = 1, \n",
+    "             basis = 'kW', label = 'LED', cap_max = 1000)\n",
+    "\n",
+    "Heater = Process(name = 'Heater', conversion = {Heat:-1, Heating:1*0.85}, capex = 30, vopex = 3, \n",
+    "             basis = 'kW', label = 'Heater', cap_max = 1000)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a60e71bf",
+   "metadata": {},
+   "source": [
+    "## Location"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c306d69a",
+   "metadata": {},
+   "source": [
+    "Locations serve as aggregations of scenarios"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1934ea2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "place = Location(name = 'place', processes = {ST, CHP, PV, WF, Grid, Refrigerator, LED, Heater}, \n",
+    "                 scales = scales, label = 'College Station')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d487226b",
+   "metadata": {},
+   "source": [
+    "## Scenario"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c2de28ca",
+   "metadata": {},
+   "source": [
+    "Demands are provided at the scenario level"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a461db2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scenario= Scenario(name='scenario', network=place, \n",
+    "                   demand= {place:{Heating:100, Lighting:200, Refrigeration:1000}},\n",
+    "                   network_scale_level=0,scheduling_scale_level=0, scales=scales, label='scenario', demand_scale_level = 0, annualization_factor = 0.05)\n",
+    "#26000 is the total power we will need in 20 years running the supermarket\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "28c7ec56",
+   "metadata": {},
+   "source": [
+    "## Formulation"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "58d6bf84",
+   "metadata": {},
+   "source": [
+    "Various constraints are need for the formulating the mathematical programming model. Here we include the cost, production, resource balance, demand, inventory, and network constraints."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "119f9199",
+   "metadata": {},
+   "source": [
+    "### Optimal Cost "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d5cfa54",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "constraint process capex\n",
+      "constraint process fopex\n",
+      "constraint process vopex\n",
+      "constraint process incidental\n",
+      "constraint storage cost\n",
+      "constraint storage cost location\n",
+      "constraint storage cost network\n",
+      "constraint production mode\n",
+      "constraint inventory balance\n",
+      "constraint inventory network\n",
+      "constraint storage facility\n",
+      "constraint production facility\n",
+      "constraint min production facility\n",
+      "constraint min storage facility\n",
+      "constraint demand\n",
+      "objective cost\n"
+     ]
+    }
+   ],
+   "source": [
+    "lp_min_cost =formulate(scenario=scenario, constraints=\n",
+    "            {\n",
+    "            Constraints.COST,\n",
+    "            Constraints.PRODUCTION,\n",
+    "            Constraints.RESOURCE_BALANCE,\n",
+    "            Constraints.DEMAND,\n",
+    "            Constraints.INVENTORY,\n",
+    "            Constraints.NETWORK,\n",
+    "            }, objective=Objective.COST)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93fe8dc7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set parameter QCPDual to value 1\n",
+      "Gurobi Optimizer version 10.0.2 build v10.0.2rc0 (win64)\n",
+      "\n",
+      "CPU model: Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz, instruction set [SSE2|AVX|AVX2]\n",
+      "Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n",
+      "\n",
+      "Optimize a model with 150 rows, 145 columns and 294 nonzeros\n",
+      "Model fingerprint: 0xc053e7e7\n",
+      "Variable types: 137 continuous, 8 integer (8 binary)\n",
+      "Coefficient statistics:\n",
+      "  Matrix range     [5e-01, 1e+06]\n",
+      "  Objective range  [1e+00, 1e+00]\n",
+      "  Bounds range     [1e+00, 1e+00]\n",
+      "  RHS range        [1e+02, 1e+10]\n",
+      "Warning: Model contains large rhs\n",
+      "         Consider reformulating model or setting NumericFocus parameter\n",
+      "         to avoid numerical issues.\n",
+      "Presolve removed 143 rows and 137 columns\n",
+      "Presolve time: 0.00s\n",
+      "Presolved: 7 rows, 8 columns, 16 nonzeros\n",
+      "Variable types: 6 continuous, 2 integer (2 binary)\n",
+      "Found heuristic solution: objective 35431.801495\n",
+      "\n",
+      "Explored 0 nodes (0 simplex iterations) in 0.02 seconds (0.00 work units)\n",
+      "Thread count was 8 (of 8 available processors)\n",
+      "\n",
+      "Solution count 1: 35431.8 \n",
+      "\n",
+      "Optimal solution found (tolerance 1.00e-04)\n",
+      "Best objective 3.543180149517e+04, best bound 3.543180149517e+04, gap 0.0000%\n",
+      "WARNING: Cannot get duals for MIP.\n"
+     ]
+    }
+   ],
+   "source": [
+    "results_min_cost =solve(scenario= scenario, instance=lp_min_cost, solver='gurobi', name='lp')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c171843d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{('place', 'BM_ST', 0): 0.0,\n",
+       " ('place', 'Grid', 0): 1000.0,\n",
+       " ('place', 'Heater', 0): 117.64705882352916,\n",
+       " ('place', 'LED', 0): 250.0,\n",
+       " ('place', 'NG_CHP', 0): 800.0,\n",
+       " ('place', 'PV', 0): 0.0,\n",
+       " ('place', 'Refrigerator', 0): 333.3333333333333,\n",
+       " ('place', 'WF', 0): 0.0}"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results_min_cost.output['Cap_P']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f29392c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{('place', 'CO2_Vent', 0): 213.80501224897768,\n",
+       " ('place', 'Lighting', 0): 200.0,\n",
+       " ('place', 'Refrigeration', 0): 1000.0,\n",
+       " ('place', 'Heating', 0): 100.00000000000001}"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results_min_cost.output['S']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89f298e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{('place', 'Heater', 0): 117.64705882352942,\n",
+       " ('place', 'Grid', 0): 1.4344423059741573,\n",
+       " ('place', 'LED', 0): 250.0,\n",
+       " ('place', 'PV', 0): 0.0,\n",
+       " ('place', 'NG_CHP', 0): 1.5125929412732766,\n",
+       " ('place', 'WF', 0): 0.0,\n",
+       " ('place', 'BM_ST', 0): 0.0,\n",
+       " ('place', 'Refrigerator', 0): 333.3333333333333}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results_min_cost.output['P']"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a3431d9e",
+   "metadata": {},
+   "source": [
+    "### Optimal Energy Efficiency "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "25544b58",
+   "metadata": {},
+   "source": [
+    "In the formulation, the objective can be skipped and a bespoke objective can be introduced as shown below"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8dd0777",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "constraint process capex\n",
+      "constraint process fopex\n",
+      "constraint process vopex\n",
+      "constraint process incidental\n",
+      "constraint storage cost\n",
+      "constraint storage cost location\n",
+      "constraint storage cost network\n",
+      "constraint production mode\n",
+      "constraint inventory balance\n",
+      "constraint inventory network\n",
+      "constraint storage facility\n",
+      "constraint production facility\n",
+      "constraint min production facility\n",
+      "constraint min storage facility\n",
+      "constraint demand\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pyomo.environ import Objective as Objectiveee\n",
+    "lp_eff =formulate(scenario=scenario, constraints=\n",
+    "            {\n",
+    "            Constraints.COST,\n",
+    "            Constraints.PRODUCTION,\n",
+    "            Constraints.RESOURCE_BALANCE,\n",
+    "            Constraints.DEMAND,\n",
+    "            Constraints.INVENTORY,\n",
+    "            Constraints.NETWORK\n",
+    "            })\n",
+    "lp_eff.objective = Objectiveee(expr = sum(lp_eff.C['place', resource_, 0] for resource_ in lp_eff.resources_purch))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddffa353",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set parameter QCPDual to value 1\n",
+      "Gurobi Optimizer version 10.0.2 build v10.0.2rc0 (win64)\n",
+      "\n",
+      "CPU model: Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz, instruction set [SSE2|AVX|AVX2]\n",
+      "Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n",
+      "\n",
+      "Optimize a model with 150 rows, 145 columns and 294 nonzeros\n",
+      "Model fingerprint: 0xaa569d30\n",
+      "Variable types: 137 continuous, 8 integer (8 binary)\n",
+      "Coefficient statistics:\n",
+      "  Matrix range     [5e-01, 1e+06]\n",
+      "  Objective range  [1e+00, 1e+00]\n",
+      "  Bounds range     [1e+00, 1e+00]\n",
+      "  RHS range        [1e+02, 1e+10]\n",
+      "Warning: Model contains large rhs\n",
+      "         Consider reformulating model or setting NumericFocus parameter\n",
+      "         to avoid numerical issues.\n",
+      "Presolve removed 150 rows and 145 columns\n",
+      "Presolve time: 0.00s\n",
+      "Presolve: All rows and columns removed\n",
+      "\n",
+      "Explored 0 nodes (0 simplex iterations) in 0.01 seconds (0.00 work units)\n",
+      "Thread count was 1 (of 8 available processors)\n",
+      "\n",
+      "Solution count 1: 2.94704 \n",
+      "\n",
+      "Optimal solution found (tolerance 1.00e-04)\n",
+      "Best objective 2.947035247247e+00, best bound 2.947035247247e+00, gap 0.0000%\n",
+      "WARNING: Cannot get duals for MIP.\n"
+     ]
+    }
+   ],
+   "source": [
+    "results_eff =solve(scenario= scenario, instance=lp_eff , solver='gurobi', name='lp')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "f87a3362",
+   "metadata": {},
+   "source": [
+    "### Optimal Emissions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20ef00d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "constraint process capex\n",
+      "constraint process fopex\n",
+      "constraint process vopex\n",
+      "constraint process incidental\n",
+      "constraint storage cost\n",
+      "constraint storage cost location\n",
+      "constraint storage cost network\n",
+      "constraint production mode\n",
+      "constraint inventory balance\n",
+      "constraint inventory network\n",
+      "constraint storage facility\n",
+      "constraint production facility\n",
+      "constraint min production facility\n",
+      "constraint min storage facility\n",
+      "constraint demand\n",
+      "constraint network cost\n",
+      "objective discharge min\n"
+     ]
+    }
+   ],
+   "source": [
+    "lp_em=formulate(scenario=scenario, constraints=\n",
+    "            {\n",
+    "            Constraints.COST,\n",
+    "            Constraints.PRODUCTION,\n",
+    "            Constraints.RESOURCE_BALANCE,\n",
+    "            Constraints.DEMAND,\n",
+    "            Constraints.INVENTORY,\n",
+    "            Constraints.NETWORK,\n",
+    "            }, objective=Objective.MIN_DISCHARGE, objective_resource = CO2_Vent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e6956da2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set parameter QCPDual to value 1\n",
+      "Gurobi Optimizer version 10.0.2 build v10.0.2rc0 (win64)\n",
+      "\n",
+      "CPU model: Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz, instruction set [SSE2|AVX|AVX2]\n",
+      "Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n",
+      "\n",
+      "Optimize a model with 151 rows, 145 columns and 304 nonzeros\n",
+      "Model fingerprint: 0xdd9b2c78\n",
+      "Variable types: 137 continuous, 8 integer (8 binary)\n",
+      "Coefficient statistics:\n",
+      "  Matrix range     [5e-01, 1e+06]\n",
+      "  Objective range  [1e+00, 1e+00]\n",
+      "  Bounds range     [1e+00, 1e+00]\n",
+      "  RHS range        [1e+02, 1e+10]\n",
+      "Warning: Model contains large rhs\n",
+      "         Consider reformulating model or setting NumericFocus parameter\n",
+      "         to avoid numerical issues.\n",
+      "Presolve removed 151 rows and 145 columns\n",
+      "Presolve time: 0.00s\n",
+      "Presolve: All rows and columns removed\n",
+      "\n",
+      "Explored 0 nodes (0 simplex iterations) in 0.01 seconds (0.00 work units)\n",
+      "Thread count was 1 (of 8 available processors)\n",
+      "\n",
+      "Solution count 2: 84.7052 84.7052 \n",
+      "\n",
+      "Optimal solution found (tolerance 1.00e-04)\n",
+      "Best objective 8.470520471130e+01, best bound 8.470520471130e+01, gap 0.0000%\n",
+      "WARNING: Cannot get duals for MIP.\n"
+     ]
+    }
+   ],
+   "source": [
+    "results_em =solve(scenario= scenario, instance=lp_em , solver='gurobi', name='lp')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "4a656475",
+   "metadata": {},
+   "source": [
+    "## Trade-off Result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b9e32853",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Costs \n",
+    "min_cost_x = results_min_cost.output['objective'] \n",
+    "eff_x = sum(results_eff.output['B_network'].values()) +  sum(results_eff.output['Capex_network'].values()) + sum(results_eff.output['Vopex_network'].values())\n",
+    "em_x = results_em.output['Cost'][None]\n",
+    "x_ = [min_cost_x, eff_x, em_x]\n",
+    "# Emissions\n",
+    "min_cost_y = results_min_cost.output['S_network'][('CO2_Vent', 0)]\n",
+    "eff_y = results_eff.output['S_network'][('CO2_Vent', 0)]\n",
+    "em_y = results_em.output['S_network'][('CO2_Vent', 0)]\n",
+    "y_ = [min_cost_y, eff_y, em_y]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f23d364d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import rc \n",
+    "rc('font', **{'family': 'serif',\n",
+    "    'serif': ['Computer Modern'], 'size': 16})\n",
+    "fig, ax = plt.subplots(figsize= (9,6))\n",
+    "plt.title('Trade-off between cost and emission')\n",
+    "plt.ylabel('Emission (kg.CO2-eq)')\n",
+    "plt.xlabel('Cost ($)')\n",
+    "ax.scatter(min_cost_x, min_cost_y, label = 'Min Cost')\n",
+    "ax.scatter(em_x, em_y, label = 'Min Emission')\n",
+    "ax.scatter(eff_x, eff_y, label = 'Max Efficiency')\n",
+    "plt.legend()\n",
+    "plt.grid(alpha=0.3)\n",
+    "plt.rcdefaults()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/setup.py b/setup.py
index 93efe7dd..7a97621b 100644
--- a/setup.py
+++ b/setup.py
@@ -39,7 +39,9 @@ def setup_package():
             'openpyxl',
             'ppopt',
             'gurobipy',
-            'distfit'
+            'distfit',
+            'pvlib',
+            'windpowerlib'
         ],
         extras_require={
             'test': ['pytest'],
diff --git a/src/energiapy/aggregation/__init__.py b/src/energiapy/aggregation/__init__.py
index e69de29b..b5cc4252 100644
--- a/src/energiapy/aggregation/__init__.py
+++ b/src/energiapy/aggregation/__init__.py
@@ -0,0 +1,2 @@
+from .reduce_scenario import reduce_scenario, Clustermethod
+from .ahc import agg_hierarchial_elbow, IncludeAHC, Fit
diff --git a/src/energiapy/components/__init__.py b/src/energiapy/components/__init__.py
index b38fc4ef..2bd604e6 100644
--- a/src/energiapy/components/__init__.py
+++ b/src/energiapy/components/__init__.py
@@ -9,3 +9,15 @@
 __maintainer__ = "Rahul Kakodkar"
 __email__ = "cacodcar@tamu.edu"
 __status__ = "Production"
+
+from .case_study import CaseStudy
+from .emission import Emission
+from .location import Location
+from .material import Material
+from .network import Network
+from .process import Process, VaryingProcess, ProcessRamp
+from .resource import Resource, VaryingResource
+from .result import Result
+from .scenario import Scenario
+from .temporal_scale import TemporalScale
+from .transport import Transport
diff --git a/src/energiapy/components/location.py b/src/energiapy/components/location.py
index 463a8ae5..cbc43c79 100644
--- a/src/energiapy/components/location.py
+++ b/src/energiapy/components/location.py
@@ -19,7 +19,7 @@
 from pandas import DataFrame
 
 from ..components.material import Material
-from ..components.process import Process, ProcessMode
+from ..components.process import Process, ProcessMode, MaterialMode
 from ..components.resource import Resource
 from ..components.temporal_scale import TemporalScale
 from ..utils.process_utils import create_storage_process
@@ -103,8 +103,21 @@ def __post_init__(self):
         self.scale_levels = self.scales.scale_levels
         self.processes_full = self.processes.union({create_storage_process(
             i) for i in self.processes if i.processmode == ProcessMode.STORAGE})
-        self.prod_max = self.get_prod_max()  # dicitionary of maximum production
-        self.prod_min = self.get_prod_min()  # dictionary of minimum production
+        self.cap_max = self.get_cap_max()  # dicitionary of maximum production
+        self.cap_min = self.get_cap_min()  # dictionary of minimum production
+        # gets the modes for all processes
+        self.modes_dict = {p: p.modes for p in self.processes_full if p.modes}
+        # gets the ramp_rates for all processes
+        self.ramp_rates_dict = {p: p.ramp_rates for p in self.processes_full}
+        # gets the cap_pwl for all processes
+        self.cap_pwl_dict = {p: p.cap_pwl for p in self.processes_full}
+        # gets the ramp sequences for all processes
+        self.ramp_sequence_dict = {
+            p: p.ramp_sequence for p in self.processes_full}
+        self.modes_all_dict = {p: {'modes': self.modes_dict[p], 'ramp_rates': self.ramp_rates_dict[p],
+                                   'cap_pwl': self.cap_pwl_dict[p], 'ramp_sequence': self.ramp_sequence_dict[p]} if p.processmode == ProcessMode.MULTI else {'modes': None, 'ramp_rates': None,
+                                                                                                                                                             'cap_pwl': None, 'ramp_sequence': None} for p in self.processes_full}
+
         self.resource_price = self.get_resource_price()  # dictionary of resource prices
         # dictionary of resource selling prices
         self.resource_revenue = self.get_resource_revenue()
@@ -224,7 +237,18 @@ def get_materials(self) -> Set[Material]:
         if len(self.processes) == 0:
             return None
         else:
-            return set().union(*[set(i.material_cons.keys()) for i in self.processes if i.material_cons is not None])
+            materials = set()
+            for i in self.processes:
+                if i.material_cons is not None:
+                    if isinstance(i.material_cons, dict):
+                        for j in i.material_cons.keys():
+                            materials = materials.union(
+                                set(i.material_cons[j].keys()))
+                    else:
+                        materials = materials.union(
+                            set(i.material_cons.keys()))
+                        # return set().union(*[set(i.material_cons.keys()) for i in self.processes if i.material_cons is not None])
+            return materials
 
     def get_resource_price(self) -> dict:
         """gets resource prices for resources with non-varying costs
@@ -263,32 +287,58 @@ def make_fail_factor(self) -> dict:
         return {process_.name: {(scale_): sample([0] * int(process_.p_fail * 100) + [1] * int(
             (1 - process_.p_fail) * 100), 1)[0] for scale_ in scale_iter} for process_ in self.failure_processes}
 
-    def get_prod_max(self) -> dict:
+    def get_cap_max(self) -> dict:
         """
         make a dictionary with maximum production
         """
-        prod_max_dict = {}
+        cap_max_dict = {}
         for i in self.processes_full:
-            if i.processmode == ProcessMode.MULTI:
-                prod_max_dict[i.name] = i.prod_max
-            else:
-                prod_max_dict[i.name] = {j: None for j in self.scales.scale[0]}
+            if i.materialmode == MaterialMode.MULTI:
+                cap_max_dict[i.name] = {j: None for j in self.scales.scale[0]}
                 for j in self.scales.scale[0]:
-                    prod_max_dict[i.name][j] = i.prod_max
-        return prod_max_dict
-
-    def get_prod_min(self) -> dict:
+                    cap_max_dict[i.name][j] = i.cap_max
+            else:
+                if i.processmode == ProcessMode.MULTI:
+                    cap_max_dict[i.name] = i.cap_max
+                else:
+                    cap_max_dict[i.name] = {
+                        j: None for j in self.scales.scale[0]}
+                    for j in self.scales.scale[0]:
+                        cap_max_dict[i.name][j] = i.cap_max
+        return cap_max_dict
+
+    def get_cap_min(self) -> dict:
         """
         make a dictionary with minimum production
         """
-        prod_min_dict = {}
+        cap_min_dict = {}
         for i in self.processes_full:
-            if i.processmode == ProcessMode.MULTI:
-                prod_min_dict[i.name] = i.prod_min
+            if i.materialmode == MaterialMode.MULTI:
+                cap_min_dict[i.name] = {j: None for j in self.scales.scale[0]}
+                for j in self.scales.scale[0]:
+                    cap_min_dict[i.name][j] = i.cap_min
             else:
-                prod_min_dict[i.name] = {0: None}
-                prod_min_dict[i.name][0] = i.prod_min
-        return prod_min_dict
+                if i.processmode == ProcessMode.MULTI:
+                    cap_min_dict[i.name] = i.cap_min
+                else:
+                    cap_min_dict[i.name] = {
+                        j: None for j in self.scales.scale[0]}
+                    for j in self.scales.scale[0]:
+                        cap_min_dict[i.name][j] = i.cap_min
+        return cap_min_dict
+
+    # def get_cap_min(self) -> dict:
+    #     """
+    #     make a dictionary with minimum production
+    #     """
+    #     cap_min_dict = {}
+    #     for i in self.processes_full:
+    #         if i.processmode == ProcessMode.MULTI:
+    #             cap_min_dict[i.name] = i.cap_min
+    #         else:
+    #             cap_min_dict[i.name] = {0: None}
+    #             cap_min_dict[i.name][0] = i.cap_min
+    #     return cap_min_dict
 
     def __repr__(self):
         return self.name
diff --git a/src/energiapy/components/material.py b/src/energiapy/components/material.py
index 6becfe3d..8e3c41be 100644
--- a/src/energiapy/components/material.py
+++ b/src/energiapy/components/material.py
@@ -26,6 +26,11 @@ class Material:
         resource_cons (Dict[Resource, float], optional): Resources consumed per unit basis of Material. Defaults to 0.
         basis (str, optional): Unit basis for material. Defaults to 'unit.
         gwp (float, optional): global warming potential per unit basis of Material produced. Defaults to 0.
+        odp (float, optional): ozone depletion potential per unit basis of Material produced. Defaults to 0.
+        acid (float, optional): acidification potential per unit basis of Material produced. Defaults to 0.
+        eutt (float, optional): terrestrial eutrophication potential per unit basis of Material produced. Defaults to 0.
+        eutf (float, optional): fresh water eutrophication potential per unit basis of Material produced. Defaults to 0.
+        eutm (float, optional): marine eutrophication potential per unit basis of Material produced. Defaults to 0.
         toxicity (float, optional): toxicity potential per unit basis of Material produced. Defaults to 0.
         citation (str, optional): Add citation. Defaults to 'citation needed'.
         label (str, optional): Longer descriptive label if required. Defaults to ''
@@ -39,12 +44,21 @@ class Material:
 
     name: str
     resource_cons: Dict[Resource, float] = None
-    gwp: float = None
+    gwp: float = 0
+    odp: float = 0
+    acid: float = 0
+    eutt: float = 0
+    eutf: float = 0
+    eutm: float = 0
     toxicity: float = None
     basis: str = 'unit'
     citation: str = 'citation needed'
     label: str = ''
 
+    def __post_init__(self):
+        self.emission_potentials_dict = {'gwp': self.gwp, 'odp': self.odp,
+                                         'acid': self.acid, 'eutt': self.eutt, 'eutf': self.eutf, 'eutm': self.eutm}
+
     def __repr__(self):
         return self.name
 
diff --git a/src/energiapy/components/process.py b/src/energiapy/components/process.py
index 6cfc1b06..a1b4bb5e 100644
--- a/src/energiapy/components/process.py
+++ b/src/energiapy/components/process.py
@@ -14,7 +14,7 @@
 from enum import Enum, auto
 from typing import Dict, Union, List, Tuple
 from warnings import warn
-
+from itertools import product
 from ..components.material import Material
 from ..components.resource import Resource
 from ..utils.resource_utils import create_storage_resource
@@ -52,6 +52,20 @@ class ProcessMode(Enum):
     """
 
 
+class MaterialMode(Enum):
+    """
+    Mode for materials 
+    """
+    SINGLE = auto()
+    """
+    Allows only single material 
+    """
+    MULTI = auto()
+    """
+    Can use multiple material combinations 
+    """
+
+
 class VaryingProcess(Enum):
     """
     The type of process capacity variability
@@ -86,6 +100,37 @@ class VaryingProcess(Enum):
     """
 
 
+@dataclass
+class ProcessRamp:
+    modes: list
+    cap_pwl: Dict
+    rates: Dict
+    sequence: Dict
+
+    def __post_init__(self):
+        sequence_fix = {i: False for i in [
+            k for k in product(self.modes, self.modes)]}
+        rates_fix = {i: 0 for i in [
+            k for k in product(self.modes, self.modes)]}
+
+        for i in sequence_fix.keys():
+            if i in self.sequence.keys():
+                sequence_fix[i[::-1]] = self.sequence[i]
+                sequence_fix[i] = self.sequence[i]
+            if i[0] == i[1]:
+                sequence_fix[i] = True
+        self.sequence = sequence_fix
+
+        for i in rates_fix.keys():
+            if i in self.rates.keys():
+                rates_fix[i] = self.rates[i]
+        self.rates = rates_fix
+
+        if list(self.cap_pwl.keys()) != self.modes:
+            warn(
+                'The Piece Wise Linear bounds for capacities should match the declared modes')
+
+
 @dataclass
 class Process:
     """
@@ -93,19 +138,24 @@ class Process:
 
     Args:
         name (str): name of process, short ones are better to deal with.
-        conversion (Union[Dict[int,Dict[Resource, float]], Dict[Resource, float]], optional): conversion data (Dict[Resource, float]]), if multimode the of form Dict[int,Dict[Resource, float]]. Defaults to None.
+        conversion (Union[Dict[Union[int, str],Dict[Resource, float]], Dict[Resource, float]], optional): conversion data (Dict[Resource, float]]), if multimode the of form Dict[int,Dict[Resource, float]]. Defaults to None.
         introduce (int, optional): Time period in the network scale when introduced. Defaults to 0.
         retire (int, optional): Time period in the network scale when retired. Defaults to None.
         capex (Union[float, dict], None): Capital expenditure per unit basis, can be scaled with capacity. Defaults to None.
         fopex (Union[float, dict], None): Fixed operational expenditure per unit basis, can be scaled with capacity. Defaults to None.
         vopex (Union[float, dict], None): Variable operational expenditure per unit basis, can be scaled with capacity. Defaults to None.
         incidental (float, None): Incidental expenditure. Defaults to None.
-        material_cons (Dict[Material, float], optional): Materials consumed per unit basis of production capacity. Defaults to None.
-        prod_max (float, optional): Maximum production capacity allowed in a time period of the scheduling scale. Defaults to 0.
-        prod_min (float, optional): Minimum production capacity allowed in a time period of the scheduling scale. Defaults to 0.
+        material_cons (Union[Dict[Union[int, str], Dict[Material, float]],Dict[Material, float]], optional): Materials consumed per unit basis of production capacity. Defaults to None.
+        cap_max (float, optional): Maximum production capacity allowed in a time period of the scheduling scale. Defaults to 0.
+        cap_min (float, optional): Minimum production capacity allowed in a time period of the scheduling scale. Defaults to 0.
         credit (float, None): credit earned per unit basis of production. Defaults to None.
         basis(str, optional): base units for operation. Defaults to 'unit'.
         gwp (float, optional): global warming potential for settting up facility per unit basis. Defaults to 0.
+        odp (float, optional): ozone depletion potential for settting up facility per unit basis. Defaults to 0.
+        acid (float, optional): acidification potential for settting up facility per unit basis. Defaults to 0.
+        eutt (float, optional): terrestrial eutrophication potential for settting up facility per unit basis. Defaults to 0.
+        eutf (float, optional): fresh water eutrophication potential for settting up facility per unit basis. Defaults to 0.
+        eutm (float, optional): marine eutrophication potential for settting up facility per unit basis. Defaults to 0.
         land (float, optional): land requirement per unit basis. Defaults to 0.
         trl (str, optional): technology readiness level. Defaults to None.
         block (str, optional): define block for convenience. Defaults to None.
@@ -125,33 +175,39 @@ class Process:
     Examples:
         For processes with varying production capacity
 
-        >>> WF = Process(name='WF', conversion={Wind: -1, Power: 1}, capex= 100, Fopex= 10, Vopex= 1,prod_max=100, gwp=52700, land= 90, basis = 'MW', block='power', label='Wind mill array')
+        >>> WF = Process(name='WF', conversion={Wind: -1, Power: 1}, capex= 100, Fopex= 10, Vopex= 1,cap_max=100, gwp=52700, land= 90, basis = 'MW', block='power', label='Wind mill array')
 
         For process with multiple modes of operation
 
-        >>> PEM = Process(name = 'PEM', conversion = {1: {Power: -1, H2: 19.474, O2: 763.2, H2O: -175.266}, 2: {Power: -1, H2: 1.2*19.474, O2: 1.2*763.2, H2O: 1.2*-175.266}, prod_max= 100, capex = 784000, label = 'PEM Electrolysis')
+        >>> PEM = Process(name = 'PEM', conversion = {1: {Power: -1, H2: 19.474, O2: 763.2, H2O: -175.266}, 2: {Power: -1, H2: 1.2*19.474, O2: 1.2*763.2, H2O: 1.2*-175.266}, cap_max= 100, capex = 784000, label = 'PEM Electrolysis')
 
         For process with multiple resource inputs
 
-        >>> CoolCar = Process(name = 'CoolCar', conversion = {1: {Power: -1, Mile: 1}, 2: {H2: -1, Mile:2}, prod_max= 50, capex = 70, label = 'CoolCar')
+        >>> CoolCar = Process(name = 'CoolCar', conversion = {1: {Power: -1, Mile: 1}, 2: {H2: -1, Mile:2}, cap_max= 50, capex = 70, label = 'CoolCar')
 
     """
 
     name: str
     introduce: int = 0
     retire: int = None
-    conversion: Union[Dict[int, Dict[Resource, float]],
+    conversion: Union[Dict[Union[int, str], Dict[Resource, float]],
                       Dict[Resource, float]] = None
     capex: Union[float, dict] = 0
     fopex: Union[float, dict] = 0
     vopex: Union[float, dict] = 0
     incidental: Union[float, dict] = 0
-    material_cons: Dict[Material, float] = None
-    prod_max: Union[Dict[int, float], float] = 0
-    prod_min: float = 0
+    material_cons: Union[Dict[Union[int, str],
+                              Dict[Material, float]], Dict[Material, float]] = None
+    cap_max: Union[Dict[int, float], float] = 0
+    cap_min: float = 0
     basis: str = 'unit'
     credit: float = None
     gwp: float = 0
+    odp: float = 0
+    acid: float = 0
+    eutt: float = 0
+    eutf: float = 0
+    eutm: float = 0
     land: float = 0
     trl: str = None
     block: str = ''
@@ -164,10 +220,13 @@ class Process:
     storage_loss: float = 0
     store_max: float = 0
     store_min: float = 0
-    rate_max: Union[Dict[int, float], float] = None
+    ramp: ProcessRamp = None
+    # rate_max: Union[Dict[int, float], float] = None
     varying_bounds: Tuple[float] = (0, 1)
-    mode_ramp: Dict[tuple, int] = None
+    # mode_ramp: Dict[tuple, int] = None
     storage_cost: float = 0
+    processmode: ProcessMode = None
+    materialmode: MaterialMode = None
 
     def __post_init__(self):
         """Determines the ProcessMode, CostDynamics, and kicks out dummy resources if process is stores resource
@@ -178,6 +237,21 @@ def __post_init__(self):
             conversion_discharge (Dict[Resource, float]): Creates a dictionary with the discharge conversion values (considers storage loss).
             cost_dynamics (CostDynamics): Determines whether the cost scales linearly with the unit capacity, or is a piecewise-linear function.
         """
+        if self.processmode is None:
+            self.processmode = ProcessMode.SINGLE
+
+        if self.ramp is not None:
+            self.modes = self.ramp.modes
+            self.cap_pwl = self.ramp.cap_pwl
+            self.ramp_rates = self.ramp.rates
+            self.ramp_sequence = self.ramp.sequence
+            self.processmode = ProcessMode.MULTI
+
+        else:
+            self.modes = None
+            self.cap_pwl = None
+            self.ramp_rates = None
+            self.ramp_sequence = None
 
         if self.varying is None:  # if nothing is varying, set defaults to CERTAIN_X
             self.varying = []
@@ -185,19 +259,16 @@ def __post_init__(self):
                 self.varying = self.varying + \
                     [VaryingProcess.CERTAIN_EXPENDITURE]
             # if maximum production is dictionary, that means that the process uses multiple modes
-            if isinstance(self.prod_max, dict):
+            if isinstance(self.cap_max, dict):
                 self.varying = self.varying + [VaryingProcess.MULTIMODE]
             else:
-                if self.prod_max > 0:
+                if self.cap_max > 0:
                     self.varying = self.varying + \
                         [VaryingProcess.CERTAIN_CAPACITY]
 
         if not isinstance(self.varying, list):
             warn('Provide a list of VaryingProcess enums')
 
-        if self.material_cons is None:
-            self.material_cons = {}
-
         if self.storage is not None:
             self.resource_storage = create_storage_resource(
                 process_name=self.name, resource=self.storage, store_max=self.store_max, store_min=self.store_min)  # create a dummy resource if process is storage type.
@@ -210,33 +281,51 @@ def __post_init__(self):
         else:
             self.conversion_discharge = None
             self.resource_storage = None
-            if isinstance(list(self.conversion.keys())[0], int):
+            if isinstance(list(self.conversion.keys())[0], (int, str)):
                 self.processmode = ProcessMode.MULTI
             else:
                 self.processmode = ProcessMode.SINGLE
 
+        if self.material_cons is not None:
+            if isinstance(list(self.material_cons.keys())[0], (int, str)):
+                self.materialmode = MaterialMode.MULTI
+            else:
+                self.materialmode = MaterialMode.SINGLE
+        else:
+            self.material_cons = {}
+
         if isinstance(self.capex, (int, float)):
             self.cost_dynamics = CostDynamics.CONSTANT
         elif isinstance(self.capex, dict):
             # Capex dictionaries are only provided for piece-wise linear cost functions
             self.cost_dynamics = CostDynamics.PWL
 
-        if self.processmode is ProcessMode.MULTI:
-            self.resource_req = {
-                i.name for i in self.conversion[list(self.conversion.keys())[0]].keys()}  # the required resources are drawn from the conversion dict, this includes stored resource
+        if (self.processmode is ProcessMode.MULTI) or (self.materialmode is MaterialMode.MULTI):
+            if self.processmode is ProcessMode.STORAGE:
+                self.resource_req = {i.name for i in self.conversion.keys()}
+            else:
+                self.resource_req = {
+                    i.name for i in self.conversion[list(self.conversion.keys())[0]].keys()}  # the required resources are drawn from the conversion dict, this includes stored resource
         else:
             self.resource_req = {i.name for i in self.conversion.keys()}
 
         if self.processmode == ProcessMode.MULTI:
-            if list(self.prod_max.keys()) != list(self.conversion.keys()):
-                warn(
-                    'The keys for prod_max and conversion need to match if ProcessMode.multi')
+            if isinstance(self.cap_max, dict):
+                if list(self.cap_max.keys()) != list(self.conversion.keys()):
+                    warn(
+                        'The keys for cap_max and conversion need to match if ProcessMode.multi')
 
         if self.cost_dynamics == CostDynamics.PWL:
             self.capacity_segments = list(self.capex.keys())
-            self.capex_segements = list(self.capex.values())
+            self.capex_segments = list(self.capex.values())
 
+        self.material_modes = set(self.material_cons.keys())
         # self.emission_dict = {i: i.emissions for i in self.conversion.keys()}
+        self.emission_potentials_dict = {'gwp': self.gwp, 'odp': self.odp,
+                                         'acid': self.acid, 'eutt': self.eutt, 'eutf': self.eutf, 'eutm': self.eutm}
+
+        self.material_modes = set(self.material_cons.keys())
+        # self.emission_dict = {i: i.emissions for i in self.conversion.keys()
 
     def __repr__(self):
         return self.name
diff --git a/src/energiapy/components/resource.py b/src/energiapy/components/resource.py
index 37e1ec16..55dfe6ca 100644
--- a/src/energiapy/components/resource.py
+++ b/src/energiapy/components/resource.py
@@ -94,6 +94,11 @@ class Resource:
         varying (bool, optional): If the cost of resource is varying/uncertain. Defaults to False.
         label (str, optional): Longer descriptive label if required. Defaults to ''.
         gwp (float, optional): Global Warming Potential per unit consumption of resource. Defaults to 0.
+        odp (float, optional): ozone depletion potential per unit basis of Resource produced. Defaults to 0.
+        acid (float, optional): acidification potential per unit basis of Resource produced. Defaults to 0.
+        eutt (float, optional): terrestrial eutrophication potential per unit basis of Resource produced. Defaults to 0.
+        eutf (float, optional): fresh water eutrophication potential per unit basis of Resource produced. Defaults to 0.
+        eutm (float, optional): marine eutrophication potential per unit basis of Resource produced. Defaults to 0.
         varying_bounds (float, optional): bounds for the variability in case of uncertain (for parametric formulation). Defaults to (0,1)
 
 
@@ -126,36 +131,83 @@ class Resource:
     varying: List[VaryingResource] = None
     label: str = ''
     gwp: float = 0
+    odp: float = 0
+    acid: float = 0
+    eutt: float = 0
+    eutf: float = 0
+    eutm: float = 0
     varying_bounds: Tuple[float] = (0, 1)
     # emissions: (Dict[Emission, float]) = None
 
     def __post_init__(self):
+
+        self.emission_potentials_dict = {'gwp': self.gwp, 'odp': self.odp,
+                                         'acid': self.acid, 'eutt': self.eutt, 'eutf': self.eutf, 'eutm': self.eutm}
         if self.demand is True:
             self.sell = True
 
         if self.varying is None:
             self.varying = []  # if varying is none default to certain availability and price
-            if self.cons_max > 0:
+        if self.cons_max > 0:
+            if (VaryingResource.UNCERTAIN_AVAILABILITY not in self.varying) and (VaryingResource.DETERMINISTIC_AVAILABILITY not in self.varying):
                 self.varying = self.varying + \
-                    [VaryingResource.CERTAIN_AVAILABILITY,
-                        VaryingResource.CERTAIN_PRICE]
+                    [VaryingResource.CERTAIN_AVAILABILITY]
 
-            if self.demand is True:  # if varying is none, but demand is true, set certain demand
+            if (VaryingResource.UNCERTAIN_PRICE not in self.varying) and (VaryingResource.DETERMINISTIC_PRICE not in self.varying):
                 self.varying = self.varying + \
-                    [VaryingResource.CERTAIN_DEMAND]
-            else:
-                if self.sell is True:  # sell and demand True, both only differ in the sense that demand sells at a fix rate
-                    self.varying = self.varying + \
-                        [VaryingResource.CERTAIN_DEMAND]
+                    [VaryingResource.CERTAIN_PRICE]
 
-            if self.revenue is True:  # if varying is none and revenue is True, default to certain revenue
+        if self.demand is True:  # if varying is none, but demand is true, set certain demand
+            if (VaryingResource.UNCERTAIN_DEMAND not in self.varying) and (VaryingResource.DETERMINISTIC_DEMAND not in self.varying):
+                self.varying = self.varying + \
+                    [VaryingResource.CERTAIN_DEMAND]
+            if (VaryingResource.UNCERTAIN_REVENUE not in self.varying) and (VaryingResource.DETERMINISTIC_REVENUE not in self.varying):
                 self.varying = self.varying + \
                     [VaryingResource.CERTAIN_REVENUE]
-            if self.varying == []:  # if none of these get filled. That means that the resource is only produced implicitly
-                self.varying = [VaryingResource.IMPLICIT]
+        else:
+            if self.sell is True:  # sell and demand True, both only differ in the sense that demand sells at a fix rate
+                if (VaryingResource.UNCERTAIN_REVENUE not in self.varying) and (VaryingResource.DETERMINISTIC_REVENUE not in self.varying):
+                    self.varying = self.varying + \
+                        [VaryingResource.CERTAIN_REVENUE]
+        # if self.revenue is True:  # if varying is none and revenue is True, default to certain revenue
+        #     self.varying = self.varying + \
+        #         [VaryingResource.CERTAIN_REVENUE]
+        if self.varying == []:  # if none of these get filled. That means that the resource is only produced implicitly
+            self.varying = [VaryingResource.IMPLICIT]
+
+        # else:
+
+        #     if self.cons_max > 0:
+        #         if VaryingResource.DETERMINISTIC_AVAILABILITY not in self.varying:
+        #             self.varying = self.varying + \
+        #                 [VaryingResource.CERTAIN_AVAILABILITY]
+
+        #         if VaryingResource.DETERMINISTIC_PRICE not in self.varying:
+        #             self.varying = self.varying + \
+        #                 [VaryingResource.CERTAIN_PRICE]
+
+        #     if self.demand is True:
+        #         if VaryingResource.DETERMINISTIC_DEMAND not in self.varying:
+        #             self.varying = self.varying + \
+        #                 [VaryingResource.CERTAIN_DEMAND]
+        #         if VaryingResource.DETERMINISTIC_REVENUE not in self.varying:
+        #             self.varying = self.varying + \
+        #                 [VaryingResource.CERTAIN_REVENUE]
+        #     else:
+        #         if self.sell is True:
+        #             if VaryingResource.DETERMINISTIC_REVENUE not in self.varying:
+        #                 self.varying = self.varying + \
+        #                     [VaryingResource.CERTAIN_REVENUE]
+
         if not isinstance(self.varying, list):
             warn('Provide a list of VaryingResource enums')
 
+        if (VaryingResource.DETERMINISTIC_PRICE in self.varying) and (self.price == 0):
+            warn('Varying prices are normalized, provide non-zero price')
+
+        if (VaryingResource.DETERMINISTIC_AVAILABILITY in self.varying) and (self.cons_max == 0):
+            warn('Varying availability is normalized, provide non-zero cons_max')
+
     def __repr__(self):
         return self.name
 
diff --git a/src/energiapy/components/scenario.py b/src/energiapy/components/scenario.py
index 952bf6ea..0369fad9 100644
--- a/src/energiapy/components/scenario.py
+++ b/src/energiapy/components/scenario.py
@@ -23,6 +23,7 @@
 from ..components.resource import Resource, VaryingResource
 from ..components.temporal_scale import TemporalScale
 from ..model.bounds import CapacityBounds
+from ..model.weights import EmissionWeights
 
 
 @dataclass
@@ -46,8 +47,9 @@ class Scenario:
         capacity_bounds (CapacityBounds, optional): bounds on the capacity, useful for multi-period formulations. Defaults to None.
         annualization_factor (float, optional): the annualization factor for Capex. Defaults to 1.
         demand_penalty (Dict[Location, Dict[Resource, float]]): penalty for unmet demand at location for each resource. Defaults to None.
-        error (float): error introduced through scenario reduction
-        rep_days_dict (dict): dictionary of representative days
+        error (float, optional): error introduced through scenario reduction. Defaults to None.
+        rep_days_dict (dict, optional): dictionary of representative days. Defaults to None.
+        emission_weights (EmissionWeights): dataclass with weights for different emission objectives. Defaults to None. 
     Example:
         The Scenario can be built over a single location. The network here is specified as a single Location. Considering scales (TemporalScale object for a year, [1, 365, 24]), scheduling, expenditure, and demand are met at an hourly level, and network at an annual level.
 
@@ -75,6 +77,7 @@ class Scenario:
     demand_penalty: Dict[Location, Dict[Resource, float]] = None
     error: float = None
     rep_dict: dict = None
+    emission_weights: EmissionWeights = None
 
     def __post_init__(self):
         """
@@ -96,8 +99,8 @@ def __post_init__(self):
             material_set (set): Set of all Material objects.
             conversion (dict): A dictionary with all conversion values for each Process.
             conversion_discharge (dict): A dictionary with all discharge conversions for Process of storage (ProcessMode.STORAGE) type.
-            prod_max (dict): A dictionary with maximum production capacity per timeperiod in the network scale for each Process at each Location.
-            prod_min (dict): A dictionary with minimum production capacity per timeperiod in the network scale for each Process at each Location.
+            cap_max (dict): A dictionary with maximum production capacity per timeperiod in the network scale for each Process at each Location.
+            cap_min (dict): A dictionary with minimum production capacity per timeperiod in the network scale for each Process at each Location.
             cons_max (dict): A dictionary with maximum consumption per timeperiod in the scheduling scale for each Resource at each Location.
             store_max (dict): A dictionary with maximum storage per timeperiod in the scheduling scale for each Resource at each Location.
             store_min (dict): A dictionary with minimum storage per timeperiod in the scheduling scale for each Resource at each Location.
@@ -208,8 +211,8 @@ def __post_init__(self):
         self.conversion = {i.name: {j.name: i.conversion[j] if j in i.conversion.keys(
         ) else 0 for j in self.resource_set} for i in self.process_set if i.conversion is not None}
 
-        self.prod_max = {i.name: i.prod_max for i in self.location_set}
-        self.prod_min = {i.name: i.prod_min for i in self.location_set}
+        self.cap_max = {i.name: i.cap_max for i in self.location_set}
+        self.cap_min = {i.name: i.cap_min for i in self.location_set}
         self.cons_max = {i.name: {
             j.name: j.cons_max for j in i.resources_full} for i in self.location_set}
         self.store_max = {i.name: {
@@ -232,6 +235,12 @@ def __post_init__(self):
             i.name: i.revenue_factor for i in self.location_set}
         self.location_resource_dict = {
             i.name: {j.name for j in i.resources_full} for i in self.location_set}
+        self.location_resource_sell_dict = {
+            i.name: {j.name for j in i.resources_full if j.sell is True} for i in self.location_set}
+        self.location_resource_purch_dict = {
+            i.name: {j.name for j in i.resources_full if j.cons_max > 0} for i in self.location_set}
+        self.location_resource_store_dict = {
+            i.name: {j.name for j in i.resources_full if j.store_max > 0} for i in self.location_set}
         self.location_process_dict = {
             i.name: {j.name for j in i.processes_full} for i in self.location_set}
         self.location_material_dict = {i.name: {j.name for j in i.materials}
@@ -247,10 +256,40 @@ def __post_init__(self):
         self.land_dict = {i.name: i.land for i in self.process_set}
         self.material_gwp_dict = {
             i.name: {j.name: j.gwp for j in self.material_set} for i in self.location_set}
+        self.material_odp_dict = {
+            i.name: {j.name: j.odp for j in self.material_set} for i in self.location_set}
+        self.material_acid_dict = {
+            i.name: {j.name: j.acid for j in self.material_set} for i in self.location_set}
+        self.material_eutt_dict = {
+            i.name: {j.name: j.eutt for j in self.material_set} for i in self.location_set}
+        self.material_eutf_dict = {
+            i.name: {j.name: j.eutf for j in self.material_set} for i in self.location_set}
+        self.material_eutm_dict = {
+            i.name: {j.name: j.eutm for j in self.material_set} for i in self.location_set}
         self.resource_gwp_dict = {
             i.name: {j.name: j.gwp for j in self.resource_set} for i in self.location_set}
+        self.resource_odp_dict = {
+            i.name: {j.name: j.odp for j in self.resource_set} for i in self.location_set}
+        self.resource_acid_dict = {
+            i.name: {j.name: j.acid for j in self.resource_set} for i in self.location_set}
+        self.resource_eutt_dict = {
+            i.name: {j.name: j.eutt for j in self.resource_set} for i in self.location_set}
+        self.resource_eutf_dict = {
+            i.name: {j.name: j.eutf for j in self.resource_set} for i in self.location_set}
+        self.resource_eutm_dict = {
+            i.name: {j.name: j.eutm for j in self.resource_set} for i in self.location_set}
         self.process_gwp_dict = {
             i.name: {j.name: j.gwp for j in self.process_set} for i in self.location_set}
+        self.process_odp_dict = {
+            i.name: {j.name: j.odp for j in self.process_set} for i in self.location_set}
+        self.process_acid_dict = {
+            i.name: {j.name: j.acid for j in self.process_set} for i in self.location_set}
+        self.process_eutt_dict = {
+            i.name: {j.name: j.eutt for j in self.process_set} for i in self.location_set}
+        self.process_eutf_dict = {
+            i.name: {j.name: j.eutf for j in self.process_set} for i in self.location_set}
+        self.process_eutm_dict = {
+            i.name: {j.name: j.eutm for j in self.process_set} for i in self.location_set}
         self.land_cost_dict = {i.name: i.land_cost for i in self.location_set}
         self.fail_factor = {i.name: i.fail_factor for i in self.location_set}
         self.credit_dict = {i.name: {j.name: i.credit[j] for j in i.credit.keys(
@@ -264,6 +303,9 @@ def __post_init__(self):
         #                               self.process_set}
         self.process_material_dict = {
             i.name: {j.name: i.material_cons[j] if j in i.material_cons.keys() else 0 for j in self.material_set} for i in self.process_set}
+
+        self.process_material_mode_material_dict = {i.name: {j: {l.name: m for l, m in k.items(
+        )} for j, k in i.material_cons.items()} for i in self.process_set}
         multiconversion_dict = dict()
         for i in self.process_set:
             if i.processmode == ProcessMode.MULTI:
@@ -281,6 +323,9 @@ def __post_init__(self):
 
         self.mode_dict = {i.name: list(
             self.multiconversion[i.name].keys()) for i in self.process_set}
+        # self.mode_dict = {i: [(k,) for k in j]for i,j in self.mode_dict.items()}
+
+        self.modes_dict = {i: i.modes_dict for i in self.location_set}
 
         if self.demand_penalty is not None:
             self.demand_penalty = {i.name: {j.name: self.demand_penalty[i][j] for j in self.demand_penalty[i].keys(
@@ -295,12 +340,25 @@ def __post_init__(self):
         self.cost_df = df_capex.merge(df_vopex, left_index=True, right_index=True, how='inner').merge(
             df_fopex, left_index=True, right_index=True, how='inner')
 
-        self.rate_max_dict = {i.name: i.rate_max for i in self.process_set}
+        # self.rate_max_dict = {i.name: i.rate_max for i in self.process_set}
 
-        self.mode_ramp_dict = {i.name: i.mode_ramp for i in self.process_set}
+        # self.mode_ramp_dict = {i.name: i.mode_ramp for i in self.process_set}
 
         self.storage_cost_dict = {
             i.name: i.storage_cost_dict for i in self.location_set}
+
+        process_material_modes = []
+        for i in self.process_set:
+            if i.material_cons is not None:
+
+                process_material_modes = process_material_modes + \
+                    [(i.name, j) for j in list(i.material_cons.keys())]
+                if i.material_cons != {}:
+                    self.process_material_modes = process_material_modes
+
+                    self.process_material_modes_dict = {
+                        i.name: i.material_modes for i in self.process_set}
+
         set_dict = {
             'resources': [i.name for i in self.resource_set],
 
@@ -376,22 +434,13 @@ def __post_init__(self):
             'locations': [i.name for i in self.location_set],
             'materials': [i.name for i in self.material_set],
 
-            'transports_certain_capacity': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_CAPACITY in i.varying],
-            'transports_certain_capex': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_CAPEX in i.varying],
-            'transports_certain_vopex': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_VOPEX in i.varying],
-            'transports_certain_fopex': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_FOPEX in i.varying],
-
-            'transports_uncertain_capacity': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_CAPACITY in i.varying],
-            'transports_uncertain_capex': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_CAPEX in i.varying],
-            'transports_uncertain_vopex': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_VOPEX in i.varying],
-            'transports_uncertain_fopex': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_FOPEX in i.varying],
+            'process_material_modes': process_material_modes,
 
-            'transports_varying_capacity': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_CAPACITY in i.varying],
-            'transports_varying_capex': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_CAPEX in i.varying],
-            'transports_varying_vopex': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_VOPEX in i.varying],
-            'transports_varying_fopex': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_FOPEX in i.varying],
+            'material_modes': [element for dictionary in list(i.material_modes for i in self.process_set) for element in dictionary],
 
+            'process_modes': [(j[0], i) for j in [(i.name, i.modes) for i in self.process_set if i.processmode is ProcessMode.MULTI] for i in j[1]]
         }
+
         self.varying_bounds_dict = {
             'demand': {i.name: i.varying_bounds for i in self.resource_set if VaryingResource.UNCERTAIN_DEMAND in i.varying},
             'availability': {i.name: i.varying_bounds for i in self.resource_set if VaryingResource.UNCERTAIN_AVAILABILITY in i.varying},
@@ -423,6 +472,25 @@ def __post_init__(self):
 
         self.set_dict = {x: sorted(set_dict[x]) for x in set_dict.keys()}
 
+        if isinstance(self.network, Network):
+            transport_set_dict = {
+                'transports_certain_capacity': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_CAPACITY in i.varying],
+                'transports_certain_capex': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_CAPEX in i.varying],
+                'transports_certain_vopex': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_VOPEX in i.varying],
+                'transports_certain_fopex': [i.name for i in self.transport_set if VaryingTransport.CERTAIN_FOPEX in i.varying],
+
+                'transports_uncertain_capacity': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_CAPACITY in i.varying],
+                'transports_uncertain_capex': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_CAPEX in i.varying],
+                'transports_uncertain_vopex': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_VOPEX in i.varying],
+                'transports_uncertain_fopex': [i.name for i in self.transport_set if VaryingTransport.UNCERTAIN_FOPEX in i.varying],
+
+                'transports_varying_capacity': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_CAPACITY in i.varying],
+                'transports_varying_capex': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_CAPEX in i.varying],
+                'transports_varying_vopex': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_VOPEX in i.varying],
+                'transports_varying_fopex': [i.name for i in self.transport_set if VaryingTransport.DETERMINISTIC_FOPEX in i.varying],
+            }
+            self.set_dict = {**self.set_dict, **transport_set_dict}
+
     def make_conversion_df(self) -> DataFrame:
         """makes a DataFrame of the conversion values
 
@@ -469,7 +537,8 @@ def matrix_form(self):
 
             n_Sf = len(self.set_dict['resources_certain_demand'])
             n_S = len(self.set_dict['resources_uncertain_demand'])
-
+            n_Snd = len([i for i in self.set_dict['resources_sell']
+                         if i not in self.set_dict['resources_demand']])
             n_Af = len(self.set_dict['resources_certain_availability'])
             n_A = len(self.set_dict['resources_uncertain_availability'])
 
@@ -484,9 +553,10 @@ def matrix_form(self):
             n_bal = n_P + n_Pf  # number of production processes for resource balance constraint
 
             # used to balance implicitly made resources
-            n_bal2 = n_Inv + n_Sf + n_S + n_Af + n_A
+            n_bal2 = n_Inv + n_Sf + n_S + n_Snd + n_Af + n_A
 
-            n_vars_fix = n_Inv + n_Sf + n_Af + n_Pf  # total number of fixed variables
+            n_vars_fix = n_Inv + n_Sf + n_Snd + n_Af + \
+                n_Pf  # total number of fixed variables
 
             n_vars_theta = n_S + n_A + n_P  # total number of theta variables
 
@@ -496,8 +566,10 @@ def matrix_form(self):
             print(f"Resource inventory level (Inv) x {n_Inv}")
             print(f"Exact resource discharge (Sf) x {n_Sf}")
             print(f"Uncertain resource discharge (S) x {n_S}")
+            print(f"Resources discharge no demand (Snd) x {n_Snd}")
             print(f"Exact resource availability (Af) x {n_Af}")
             print(f"Uncertain resource availability (A) x {n_A}")
+            print(f"Implicit resource (I) x {n_I}")
             print(f"Exact resource price (Cf) x {n_Cf}")
             print(f"Uncertain resource price (C) x {n_C}")
             print(f"Exact process production (Pf) x {n_Pf}")
@@ -507,7 +579,7 @@ def matrix_form(self):
 
             # *--------------------------------A--------------------------------------
             A_bal = numpy.diag(
-                [*[1] * n_Inv, *[-1] * n_Sf, *[-1] * n_S,  *[1] * n_Af, *[1] * n_A])
+                [*[1] * n_Inv, *[-1] * n_Sf, *[-1] * n_S, *[-1]*n_Snd, *[1] * n_Af, *[1] * n_A])
 
             if n_I > 0:  # if implict variables present, add 0 stacks to matrix
 
@@ -515,6 +587,7 @@ def matrix_form(self):
 
             conversion_list = self.set_dict['resources_store'] + self.set_dict['resources_certain_demand'] + \
                 self.set_dict['resources_uncertain_demand'] + \
+                [i for i in self.set_dict['resources_sell'] if i not in self.set_dict['resources_demand']] + \
                 self.set_dict['resources_certain_availability'] + \
                 self.set_dict['resources_uncertain_availability'] + \
                 self.set_dict['resources_implicit']
@@ -522,6 +595,7 @@ def matrix_form(self):
             column_list_vars = [*['Inv_' + i for i in self.set_dict['resources_store']] +
                                 ['Sf_' + i for i in self.set_dict['resources_certain_demand']] +
                                 ['S_' + i for i in self.set_dict['resources_uncertain_demand']] +
+                                ['Snd_' + i for i in [i for i in self.set_dict['resources_sell'] if i not in self.set_dict['resources_demand']]] +
                                 ['Af_' + i for i in self.set_dict['resources_certain_availability']] +
                                 ['A_' + i for i in self.set_dict['resources_uncertain_availability']] +
                                 ['Pf_' + i for i in self.set_dict['processes_certain_capacity']] +
@@ -531,11 +605,12 @@ def matrix_form(self):
                                   sorted(self.conversion.keys())]).transpose()
 
             A_diag = numpy.diag(
-                [*[1]*n_Inv, *[-1]*n_Sf, *[-1]*n_S,  *[1]*n_Af, *[1] * n_A, *[1]*n_Pf, *[1]*n_P])
+                [*[1]*n_Inv, *[-1]*n_Sf, *[-1]*n_S, *[-1]*n_Snd,  *[1]*n_Af, *[1] * n_A, *[1]*n_Pf, *[1]*n_P])
 
             row_diag = [*['Inv_' + i + '(<)' for i in self.set_dict['resources_store']] +
                         ['Sf_' + i + '(>)' for i in self.set_dict['resources_certain_demand']] +
                         ['S_' + i + '(>)' for i in self.set_dict['resources_uncertain_demand']] +
+                        ['Snd_' + i + '(>)' for i in [i for i in self.set_dict['resources_sell'] if i not in self.set_dict['resources_demand']]] +
                         ['Af_' + i + '(<)' for i in self.set_dict['resources_certain_availability']] +
                         ['A_' + i + '(<)' for i in self.set_dict['resources_uncertain_availability']] +
                         ['Pf_' + i + '(<)' for i in self.set_dict['processes_certain_capacity']] +
@@ -544,12 +619,20 @@ def matrix_form(self):
             row_NN = [*['NN_Inv_' + i + '(>)' for i in self.set_dict['resources_store']] +
                       ['NN_Sf_' + i + '(>)' for i in self.set_dict['resources_certain_demand']] +
                       ['NN_S_' + i + '(>)' for i in self.set_dict['resources_uncertain_demand']] +
+                      ['NN_Snd_' + i + '(>)' for i in [i for i in self.set_dict['resources_sell'] if i not in self.set_dict['resources_demand']]] +
                       ['NN_Af_' + i + '(>)' for i in self.set_dict['resources_certain_availability']] +
                       ['NN_A_' + i + '(>)' for i in self.set_dict['resources_uncertain_availability']] +
                       ['NN_Pf_' + i + '(>)' for i in self.set_dict['processes_certain_capacity']] +
                       ['NN_P_' + i + '(>)' for i in self.set_dict['processes_uncertain_capacity']]]
 
-            row_bal = ['MB_' + i + '(=)' for i in self.set_dict['resources']]
+            row_bal = ['MB_' + i + '(=)' for i in self.set_dict['resources_store']
+                       + self.set_dict['resources_certain_demand']
+                       + self.set_dict['resources_uncertain_demand']
+                       + [i for i in self.set_dict['resources_sell']
+                          if i not in self.set_dict['resources_demand']]
+                       + self.set_dict['resources_certain_availability']
+                       + self.set_dict['resources_uncertain_availability']
+                       + self.set_dict['resources_implicit']]
 
             row_list = row_bal + row_diag + row_NN
 
@@ -572,6 +655,8 @@ def matrix_form(self):
                                 for i in self.set_dict['resources_certain_demand']])  # fixed demand bound
             b_S = numpy.array([[0]
                                for i in self.set_dict['resources_uncertain_demand']])  # uncertain demand
+            b_Snd = numpy.array([[0]
+                                 for i in [i for i in self.set_dict['resources_sell'] if i not in self.set_dict['resources_demand']]])  # sell but no demand
             # b_S = numpy.array([[-self.demand[location][i]]
             #    for i in self.set_dict['resources_uncertain_demand']])  # uncertain demand
             b_Af = numpy.array([[self.cons_max[location][i]]
@@ -579,9 +664,9 @@ def matrix_form(self):
             b_A = numpy.array([[self.cons_max[location][i]]
                                for i in self.set_dict['resources_uncertain_availability']])  # uncertain availability
 
-            b_Pf = numpy.array([[self.prod_max[location][i][0]]
+            b_Pf = numpy.array([[self.cap_max[location][i][0]]
                                 for i in self.set_dict['processes_certain_capacity']])  # fixed production bound
-            # b_P = numpy.array([[self.prod_max[location][i][0]]
+            # b_P = numpy.array([[self.cap_max[location][i][0]]
             #                    for i in self.set_dict['processes_uncertain_capacity']])  # uncertain production
 
             # uncertain production
@@ -590,7 +675,8 @@ def matrix_form(self):
 
             b_nn = numpy.zeros((n_vars, 1))  # non zero constraints
 
-            b_list = [b_bal, b_Inv, b_Sf, b_S, b_Af, b_A, b_Pf, b_P, b_nn]
+            b_list = [b_bal, b_Inv, b_Sf, b_S,
+                      b_Snd, b_Af, b_A, b_Pf, b_P, b_nn]
 
             b = numpy.block([[i]
                             for i in b_list if len(i) > 0])  # make b matrix
@@ -611,16 +697,16 @@ def matrix_form(self):
 
             iter_ = 0
             for i in range(n_A):
-                n = n_Inv + n_Sf + n_S + n_Af
+                n = n_Inv + n_Sf + n_S + n_Snd + n_Af
                 F[n_bal3 + n + iter_][n_S + i] = self.cons_max[location][
                     self.set_dict['resources_uncertain_availability'][i]]
                 iter_ += 1
 
             iter_ = 0
             for i in range(n_P):
-                n = n_Inv + n_Sf + n_S + n_Af + n_A + n_Pf
+                n = n_Inv + n_Sf + n_S + n_Snd + n_Af + n_A + n_Pf
                 F[n_bal3 + n + iter_][n_S + n_A +
-                                      i] = self.prod_max[location][self.set_dict['processes_uncertain_capacity'][i]][0]
+                                      i] = self.cap_max[location][self.set_dict['processes_uncertain_capacity'][i]][0]
                 # defaults to 0 as mode, using P_m instead of P
                 iter_ += 1
 
@@ -633,6 +719,7 @@ def matrix_form(self):
             c_Inv = numpy.zeros((n_Inv, 1))
             c_Sf = numpy.zeros((n_Sf, 1))
             c_S = numpy.zeros((n_S, 1))
+            c_Snd = numpy.zeros((n_Snd, 1))
 
             # c_Af = numpy.zeros((n_Af, 1))
             # c_A = numpy.zeros((n_A, 1))
@@ -646,7 +733,7 @@ def matrix_form(self):
                                 for i in self.set_dict['processes_certain_capacity']])
             c_P = numpy.array([[self.vopex_dict[i]]
                                for i in self.set_dict['processes_uncertain_capacity']])
-            c_list = [c_Inv, c_Sf,  c_S, c_Cf,  c_C, c_Pf, c_P]
+            c_list = [c_Inv, c_Sf,  c_S, c_Snd, c_Cf, c_C, c_Pf, c_P]
             c = numpy.block([[i] for i in c_list if len(i) > 0])
 
             self.c_df = DataFrame(c)
diff --git a/src/energiapy/components/transport.py b/src/energiapy/components/transport.py
index 2b462a22..6996ddb0 100644
--- a/src/energiapy/components/transport.py
+++ b/src/energiapy/components/transport.py
@@ -83,9 +83,9 @@ class Transport:
         material_cons (Dict[Material, float], optional): Materials consumed per unit distance of Transport. Defaults to None.
         introduce (int, optional): when transportation mode is introduced. Defaults to 0.
         retire (int, optional): when transportation mode is retired. Defaults to None
-        trans_max (float, optional): maximum capacity of material that can be transported. Defaults to 0.
+        trans_max (float, optional): maximum capacity of transport that can be set up. Defaults to 0.
+        trans_min (float, optional): minimum capacity of transport that needs to be set up. Defaults to 0.
         trans_loss (float, optional): transport losses per unit basis of Raterial per timeperiod in scheduling scale. Defaults to 0.
-        trans_cost (float, optional): cost per unit distance per unit basis of Resource. Defaults to 0.
         emission (float, optional): emissions per unit distance of transportation. Defaults to 0.
         capex (float, optional): capital expenditure on a per unit distance unit capacity basis. Defaults to 0.
         vopex (float, optional): variable operational expenditure on a per unit distance unit capacity basis. Defaults to 0.
diff --git a/src/energiapy/conversion/photovoltaic.py b/src/energiapy/conversion/photovoltaic.py
index 4a3fe3dd..6e6b158b 100644
--- a/src/energiapy/conversion/photovoltaic.py
+++ b/src/energiapy/conversion/photovoltaic.py
@@ -55,5 +55,5 @@ def solar_power_output(data: pandas.DataFrame, coord: tuple, sam: str = 'cecmod'
     mc.run_model(weather=data)
     output = pandas.DataFrame(numpy.maximum(0, numpy.nan_to_num(
         numpy.array(mc.results.ac))), index=data.index)
-    output.columns = ['PV_Power']
+    output.columns = ['Value']
     return output
diff --git a/src/energiapy/conversion/windmill.py b/src/energiapy/conversion/windmill.py
index 8d56f152..a47a4d35 100644
--- a/src/energiapy/conversion/windmill.py
+++ b/src/energiapy/conversion/windmill.py
@@ -74,4 +74,5 @@ def wind_power_output(data: pandas.DataFrame, roughness_length: float = 0.1, tur
     mc_turbine = WModelChain(turbine, **modelchain_data).run_model(data)
     # write power output time series to WindTurbine object
     output = pandas.DataFrame(mc_turbine.power_output)
+    output.columns = ['Value']
     return output
diff --git a/src/energiapy/model/constraints/constraints.py b/src/energiapy/model/constraints/constraints.py
index d2d1f4fb..37b0ed41 100644
--- a/src/energiapy/model/constraints/constraints.py
+++ b/src/energiapy/model/constraints/constraints.py
@@ -197,9 +197,11 @@ def cons_rule(instance, location, component, *scale):
             #         scale[:x_scale_level + 1]]
 
             else:
-
-                x = getattr(instance, variable_x)[
-                    location, component, scale[:x_scale_level + 1]]
+                if component in loc_comp_dict[location]:
+                    x = getattr(instance, variable_x)[
+                        location, component, scale[:x_scale_level + 1]]
+                else:
+                    x = None
 
             def weight(x): return 1 if cluster_wt is None else cluster_wt[x]
 
@@ -231,26 +233,28 @@ def weight(x): return 1 if cluster_wt is None else cluster_wt[x]
             b = bmax*bfactor
 
             if variable_y is not None:
-                if type_cons == Cons.X_EQ_SUMSCALE_Y:
-                    d_sum = sum(weight(scale_)*getattr(instance, variable_y)[location, component, scale_[
-                                :y_scale_level + 1]] for scale_ in scale_iter if scale_[:x_scale_level + 1] == scale)
-                # elif type_cons == Cons.X_EQ_SUMLOC_Y:
-                    # d_sum = sum(getattr(instance, variable_y)[location_, component, scale[
-                    #             :y_scale_level + 1]] for location_ in location_set)
-                elif type_cons == Cons.X_EQ_SUM_Y:
-                    d_sum = sum(getattr(instance, variable_y)[location_, scale[
-                                :y_scale_level + 1]] for location_ in location_set)
-                elif type_cons == Cons.X_EQ_SUMCOMP_Y:
-                    d_sum = sum(getattr(instance, variable_y)[location, component_, scale[
-                                :y_scale_level + 1]] for component_ in component_set)
-                elif type_cons == Cons.X_EQ_SUMCOST_Y:
-                    d_sum = sum(getattr(instance, variable_y)[location_, scale[
-                                :y_scale_level + 1]] for location_ in location_set)
-
+                if component in loc_comp_dict[location]:
+                    if type_cons == Cons.X_EQ_SUMSCALE_Y:
+                        d_sum = sum(weight(scale_)*getattr(instance, variable_y)[location, component, scale_[
+                                    :y_scale_level + 1]] for scale_ in scale_iter if scale_[:x_scale_level + 1] == scale)
+                    # elif type_cons == Cons.X_EQ_SUMLOC_Y:
+                        # d_sum = sum(getattr(instance, variable_y)[location_, component, scale[
+                        #             :y_scale_level + 1]] for location_ in location_set)
+                    elif type_cons == Cons.X_EQ_SUM_Y:
+                        d_sum = sum(getattr(instance, variable_y)[location_, scale[
+                                    :y_scale_level + 1]] for location_ in location_set)
+                    elif type_cons == Cons.X_EQ_SUMCOMP_Y:
+                        d_sum = sum(getattr(instance, variable_y)[location, component_, scale[
+                                    :y_scale_level + 1]] for component_ in component_set)
+                    elif type_cons == Cons.X_EQ_SUMCOST_Y:
+                        d_sum = sum(getattr(instance, variable_y)[location_, scale[
+                                    :y_scale_level + 1]] for location_ in location_set)
+                    else:
+                        y = getattr(instance, variable_y)[
+                            location, component, scale[:y_scale_level + 1]]
                 else:
-                    y = getattr(instance, variable_y)[
-                        location, component, scale[:y_scale_level + 1]]
-
+                    d_sum = None
+                    y = None
             if loc_comp_dict[location] is not None:
                 if component in loc_comp_dict[location]:
                     if type_cons == Cons.X_LEQ_B:
@@ -278,7 +282,7 @@ def weight(x): return 1 if cluster_wt is None else cluster_wt[x]
                     if type_cons in [Cons.X_EQ_SUMSCALE_Y, Cons.X_EQ_SUMCOMP_Y, Cons.X_EQ_SUMCOST_Y]:
                         return x == d_sum
                 else:
-                    return x == 0
+                    return Constraint.Skip
 
         return Constraint(location_set, component_set, *scales, rule=cons_rule, doc=label)
 
diff --git a/src/energiapy/model/constraints/cost.py b/src/energiapy/model/constraints/cost.py
index 8fea9910..6f4c564c 100644
--- a/src/energiapy/model/constraints/cost.py
+++ b/src/energiapy/model/constraints/cost.py
@@ -18,6 +18,7 @@
 
 from ...utils.latex_utils import constraint_latex_render
 from ...utils.scale_utils import scale_list, scale_tuple
+from ...utils.data_utils import get_depth
 from .constraints import Constraints
 
 
@@ -340,16 +341,38 @@ def constraint_process_capex(instance: ConcreteModel, capex_dict: dict, network_
     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
 
     def process_capex_rule(instance, location, process, *scale_list):
+
+        # if capex_dict[process] is not None:
+        #     if capex_factor[location] is not None:
+        #         if process in list(capex_factor[location].keys()):
+        #             return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_factor[location][process][scale_list]*capex_dict[process]*instance.Cap_P[location, process, scale_list]
+        #         else:
+        #             return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_dict[process]*instance.Cap_P[location, process, scale_list]
+        #     else:
+        #         return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_dict[process]*instance.Cap_P[location, process, scale_list]
+        # else:
+        #     return instance.Capex_process[location, process, scale_list] == 0
+
         if capex_dict[process] is not None:
-            if capex_factor[location] is not None:
-                if process in list(capex_factor[location].keys()):
-                    return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_factor[location][process][scale_list]*capex_dict[process]*instance.Cap_P[location, process, scale_list]
-                else:
-                    return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_dict[process]*instance.Cap_P[location, process, scale_list]
+            Cap_P = instance.Cap_P[location, process, scale_list]
+        else:
+            Cap_P = 0
+
+        if capex_factor[location] is not None:
+            if process in list(capex_factor[location].keys()):
+                capex_fact = capex_factor[location][process][scale_list]
             else:
-                return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_dict[process]*instance.Cap_P[location, process, scale_list]
+                capex_fact = 1
+        else:
+            capex_fact = 1
+
+        if get_depth(capex_dict) == 1:
+            return instance.Capex_process[location, process, scale_list] == annualization_factor*capex_fact*capex_dict[process]*Cap_P
         else:
-            return instance.Capex_process[location, process, scale_list] == 0
+            if hasattr(instance, 'X_M') is True:
+                return instance.Capex_process[location, process, scale_list] == sum(annualization_factor*capex_fact*capex_dict[i[0]][i[1]]*instance.Cap_P_M[location, i[0], i[1], scale_list] for i in instance.process_material_modes if i[0] == process)
+            if hasattr(instance, 'X_P_m') is True:
+                return instance.Capex_process[location, process, scale_list] == sum(annualization_factor*capex_fact*capex_dict[i[0]][i[1]]*Cap_P for i in instance.process_material_modes if i[0] == process)
     instance.constraint_process_capex = Constraint(
         instance.locations, instance.processes, *scales, rule=process_capex_rule, doc='capex for process')
 
@@ -399,12 +422,40 @@ def network_capex_rule(instance, *scale_list):
 # *-------------------------vopex costing constraints----------------------------
 
 
-def constraint_process_vopex(instance: ConcreteModel, vopex_dict: dict, network_scale_level: int = 0, vopex_factor: dict = None, location_process_dict: dict = None) -> Constraint:
-    """Fixed operational expenditure for each process at location in network
+# def constraint_process_vopex(instance: ConcreteModel, vopex_dict: dict, network_scale_level: int = 0, vopex_factor: dict = None, location_process_dict: dict = None) -> Constraint:
+#     """Fixed operational expenditure for each process at location in network
+
+#     Args:
+#         instance (ConcreteModel): pyomo instance
+#         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+
+#     Returns:
+#         Constraint: process_vopex
+#     """
+#     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+#     def process_vopex_rule(instance, location, process, *scale_list):
+#         if vopex_dict[process] is not None:
+#             if vopex_factor[location] is not None:
+#                 return instance.Vopex_process[location, process, scale_list] == vopex_factor[location][process][scale_list]*vopex_dict[process]*instance.P_location[location, process, scale_list]
+#             else:
+#                 return instance.Vopex_process[location, process, scale_list] == vopex_dict[process]*instance.P_location[location, process, scale_list]
+#         else:
+#             return instance.Vopex_process[location, process, scale_list] == 0
+#     instance.constraint_process_vopex = Constraint(
+#         instance.locations, instance.processes, *scales, rule=process_vopex_rule, doc='total vopex from network')
+#     constraint_latex_render(process_vopex_rule)
+#     return instance.constraint_process_vopex
+
+
+def constraint_process_vopex(instance: ConcreteModel, vopex_dict: dict, network_scale_level: int = 0, annualization_factor: float = 1, vopex_factor: dict = None, cost_dynamics: Costdynamics = Costdynamics.constant, location_process_dict: dict = None) -> Constraint:
+    """Capital expenditure for each process at location in network
 
     Args:
         instance (ConcreteModel): pyomo instance
+        vopex_dict (dict): vopex at location
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        annualization_factor (float, optional): Annual depreciation of asset. Defaults to 1.
 
     Returns:
         Constraint: process_vopex
@@ -412,15 +463,30 @@ def constraint_process_vopex(instance: ConcreteModel, vopex_dict: dict, network_
     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
 
     def process_vopex_rule(instance, location, process, *scale_list):
+
         if vopex_dict[process] is not None:
-            if vopex_factor[location] is not None:
-                return instance.Vopex_process[location, process, scale_list] == vopex_factor[location][process][scale_list]*vopex_dict[process]*instance.P_location[location, process, scale_list]
+            P_location = instance.P_location[location, process, scale_list]
+        else:
+            P_location = 0
+
+        if vopex_factor[location] is not None:
+            if process in list(vopex_factor[location].keys()):
+                vopex_fact = vopex_factor[location][process][scale_list]
             else:
-                return instance.Vopex_process[location, process, scale_list] == vopex_dict[process]*instance.P_location[location, process, scale_list]
+                vopex_fact = 1
         else:
-            return instance.Vopex_process[location, process, scale_list] == 0
+            vopex_fact = 1
+
+        if get_depth(vopex_dict) == 1:
+            return instance.Vopex_process[location, process, scale_list] == annualization_factor*vopex_fact*vopex_dict[process]*P_location
+        else:
+            if hasattr(instance, 'X_M') is True:
+                return instance.Vopex_process[location, process, scale_list] == sum(annualization_factor*vopex_fact*vopex_dict[i[0]][i[1]]*instance.P_location_material_m[location, i[0], i[1], scale_list] for i in instance.process_material_modes if i[0] == process)
+            if hasattr(instance, 'X_P_m') is True:
+                return instance.Vopex_process[location, process, scale_list] == sum(annualization_factor*vopex_fact*vopex_dict[i[0]][i[1]]*P_location for i in instance.process_material_modes if i[0] == process)
     instance.constraint_process_vopex = Constraint(
-        instance.locations, instance.processes, *scales, rule=process_vopex_rule, doc='total vopex from network')
+        instance.locations, instance.processes, *scales, rule=process_vopex_rule, doc='vopex for process')
+
     constraint_latex_render(process_vopex_rule)
     return instance.constraint_process_vopex
 
@@ -468,11 +534,12 @@ def network_vopex_rule(instance, *scale_list):
 # *-------------------------fopex costing constraints----------------------------
 
 
-def constraint_process_fopex(instance: ConcreteModel, fopex_dict: dict, network_scale_level: int = 0, fopex_factor: dict = None, annualization_factor: float = 1, location_process_dict: dict = None) -> Constraint:
-    """Fixed operational expenditure for each process at location in network
+def constraint_process_fopex(instance: ConcreteModel, fopex_dict: dict, network_scale_level: int = 0, annualization_factor: float = 1, fopex_factor: dict = None, cost_dynamics: Costdynamics = Costdynamics.constant, location_process_dict: dict = None) -> Constraint:
+    """Capital expenditure for each process at location in network
+
     Args:
         instance (ConcreteModel): pyomo instance
-        fopex_dict (dict): fixed opex at location
+        fopex_dict (dict): fopex at location
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
         annualization_factor (float, optional): Annual depreciation of asset. Defaults to 1.
 
@@ -482,18 +549,59 @@ def constraint_process_fopex(instance: ConcreteModel, fopex_dict: dict, network_
     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
 
     def process_fopex_rule(instance, location, process, *scale_list):
+
         if fopex_dict[process] is not None:
-            if fopex_factor[location] is not None:
-                return instance.Fopex_process[location, process, scale_list] == annualization_factor*fopex_factor[location][process][scale_list]*fopex_dict[process]*instance.Cap_P[location, process, scale_list]
+            Cap_P = instance.Cap_P[location, process, scale_list]
+        else:
+            Cap_P = 0
+
+        if fopex_factor[location] is not None:
+            if process in list(fopex_factor[location].keys()):
+                fopex_fact = fopex_factor[location][process][scale_list]
             else:
-                return instance.Fopex_process[location, process, scale_list] == annualization_factor*fopex_dict[process]*instance.Cap_P[location, process, scale_list]
+                fopex_fact = 1
+        else:
+            fopex_fact = 1
+
+        if get_depth(fopex_dict) == 1:
+            return instance.Fopex_process[location, process, scale_list] == annualization_factor*fopex_fact*fopex_dict[process]*Cap_P
         else:
-            return instance.Fopex_process[location, process, scale_list] == 0
+            if hasattr(instance, 'X_M') is True:
+                return instance.Fopex_process[location, process, scale_list] == sum(annualization_factor*fopex_fact*fopex_dict[i[0]][i[1]]*instance.Cap_P_M[location, i[0], i[1], scale_list] for i in instance.process_material_modes if i[0] == process)
+            if hasattr(instance, 'X_P_m') is True:
+                return instance.Fopex_process[location, process, scale_list] == sum(annualization_factor*fopex_fact*fopex_dict[i[0]][i[1]]*Cap_P for i in instance.process_material_modes if i[0] == process)
     instance.constraint_process_fopex = Constraint(
         instance.locations, instance.processes, *scales, rule=process_fopex_rule, doc='fopex for process')
+
     constraint_latex_render(process_fopex_rule)
     return instance.constraint_process_fopex
 
+# def constraint_process_fopex(instance: ConcreteModel, fopex_dict: dict, network_scale_level: int = 0, fopex_factor: dict = None, annualization_factor: float = 1, location_process_dict: dict = None) -> Constraint:
+#     """Fixed operational expenditure for each process at location in network
+#     Args:
+#         instance (ConcreteModel): pyomo instance
+#         fopex_dict (dict): fixed opex at location
+#         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+#         annualization_factor (float, optional): Annual depreciation of asset. Defaults to 1.
+
+#     Returns:
+#         Constraint: process_fopex
+#     """
+#     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+#     def process_fopex_rule(instance, location, process, *scale_list):
+#         if fopex_dict[process] is not None:
+#             if fopex_factor[location] is not None:
+#                 return instance.Fopex_process[location, process, scale_list] == annualization_factor*fopex_factor[location][process][scale_list]*fopex_dict[process]*instance.Cap_P[location, process, scale_list]
+#             else:
+#                 return instance.Fopex_process[location, process, scale_list] == annualization_factor*fopex_dict[process]*instance.Cap_P[location, process, scale_list]
+#         else:
+#             return instance.Fopex_process[location, process, scale_list] == 0
+#     instance.constraint_process_fopex = Constraint(
+#         instance.locations, instance.processes, *scales, rule=process_fopex_rule, doc='fopex for process')
+#     constraint_latex_render(process_fopex_rule)
+#     return instance.constraint_process_fopex
+
 
 def constraint_location_fopex(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
     """Fixed operational expenditure for each process at location in network
@@ -748,7 +856,10 @@ def constraint_storage_cost(instance: ConcreteModel, location_resource_dict: dic
 
     def storage_cost_rule(instance, location, resource, *scale_list):
         if resource in location_resource_dict[location]:
-            return instance.Inv_cost[location, resource, scale_list[:network_scale_level + 1]] == storage_cost_dict[location][resource]*instance.Inv_network[location, resource, scale_list[:network_scale_level + 1]]
+            if resource in storage_cost_dict[location]:
+                return instance.Inv_cost[location, resource, scale_list[:network_scale_level + 1]] == storage_cost_dict[location][resource]*instance.Inv_network[location, resource, scale_list[:network_scale_level + 1]]
+            else:
+                return instance.Inv_cost[location, resource, scale_list[:network_scale_level + 1]] == 0
         else:
             return instance.Inv_cost[location, resource, scale_list] == 0
     instance.constraint_storage_cost = Constraint(
diff --git a/src/energiapy/model/constraints/demand.py b/src/energiapy/model/constraints/demand.py
index 9600e86f..361b5f81 100644
--- a/src/energiapy/model/constraints/demand.py
+++ b/src/energiapy/model/constraints/demand.py
@@ -116,22 +116,31 @@ def demand_rule(instance, location, resource, *scale_list):
                     demandtarget = 0
         else:
             # TODO - doesn't meet demand in first timeperiod
-            discharge = sum(instance.S[location, resource, scale_] for scale_ in scale_iter if scale_[
-                :demand_scale_level + 1] == scale_list)
+            if resource in location_resource_dict[location]:
+                discharge = sum(instance.S[location, resource, scale_] for scale_ in scale_iter if scale_[
+                    :demand_scale_level + 1] == scale_list)
+            else:
+                discharge = 0
 
-            if isinstance(demand, dict):
-                demandtarget = demand[location][resource]
+            if resource in location_resource_dict[location]:
+                if isinstance(demand, dict):
+                    demandtarget = demand[location][resource]
+                else:
+                    demandtarget = demand
             else:
-                demandtarget = demand
+                demandtarget = 0
 
-        if sign == 'geq':
-            return discharge >= demandtarget
+        if resource in location_resource_dict[location]:
+            if sign == 'geq':
+                return discharge >= demandtarget
 
-        if sign == 'leq':
-            return discharge <= demandtarget
+            if sign == 'leq':
+                return discharge <= demandtarget
 
-        if sign == 'eq':
-            return discharge == demandtarget
+            if sign == 'eq':
+                return discharge == demandtarget
+        else:
+            return Constraint.Skip
 
     if len(instance.locations) > 1:
         instance.constraint_demand = Constraint(
diff --git a/src/energiapy/model/constraints/emission.py b/src/energiapy/model/constraints/emission.py
index 9f003be9..2972fee4 100644
--- a/src/energiapy/model/constraints/emission.py
+++ b/src/energiapy/model/constraints/emission.py
@@ -80,13 +80,38 @@ def global_warming_potential_process_rule(instance, location, process,  *scale_l
     return instance.constraint_global_warming_potential_process
 
 
-def constraint_global_warming_potential_material(instance: ConcreteModel, material_gwp_dict: dict, process_material_dict: dict, network_scale_level: int = 0) -> Constraint:
-    """Calculates the global warming potential arising from the use of materials for processes
+def constraint_global_warming_potential_material_mode(instance: ConcreteModel, material_gwp_dict: dict, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the global warming potential arising from the use of materials for processes in each material mode
 
     Args:
         instance (ConcreteModel): pyomo model instance
         material_gwp_dict (dict): GWP associated with each material
-        process_material_dict (dict): Material consumed by each process
+        process_material_mode_material_dict (dict): Material consumed by each process for each material mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: global_warming_potential_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def global_warming_potential_material_mode_rule(instance, location, process, material_mode, *scale_list):
+        if material_mode in process_material_mode_material_dict[process]:
+            return instance.global_warming_potential_material_mode[location, process, material_mode, scale_list] == \
+                sum(process_material_mode_material_dict[process][material_mode][material]*material_gwp_dict[location][material]
+                    for material in instance.materials if material in process_material_mode_material_dict[process][material_mode]) * instance.Cap_P_M[location, process, material_mode, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_global_warming_potential_material_mode = Constraint(
+        instance.locations, instance.processes_materials, instance.material_modes, *scales, rule=global_warming_potential_material_mode_rule, doc='global warming potential for the each material')
+    constraint_latex_render(global_warming_potential_material_mode_rule)
+    return instance.constraint_global_warming_potential_material_mode
+
+
+def constraint_global_warming_potential_material(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the global warming potential arising from the use of materials for processes across all material modes
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
         network_scale_level (int, optional): scale for network decisions. Defaults to 0.
 
     Returns:
@@ -95,14 +120,61 @@ def constraint_global_warming_potential_material(instance: ConcreteModel, materi
     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
 
     def global_warming_potential_material_rule(instance, location, process,  *scale_list):
-        return instance.global_warming_potential_material[location, process, scale_list] == sum(process_material_dict[process][material]*material_gwp_dict[location][material] for material in instance.materials) * instance.Cap_P[location, process, scale_list]
+        return instance.global_warming_potential_material[location, process, scale_list] == sum(instance.global_warming_potential_material_mode[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes)
     instance.constraint_global_warming_potential_material = Constraint(
         instance.locations, instance.processes_materials, *scales, rule=global_warming_potential_material_rule, doc='global warming potential for the each material')
     constraint_latex_render(global_warming_potential_material_rule)
     return instance.constraint_global_warming_potential_material
 
 
-def constraint_global_warming_potential_resource(instance: ConcreteModel, resource_gwp_dict: dict, network_scale_level: int = 0) -> Constraint:
+def constraint_global_warming_potential_resource_consumption(instance: ConcreteModel, resource_gwp_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the global warming potential from each resource consumed
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_gwp_dict (dict): GWP associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: global_warming_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def global_warming_potential_resource_consumption_rule(instance, location, resource,  *scale_list):
+        # if resource_gwp_dict[location][resource] > 0:
+        return instance.global_warming_potential_resource_consumption[location, resource, scale_list] == resource_gwp_dict[location][resource]*instance.C_location[location, resource, scale_list]
+        # else:
+        #     return instance.global_warming_potential_resource_consumption[location, resource, scale_list] == 0
+    instance.constraint_global_warming_potential_resource_consumption = Constraint(
+        instance.locations, instance.resources_purch, *scales, rule=global_warming_potential_resource_consumption_rule, doc='global warming potential for the each resource consumed')
+    constraint_latex_render(global_warming_potential_resource_consumption_rule)
+    return instance.constraint_global_warming_potential_resource_consumption
+
+# def constraint_global_warming_potential_resource_consumption_negative(instance: ConcreteModel, resource_gwp_dict: dict, network_scale_level: int = 0) -> Constraint:
+#     """Calculates the global warming potential from each resource consumed
+
+#     Args:
+#         instance (ConcreteModel): pyomo model instance
+#         resource_gwp_dict (dict): GWP associated with each resource
+#         network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+#     Returns:
+#         Constraint: global_warming_potential_resource
+#     """
+#     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+#     def global_warming_potential_resource_consumption_negative_rule(instance, location, resource,  *scale_list):
+#         if resource_gwp_dict[location][resource] > 0:
+#             return instance.global_warming_potential_resource_consumption_negative[location, resource, scale_list] == 0
+#         else:
+#             return instance.global_warming_potential_resource_consumption_negative[location, resource, scale_list] == -1*resource_gwp_dict[location][resource]*instance.C_location[location, resource, scale_list]
+#     instance.constraint_global_warming_potential_resource_consumption_negative = Constraint(
+#         instance.locations, instance.resources_purch, *scales, rule=global_warming_potential_resource_consumption_negative_rule, doc='global warming potential for the each resource consumed')
+#     constraint_latex_render(global_warming_potential_resource_consumption_negative_rule)
+#     return instance.constraint_global_warming_potential_resource_consumption_negative
+
+
+def constraint_global_warming_potential_resource_discharge(instance: ConcreteModel, resource_gwp_dict: dict, network_scale_level: int = 0) -> Constraint:
     """Calculates the global warming potential from each resource
 
     Args:
@@ -115,10 +187,46 @@ def constraint_global_warming_potential_resource(instance: ConcreteModel, resour
     """
     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
 
+    def global_warming_potential_resource_discharge_rule(instance, location, resource,  *scale_list):
+        return instance.global_warming_potential_resource_discharge[location, resource, scale_list] == resource_gwp_dict[location][resource]*instance.S_location[location, resource, scale_list]
+    instance.constraint_global_warming_potential_resource_discharge = Constraint(
+        instance.locations, instance.resources_sell, *scales, rule=global_warming_potential_resource_discharge_rule, doc='global warming potential for the each resource discharged')
+    constraint_latex_render(global_warming_potential_resource_discharge_rule)
+    return instance.constraint_global_warming_potential_resource_discharge
+
+
+def constraint_global_warming_potential_resource(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the global warming potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: global_warming_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
     def global_warming_potential_resource_rule(instance, location, resource,  *scale_list):
-        return instance.global_warming_potential_resource[location, resource, scale_list] == resource_gwp_dict[location][resource]*instance.C_location[location, resource, scale_list]
+        # if (resource in instance.resources_sell) or (resource in instance.resources_purch):
+        if resource in instance.resources_sell:
+            sales = instance.global_warming_potential_resource_discharge[location,
+                                                                         resource, scale_list]
+        else:
+            sales = 0
+
+        if resource in instance.resources_purch:
+            purch = instance.global_warming_potential_resource_consumption[
+                location, resource, scale_list]
+
+        else:
+            purch = 0
+        return instance.global_warming_potential_resource[location, resource, scale_list] == sales + purch
+
+        # else:
+        #     return Constraint.Skip
     instance.constraint_global_warming_potential_resource = Constraint(
-        instance.locations, instance.resources_purch, *scales, rule=global_warming_potential_resource_rule, doc='global warming potential for the each resource')
+        instance.locations, instance.resources, *scales, rule=global_warming_potential_resource_rule, doc='global warming potential for the each resource')
     constraint_latex_render(global_warming_potential_resource_rule)
     return instance.constraint_global_warming_potential_resource
 
@@ -139,7 +247,7 @@ def global_warming_potential_location_rule(instance, location, *scale_list):
         gwp_process = sum(
             instance.global_warming_potential_process[location, process_, scale_list] for process_ in instance.processes)
         gwp_resource = sum(
-            instance.global_warming_potential_resource[location, resource_, scale_list] for resource_ in instance.resources_purch)
+            instance.global_warming_potential_resource[location, resource_, scale_list] for resource_ in instance.resources)
         gwp_material = sum(
             instance.global_warming_potential_material[location, material_, scale_list] for material_ in instance.processes_materials)
 
@@ -215,7 +323,6 @@ def global_warming_potential_network_bound_rule(instance, *scale_list):
         *scales, rule=global_warming_potential_network_bound_rule, doc='global warming potential bound for the whole network')
 
 
-
 def constraint_global_warming_potential_20_resource(instance: ConcreteModel, emission_dict: dict, network_scale_level: int = 0) -> Constraint:
     """calculates global warming potential for each process
 
@@ -235,3 +342,997 @@ def global_warming_potential_process_rule(instance, location, process, resource,
         instance.locations, instance.processes, *scales, rule=global_warming_potential_process_rule, doc='global warming potential for the each process')
     constraint_latex_render(global_warming_potential_process_rule)
     return instance.constraint_global_warming_potential_process
+
+# *--------------------Ozone Depletion Potential-------------------------------------------------------
+
+
+def constraint_ozone_depletion_potential_process(instance: ConcreteModel, process_odp_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """calculates ozone depletion potential for each process
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        process_odp_dict (dict): _description_
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_process
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_process_rule(instance, location, process,  *scale_list):
+        return instance.ozone_depletion_potential_process[location, process, scale_list] == process_odp_dict[location][process]*instance.Cap_P[location, process, scale_list]
+    instance.constraint_ozone_depletion_potential_process = Constraint(
+        instance.locations, instance.processes, *scales, rule=ozone_depletion_potential_process_rule, doc='ozone depletion potential for the each process')
+    constraint_latex_render(ozone_depletion_potential_process_rule)
+    return instance.constraint_ozone_depletion_potential_process
+
+
+def constraint_ozone_depletion_potential_material_mode(instance: ConcreteModel, material_odp_dict: dict, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the ozone depletion potential arising from the use of materials for processes in each material mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        material_odp_dict (dict): odp associated with each material
+        process_material_mode_material_dict (dict): Material consumed by each process for each material mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_material_mode_rule(instance, location, process, material_mode, *scale_list):
+        if material_mode in process_material_mode_material_dict[process]:
+            return instance.ozone_depletion_potential_material_mode[location, process, material_mode, scale_list] == \
+                sum(process_material_mode_material_dict[process][material_mode][material]*material_odp_dict[location][material]
+                    for material in instance.materials if material in process_material_mode_material_dict[process][material_mode]) * instance.Cap_P_M[location, process, material_mode, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_ozone_depletion_potential_material_mode = Constraint(
+        instance.locations, instance.processes_materials, instance.material_modes, *scales, rule=ozone_depletion_potential_material_mode_rule, doc='ozone depletion potential for the each material')
+    constraint_latex_render(ozone_depletion_potential_material_mode_rule)
+    return instance.constraint_ozone_depletion_potential_material_mode
+
+
+def constraint_ozone_depletion_potential_material(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the ozone depletion potential arising from the use of materials for processes across all material modes
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_material
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_material_rule(instance, location, process,  *scale_list):
+        return instance.ozone_depletion_potential_material[location, process, scale_list] == sum(instance.ozone_depletion_potential_material_mode[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes)
+    instance.constraint_ozone_depletion_potential_material = Constraint(
+        instance.locations, instance.processes_materials, *scales, rule=ozone_depletion_potential_material_rule, doc='ozone depletion potential for the each material')
+    constraint_latex_render(ozone_depletion_potential_material_rule)
+    return instance.constraint_ozone_depletion_potential_material
+
+
+def constraint_ozone_depletion_potential_resource_consumption(instance: ConcreteModel, resource_odp_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the ozone depletion potential from each resource consumed
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_odp_dict (dict): odp associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_resource_consumption_rule(instance, location, resource,  *scale_list):
+        return instance.ozone_depletion_potential_resource_consumption[location, resource, scale_list] == resource_odp_dict[location][resource]*instance.C_location[location, resource, scale_list]
+    instance.constraint_ozone_depletion_potential_resource_consumption = Constraint(
+        instance.locations, instance.resources_purch, *scales, rule=ozone_depletion_potential_resource_consumption_rule, doc='ozone depletion potential for the each resource consumed')
+    constraint_latex_render(
+        ozone_depletion_potential_resource_consumption_rule)
+    return instance.constraint_ozone_depletion_potential_resource_consumption
+
+
+def constraint_ozone_depletion_potential_resource_discharge(instance: ConcreteModel, resource_odp_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the ozone depletion potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_odp_dict (dict): odp associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_resource_discharge_rule(instance, location, resource,  *scale_list):
+        return instance.ozone_depletion_potential_resource_discharge[location, resource, scale_list] == resource_odp_dict[location][resource]*instance.S_location[location, resource, scale_list]
+    instance.constraint_ozone_depletion_potential_resource_discharge = Constraint(
+        instance.locations, instance.resources_sell, *scales, rule=ozone_depletion_potential_resource_discharge_rule, doc='ozone depletion potential for the each resource discharged')
+    constraint_latex_render(ozone_depletion_potential_resource_discharge_rule)
+    return instance.constraint_ozone_depletion_potential_resource_discharge
+
+
+def constraint_ozone_depletion_potential_resource(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the ozone depletion potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_resource_rule(instance, location, resource,  *scale_list):
+        # if (resource in instance.resources_sell) or (resource in instance.resources_purch):
+        if resource in instance.resources_sell:
+            sales = instance.ozone_depletion_potential_resource_discharge[
+                location, resource, scale_list]
+        else:
+            sales = 0
+
+        if resource in instance.resources_purch:
+            purch = instance.ozone_depletion_potential_resource_consumption[
+                location, resource, scale_list]
+
+        else:
+            purch = 0
+        return instance.ozone_depletion_potential_resource[location, resource, scale_list] == sales + purch
+
+        # else:
+        #     return Constraint.Skip
+    instance.constraint_ozone_depletion_potential_resource = Constraint(
+        instance.locations, instance.resources, *scales, rule=ozone_depletion_potential_resource_rule, doc='ozone depletion potential for the each resource')
+    constraint_latex_render(ozone_depletion_potential_resource_rule)
+    return instance.constraint_ozone_depletion_potential_resource
+
+
+def constraint_ozone_depletion_potential_location(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the ozone depletion potential at each location
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_location
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_location_rule(instance, location, *scale_list):
+        odp_process = sum(
+            instance.ozone_depletion_potential_process[location, process_, scale_list] for process_ in instance.processes)
+        odp_resource = sum(
+            instance.ozone_depletion_potential_resource[location, resource_, scale_list] for resource_ in instance.resources)
+        odp_material = sum(
+            instance.ozone_depletion_potential_material[location, material_, scale_list] for material_ in instance.processes_materials)
+
+        return instance.ozone_depletion_potential_location[location, scale_list] == odp_process + odp_resource + odp_material
+    instance.constraint_ozone_depletion_potential_location = Constraint(
+        instance.locations, *scales, rule=ozone_depletion_potential_location_rule, doc='ozone depletion potential for the each location')
+    constraint_latex_render(ozone_depletion_potential_location_rule)
+    return instance.constraint_ozone_depletion_potential_location
+
+
+def constraint_ozone_depletion_potential_network(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """ozone depletion potential for the whole network
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: ozone_depletion_potential_network
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def ozone_depletion_potential_network_rule(instance, *scale_list):
+        return instance.ozone_depletion_potential_network[scale_list] == \
+            sum(instance.ozone_depletion_potential_location[location_,
+                scale_list] for location_ in instance.locations)
+    instance.constraint_ozone_depletion_potential_network = Constraint(
+        *scales, rule=ozone_depletion_potential_network_rule, doc='ozone depletion potential for the whole network')
+    constraint_latex_render(ozone_depletion_potential_network_rule)
+    return instance.constraint_ozone_depletion_potential_network
+
+# *-------------------------------------Acidification Potential------------------------------------------------
+
+
+def constraint_acidification_potential_process(instance: ConcreteModel, process_acid_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """calculates acidification potential for each process
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        process_acid_dict (dict): _description_
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_process
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_process_rule(instance, location, process,  *scale_list):
+        return instance.acidification_potential_process[location, process, scale_list] == process_acid_dict[location][process]*instance.Cap_P[location, process, scale_list]
+    instance.constraint_acidification_potential_process = Constraint(
+        instance.locations, instance.processes, *scales, rule=acidification_potential_process_rule, doc='acidification potential for the each process')
+    constraint_latex_render(acidification_potential_process_rule)
+    return instance.constraint_acidification_potential_process
+
+
+def constraint_acidification_potential_material_mode(instance: ConcreteModel, material_acid_dict: dict, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the acidification potential arising from the use of materials for processes in each material mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        material_acid_dict (dict): acid associated with each material
+        process_material_mode_material_dict (dict): Material consumed by each process for each material mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_material_mode_rule(instance, location, process, material_mode, *scale_list):
+        if material_mode in process_material_mode_material_dict[process]:
+            return instance.acidification_potential_material_mode[location, process, material_mode, scale_list] == \
+                sum(process_material_mode_material_dict[process][material_mode][material]*material_acid_dict[location][material]
+                    for material in instance.materials if material in process_material_mode_material_dict[process][material_mode]) * instance.Cap_P_M[location, process, material_mode, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_acidification_potential_material_mode = Constraint(
+        instance.locations, instance.processes_materials, instance.material_modes, *scales, rule=acidification_potential_material_mode_rule, doc='acidification potential for the each material')
+    constraint_latex_render(acidification_potential_material_mode_rule)
+    return instance.constraint_acidification_potential_material_mode
+
+
+def constraint_acidification_potential_material(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the acidification potential arising from the use of materials for processes across all material modes
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_material
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_material_rule(instance, location, process,  *scale_list):
+        return instance.acidification_potential_material[location, process, scale_list] == sum(instance.acidification_potential_material_mode[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes)
+    instance.constraint_acidification_potential_material = Constraint(
+        instance.locations, instance.processes_materials, *scales, rule=acidification_potential_material_rule, doc='acidification potential for the each material')
+    constraint_latex_render(acidification_potential_material_rule)
+    return instance.constraint_acidification_potential_material
+
+
+def constraint_acidification_potential_resource_consumption(instance: ConcreteModel, resource_acid_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the acidification potential from each resource consumed
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_acid_dict (dict): acid associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_resource_consumption_rule(instance, location, resource,  *scale_list):
+        return instance.acidification_potential_resource_consumption[location, resource, scale_list] == resource_acid_dict[location][resource]*instance.C_location[location, resource, scale_list]
+    instance.constraint_acidification_potential_resource_consumption = Constraint(
+        instance.locations, instance.resources_purch, *scales, rule=acidification_potential_resource_consumption_rule, doc='acidification potential for the each resource consumed')
+    constraint_latex_render(acidification_potential_resource_consumption_rule)
+    return instance.constraint_acidification_potential_resource_consumption
+
+
+def constraint_acidification_potential_resource_discharge(instance: ConcreteModel, resource_acid_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the acidification potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_acid_dict (dict): acid associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_resource_discharge_rule(instance, location, resource,  *scale_list):
+        return instance.acidification_potential_resource_discharge[location, resource, scale_list] == resource_acid_dict[location][resource]*instance.S_location[location, resource, scale_list]
+    instance.constraint_acidification_potential_resource_discharge = Constraint(
+        instance.locations, instance.resources_sell, *scales, rule=acidification_potential_resource_discharge_rule, doc='acidification potential for the each resource discharged')
+    constraint_latex_render(acidification_potential_resource_discharge_rule)
+    return instance.constraint_acidification_potential_resource_discharge
+
+
+def constraint_acidification_potential_resource(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the acidification potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_resource_rule(instance, location, resource,  *scale_list):
+        # if (resource in instance.resources_sell) or (resource in instance.resources_purch):
+        if resource in instance.resources_sell:
+            sales = instance.acidification_potential_resource_discharge[location,
+                                                                        resource, scale_list]
+        else:
+            sales = 0
+
+        if resource in instance.resources_purch:
+            purch = instance.acidification_potential_resource_consumption[
+                location, resource, scale_list]
+
+        else:
+            purch = 0
+        return instance.acidification_potential_resource[location, resource, scale_list] == sales + purch
+
+        # else:
+        #     return Constraint.Skip
+    instance.constraint_acidification_potential_resource = Constraint(
+        instance.locations, instance.resources, *scales, rule=acidification_potential_resource_rule, doc='acidification potential for the each resource')
+    constraint_latex_render(acidification_potential_resource_rule)
+    return instance.constraint_acidification_potential_resource
+
+
+def constraint_acidification_potential_location(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the acidification potential at each location
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_location
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_location_rule(instance, location, *scale_list):
+        acid_process = sum(
+            instance.acidification_potential_process[location, process_, scale_list] for process_ in instance.processes)
+        acid_resource = sum(
+            instance.acidification_potential_resource[location, resource_, scale_list] for resource_ in instance.resources)
+        acid_material = sum(
+            instance.acidification_potential_material[location, material_, scale_list] for material_ in instance.processes_materials)
+
+        return instance.acidification_potential_location[location, scale_list] == acid_process + acid_resource + acid_material
+    instance.constraint_acidification_potential_location = Constraint(
+        instance.locations, *scales, rule=acidification_potential_location_rule, doc='acidification potential for the each location')
+    constraint_latex_render(acidification_potential_location_rule)
+    return instance.constraint_acidification_potential_location
+
+
+def constraint_acidification_potential_network(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """acidification potential for the whole network
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: acidification_potential_network
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def acidification_potential_network_rule(instance, *scale_list):
+        return instance.acidification_potential_network[scale_list] == \
+            sum(instance.acidification_potential_location[location_,
+                scale_list] for location_ in instance.locations)
+    instance.constraint_acidification_potential_network = Constraint(
+        *scales, rule=acidification_potential_network_rule, doc='acidification potential for the whole network')
+    constraint_latex_render(acidification_potential_network_rule)
+    return instance.constraint_acidification_potential_network
+
+# *-------------------Terrestrial Eutrophication Potential-------------------------------------------------------------
+
+
+def constraint_terrestrial_eutrophication_potential_process(instance: ConcreteModel, process_eutt_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """calculates terrestrial eutrophication potential for each process
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        process_eutt_dict (dict): _description_
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_process
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_process_rule(instance, location, process,  *scale_list):
+        return instance.terrestrial_eutrophication_potential_process[location, process, scale_list] == process_eutt_dict[location][process]*instance.Cap_P[location, process, scale_list]
+    instance.constraint_terrestrial_eutrophication_potential_process = Constraint(
+        instance.locations, instance.processes, *scales, rule=terrestrial_eutrophication_potential_process_rule, doc='terrestrial eutrophication potential for the each process')
+    constraint_latex_render(terrestrial_eutrophication_potential_process_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_process
+
+
+def constraint_terrestrial_eutrophication_potential_material_mode(instance: ConcreteModel, material_eutt_dict: dict, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the terrestrial eutrophication potential arising from the use of materials for processes in each material mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        material_eutt_dict (dict): eutt associated with each material
+        process_material_mode_material_dict (dict): Material consumed by each process for each material mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_material_mode_rule(instance, location, process, material_mode, *scale_list):
+        if material_mode in process_material_mode_material_dict[process]:
+            return instance.terrestrial_eutrophication_potential_material_mode[location, process, material_mode, scale_list] == \
+                sum(process_material_mode_material_dict[process][material_mode][material]*material_eutt_dict[location][material]
+                    for material in instance.materials if material in process_material_mode_material_dict[process][material_mode]) * instance.Cap_P_M[location, process, material_mode, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_terrestrial_eutrophication_potential_material_mode = Constraint(
+        instance.locations, instance.processes_materials, instance.material_modes, *scales, rule=terrestrial_eutrophication_potential_material_mode_rule, doc='terrestrial eutrophication potential for the each material')
+    constraint_latex_render(
+        terrestrial_eutrophication_potential_material_mode_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_material_mode
+
+
+def constraint_terrestrial_eutrophication_potential_material(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the terrestrial eutrophication potential arising from the use of materials for processes across all material modes
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_material
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_material_rule(instance, location, process,  *scale_list):
+        return instance.terrestrial_eutrophication_potential_material[location, process, scale_list] == sum(instance.terrestrial_eutrophication_potential_material_mode[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes)
+    instance.constraint_terrestrial_eutrophication_potential_material = Constraint(
+        instance.locations, instance.processes_materials, *scales, rule=terrestrial_eutrophication_potential_material_rule, doc='terrestrial eutrophication potential for the each material')
+    constraint_latex_render(terrestrial_eutrophication_potential_material_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_material
+
+
+def constraint_terrestrial_eutrophication_potential_resource_consumption(instance: ConcreteModel, resource_eutt_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the terrestrial eutrophication potential from each resource consumed
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_eutt_dict (dict): eutt associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_resource_consumption_rule(instance, location, resource,  *scale_list):
+        return instance.terrestrial_eutrophication_potential_resource_consumption[location, resource, scale_list] == resource_eutt_dict[location][resource]*instance.C_location[location, resource, scale_list]
+    instance.constraint_terrestrial_eutrophication_potential_resource_consumption = Constraint(
+        instance.locations, instance.resources_purch, *scales, rule=terrestrial_eutrophication_potential_resource_consumption_rule, doc='terrestrial eutrophication potential for the each resource consumed')
+    constraint_latex_render(
+        terrestrial_eutrophication_potential_resource_consumption_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_resource_consumption
+
+
+def constraint_terrestrial_eutrophication_potential_resource_discharge(instance: ConcreteModel, resource_eutt_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the terrestrial eutrophication potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_eutt_dict (dict): eutt associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_resource_discharge_rule(instance, location, resource,  *scale_list):
+        return instance.terrestrial_eutrophication_potential_resource_discharge[location, resource, scale_list] == resource_eutt_dict[location][resource]*instance.S_location[location, resource, scale_list]
+    instance.constraint_terrestrial_eutrophication_potential_resource_discharge = Constraint(
+        instance.locations, instance.resources_sell, *scales, rule=terrestrial_eutrophication_potential_resource_discharge_rule, doc='terrestrial eutrophication potential for the each resource discharged')
+    constraint_latex_render(
+        terrestrial_eutrophication_potential_resource_discharge_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_resource_discharge
+
+
+def constraint_terrestrial_eutrophication_potential_resource(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the terrestrial eutrophication potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_resource_rule(instance, location, resource,  *scale_list):
+        # if (resource in instance.resources_sell) or (resource in instance.resources_purch):
+        if resource in instance.resources_sell:
+            sales = instance.terrestrial_eutrophication_potential_resource_discharge[
+                location, resource, scale_list]
+        else:
+            sales = 0
+
+        if resource in instance.resources_purch:
+            purch = instance.terrestrial_eutrophication_potential_resource_consumption[
+                location, resource, scale_list]
+
+        else:
+            purch = 0
+        return instance.terrestrial_eutrophication_potential_resource[location, resource, scale_list] == sales + purch
+
+        # else:
+        #     return Constraint.Skip
+    instance.constraint_terrestrial_eutrophication_potential_resource = Constraint(
+        instance.locations, instance.resources, *scales, rule=terrestrial_eutrophication_potential_resource_rule, doc='terrestrial eutrophication potential for the each resource')
+    constraint_latex_render(terrestrial_eutrophication_potential_resource_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_resource
+
+
+def constraint_terrestrial_eutrophication_potential_location(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the terrestrial eutrophication potential at each location
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_location
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_location_rule(instance, location, *scale_list):
+        eutt_process = sum(
+            instance.terrestrial_eutrophication_potential_process[location, process_, scale_list] for process_ in instance.processes)
+        eutt_resource = sum(
+            instance.terrestrial_eutrophication_potential_resource[location, resource_, scale_list] for resource_ in instance.resources)
+        eutt_material = sum(
+            instance.terrestrial_eutrophication_potential_material[location, material_, scale_list] for material_ in instance.processes_materials)
+
+        return instance.terrestrial_eutrophication_potential_location[location, scale_list] == eutt_process + eutt_resource + eutt_material
+    instance.constraint_terrestrial_eutrophication_potential_location = Constraint(
+        instance.locations, *scales, rule=terrestrial_eutrophication_potential_location_rule, doc='terrestrial eutrophication potential for the each location')
+    constraint_latex_render(terrestrial_eutrophication_potential_location_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_location
+
+
+def constraint_terrestrial_eutrophication_potential_network(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """terrestrial eutrophication potential for the whole network
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: terrestrial_eutrophication_potential_network
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def terrestrial_eutrophication_potential_network_rule(instance, *scale_list):
+        return instance.terrestrial_eutrophication_potential_network[scale_list] == \
+            sum(instance.terrestrial_eutrophication_potential_location[location_,
+                scale_list] for location_ in instance.locations)
+    instance.constraint_terrestrial_eutrophication_potential_network = Constraint(
+        *scales, rule=terrestrial_eutrophication_potential_network_rule, doc='terrestrial eutrophication potential for the whole network')
+    constraint_latex_render(terrestrial_eutrophication_potential_network_rule)
+    return instance.constraint_terrestrial_eutrophication_potential_network
+
+# *-------------------Freshwater Eutrophication Potential-------------------------------------------------------------
+
+
+def constraint_freshwater_eutrophication_potential_process(instance: ConcreteModel, process_eutf_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """calculates freshwater eutrophication potential for each process
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        process_eutf_dict (dict): _description_
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_process
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_process_rule(instance, location, process,  *scale_list):
+        return instance.freshwater_eutrophication_potential_process[location, process, scale_list] == process_eutf_dict[location][process]*instance.Cap_P[location, process, scale_list]
+    instance.constraint_freshwater_eutrophication_potential_process = Constraint(
+        instance.locations, instance.processes, *scales, rule=freshwater_eutrophication_potential_process_rule, doc='freshwater eutrophication potential for the each process')
+    constraint_latex_render(freshwater_eutrophication_potential_process_rule)
+    return instance.constraint_freshwater_eutrophication_potential_process
+
+
+def constraint_freshwater_eutrophication_potential_material_mode(instance: ConcreteModel, material_eutf_dict: dict, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the freshwater eutrophication potential arising from the use of materials for processes in each material mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        material_eutf_dict (dict): eutf associated with each material
+        process_material_mode_material_dict (dict): Material consumed by each process for each material mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_material_mode_rule(instance, location, process, material_mode, *scale_list):
+        if material_mode in process_material_mode_material_dict[process]:
+            return instance.freshwater_eutrophication_potential_material_mode[location, process, material_mode, scale_list] == \
+                sum(process_material_mode_material_dict[process][material_mode][material]*material_eutf_dict[location][material]
+                    for material in instance.materials if material in process_material_mode_material_dict[process][material_mode]) * instance.Cap_P_M[location, process, material_mode, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_freshwater_eutrophication_potential_material_mode = Constraint(
+        instance.locations, instance.processes_materials, instance.material_modes, *scales, rule=freshwater_eutrophication_potential_material_mode_rule, doc='freshwater eutrophication potential for the each material')
+    constraint_latex_render(
+        freshwater_eutrophication_potential_material_mode_rule)
+    return instance.constraint_freshwater_eutrophication_potential_material_mode
+
+
+def constraint_freshwater_eutrophication_potential_material(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the freshwater eutrophication potential arising from the use of materials for processes across all material modes
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_material
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_material_rule(instance, location, process,  *scale_list):
+        return instance.freshwater_eutrophication_potential_material[location, process, scale_list] == sum(instance.freshwater_eutrophication_potential_material_mode[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes)
+    instance.constraint_freshwater_eutrophication_potential_material = Constraint(
+        instance.locations, instance.processes_materials, *scales, rule=freshwater_eutrophication_potential_material_rule, doc='freshwater eutrophication potential for the each material')
+    constraint_latex_render(freshwater_eutrophication_potential_material_rule)
+    return instance.constraint_freshwater_eutrophication_potential_material
+
+
+def constraint_freshwater_eutrophication_potential_resource_consumption(instance: ConcreteModel, resource_eutf_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the freshwater eutrophication potential from each resource consumed
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_eutf_dict (dict): eutf associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_resource_consumption_rule(instance, location, resource,  *scale_list):
+        return instance.freshwater_eutrophication_potential_resource_consumption[location, resource, scale_list] == resource_eutf_dict[location][resource]*instance.C_location[location, resource, scale_list]
+    instance.constraint_freshwater_eutrophication_potential_resource_consumption = Constraint(
+        instance.locations, instance.resources_purch, *scales, rule=freshwater_eutrophication_potential_resource_consumption_rule, doc='freshwater eutrophication potential for the each resource consumed')
+    constraint_latex_render(
+        freshwater_eutrophication_potential_resource_consumption_rule)
+    return instance.constraint_freshwater_eutrophication_potential_resource_consumption
+
+
+def constraint_freshwater_eutrophication_potential_resource_discharge(instance: ConcreteModel, resource_eutf_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the freshwater eutrophication potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_eutf_dict (dict): eutf associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_resource_discharge_rule(instance, location, resource,  *scale_list):
+        return instance.freshwater_eutrophication_potential_resource_discharge[location, resource, scale_list] == resource_eutf_dict[location][resource]*instance.S_location[location, resource, scale_list]
+    instance.constraint_freshwater_eutrophication_potential_resource_discharge = Constraint(
+        instance.locations, instance.resources_sell, *scales, rule=freshwater_eutrophication_potential_resource_discharge_rule, doc='freshwater eutrophication potential for the each resource discharged')
+    constraint_latex_render(
+        freshwater_eutrophication_potential_resource_discharge_rule)
+    return instance.constraint_freshwater_eutrophication_potential_resource_discharge
+
+
+def constraint_freshwater_eutrophication_potential_resource(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the freshwater eutrophication potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_resource_rule(instance, location, resource,  *scale_list):
+        # if (resource in instance.resources_sell) or (resource in instance.resources_purch):
+        if resource in instance.resources_sell:
+            sales = instance.freshwater_eutrophication_potential_resource_discharge[
+                location, resource, scale_list]
+        else:
+            sales = 0
+
+        if resource in instance.resources_purch:
+            purch = instance.freshwater_eutrophication_potential_resource_consumption[
+                location, resource, scale_list]
+
+        else:
+            purch = 0
+        return instance.freshwater_eutrophication_potential_resource[location, resource, scale_list] == sales + purch
+
+        # else:
+        #     return Constraint.Skip
+    instance.constraint_freshwater_eutrophication_potential_resource = Constraint(
+        instance.locations, instance.resources, *scales, rule=freshwater_eutrophication_potential_resource_rule, doc='freshwater eutrophication potential for the each resource')
+    constraint_latex_render(freshwater_eutrophication_potential_resource_rule)
+    return instance.constraint_freshwater_eutrophication_potential_resource
+
+
+def constraint_freshwater_eutrophication_potential_location(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the freshwater eutrophication potential at each location
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_location
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_location_rule(instance, location, *scale_list):
+        eutf_process = sum(
+            instance.freshwater_eutrophication_potential_process[location, process_, scale_list] for process_ in instance.processes)
+        eutf_resource = sum(
+            instance.freshwater_eutrophication_potential_resource[location, resource_, scale_list] for resource_ in instance.resources)
+        eutf_material = sum(
+            instance.freshwater_eutrophication_potential_material[location, material_, scale_list] for material_ in instance.processes_materials)
+
+        return instance.freshwater_eutrophication_potential_location[location, scale_list] == eutf_process + eutf_resource + eutf_material
+    instance.constraint_freshwater_eutrophication_potential_location = Constraint(
+        instance.locations, *scales, rule=freshwater_eutrophication_potential_location_rule, doc='freshwater eutrophication potential for the each location')
+    constraint_latex_render(freshwater_eutrophication_potential_location_rule)
+    return instance.constraint_freshwater_eutrophication_potential_location
+
+
+def constraint_freshwater_eutrophication_potential_network(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """freshwater eutrophication potential for the whole network
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: freshwater_eutrophication_potential_network
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def freshwater_eutrophication_potential_network_rule(instance, *scale_list):
+        return instance.freshwater_eutrophication_potential_network[scale_list] == \
+            sum(instance.freshwater_eutrophication_potential_location[location_,
+                scale_list] for location_ in instance.locations)
+    instance.constraint_freshwater_eutrophication_potential_network = Constraint(
+        *scales, rule=freshwater_eutrophication_potential_network_rule, doc='freshwater eutrophication potential for the whole network')
+    constraint_latex_render(freshwater_eutrophication_potential_network_rule)
+    return instance.constraint_freshwater_eutrophication_potential_network
+
+# *-------------------Marine Eutrophication Potential-------------------------------------------------------------
+
+
+def constraint_marine_eutrophication_potential_process(instance: ConcreteModel, process_eutm_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """calculates marine eutrophication potential for each process
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        process_eutm_dict (dict): _description_
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_process
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_process_rule(instance, location, process,  *scale_list):
+        return instance.marine_eutrophication_potential_process[location, process, scale_list] == process_eutm_dict[location][process]*instance.Cap_P[location, process, scale_list]
+    instance.constraint_marine_eutrophication_potential_process = Constraint(
+        instance.locations, instance.processes, *scales, rule=marine_eutrophication_potential_process_rule, doc='marine eutrophication potential for the each process')
+    constraint_latex_render(marine_eutrophication_potential_process_rule)
+    return instance.constraint_marine_eutrophication_potential_process
+
+
+def constraint_marine_eutrophication_potential_material_mode(instance: ConcreteModel, material_eutm_dict: dict, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the marine eutrophication potential arising from the use of materials for processes in each material mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        material_eutm_dict (dict): eutm associated with each material
+        process_material_mode_material_dict (dict): Material consumed by each process for each material mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_material_mode_rule(instance, location, process, material_mode, *scale_list):
+        if material_mode in process_material_mode_material_dict[process]:
+            return instance.marine_eutrophication_potential_material_mode[location, process, material_mode, scale_list] == \
+                sum(process_material_mode_material_dict[process][material_mode][material]*material_eutm_dict[location][material]
+                    for material in instance.materials if material in process_material_mode_material_dict[process][material_mode]) * instance.Cap_P_M[location, process, material_mode, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_marine_eutrophication_potential_material_mode = Constraint(
+        instance.locations, instance.processes_materials, instance.material_modes, *scales, rule=marine_eutrophication_potential_material_mode_rule, doc='marine eutrophication potential for the each material')
+    constraint_latex_render(marine_eutrophication_potential_material_mode_rule)
+    return instance.constraint_marine_eutrophication_potential_material_mode
+
+
+def constraint_marine_eutrophication_potential_material(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the marine eutrophication potential arising from the use of materials for processes across all material modes
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_material
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_material_rule(instance, location, process,  *scale_list):
+        return instance.marine_eutrophication_potential_material[location, process, scale_list] == sum(instance.marine_eutrophication_potential_material_mode[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes)
+    instance.constraint_marine_eutrophication_potential_material = Constraint(
+        instance.locations, instance.processes_materials, *scales, rule=marine_eutrophication_potential_material_rule, doc='marine eutrophication potential for the each material')
+    constraint_latex_render(marine_eutrophication_potential_material_rule)
+    return instance.constraint_marine_eutrophication_potential_material
+
+
+def constraint_marine_eutrophication_potential_resource_consumption(instance: ConcreteModel, resource_eutm_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the marine eutrophication potential from each resource consumed
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_eutm_dict (dict): eutm associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_resource_consumption_rule(instance, location, resource,  *scale_list):
+        return instance.marine_eutrophication_potential_resource_consumption[location, resource, scale_list] == resource_eutm_dict[location][resource]*instance.C_location[location, resource, scale_list]
+    instance.constraint_marine_eutrophication_potential_resource_consumption = Constraint(
+        instance.locations, instance.resources_purch, *scales, rule=marine_eutrophication_potential_resource_consumption_rule, doc='marine eutrophication potential for the each resource consumed')
+    constraint_latex_render(
+        marine_eutrophication_potential_resource_consumption_rule)
+    return instance.constraint_marine_eutrophication_potential_resource_consumption
+
+
+def constraint_marine_eutrophication_potential_resource_discharge(instance: ConcreteModel, resource_eutm_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates the marine eutrophication potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        resource_eutm_dict (dict): eutm associated with each resource
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_resource_discharge_rule(instance, location, resource,  *scale_list):
+        return instance.marine_eutrophication_potential_resource_discharge[location, resource, scale_list] == resource_eutm_dict[location][resource]*instance.S_location[location, resource, scale_list]
+    instance.constraint_marine_eutrophication_potential_resource_discharge = Constraint(
+        instance.locations, instance.resources_sell, *scales, rule=marine_eutrophication_potential_resource_discharge_rule, doc='marine eutrophication potential for the each resource discharged')
+    constraint_latex_render(
+        marine_eutrophication_potential_resource_discharge_rule)
+    return instance.constraint_marine_eutrophication_potential_resource_discharge
+
+
+def constraint_marine_eutrophication_potential_resource(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the marine eutrophication potential from each resource
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_resource
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_resource_rule(instance, location, resource,  *scale_list):
+        # if (resource in instance.resources_sell) or (resource in instance.resources_purch):
+        if resource in instance.resources_sell:
+            sales = instance.marine_eutrophication_potential_resource_discharge[
+                location, resource, scale_list]
+        else:
+            sales = 0
+
+        if resource in instance.resources_purch:
+            purch = instance.marine_eutrophication_potential_resource_consumption[
+                location, resource, scale_list]
+
+        else:
+            purch = 0
+        return instance.marine_eutrophication_potential_resource[location, resource, scale_list] == sales + purch
+
+        # else:
+        #     return Constraint.Skip
+    instance.constraint_marine_eutrophication_potential_resource = Constraint(
+        instance.locations, instance.resources, *scales, rule=marine_eutrophication_potential_resource_rule, doc='marine eutrophication potential for the each resource')
+    constraint_latex_render(marine_eutrophication_potential_resource_rule)
+    return instance.constraint_marine_eutrophication_potential_resource
+
+
+def constraint_marine_eutrophication_potential_location(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """Calculates the marine eutrophication potential at each location
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_location
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_location_rule(instance, location, *scale_list):
+        eutm_process = sum(
+            instance.marine_eutrophication_potential_process[location, process_, scale_list] for process_ in instance.processes)
+        eutm_resource = sum(
+            instance.marine_eutrophication_potential_resource[location, resource_, scale_list] for resource_ in instance.resources)
+        eutm_material = sum(
+            instance.marine_eutrophication_potential_material[location, material_, scale_list] for material_ in instance.processes_materials)
+
+        return instance.marine_eutrophication_potential_location[location, scale_list] == eutm_process + eutm_resource + eutm_material
+    instance.constraint_marine_eutrophication_potential_location = Constraint(
+        instance.locations, *scales, rule=marine_eutrophication_potential_location_rule, doc='marine eutrophication potential for the each location')
+    constraint_latex_render(marine_eutrophication_potential_location_rule)
+    return instance.constraint_marine_eutrophication_potential_location
+
+
+def constraint_marine_eutrophication_potential_network(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
+    """marine eutrophication potential for the whole network
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: marine_eutrophication_potential_network
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def marine_eutrophication_potential_network_rule(instance, *scale_list):
+        return instance.marine_eutrophication_potential_network[scale_list] == \
+            sum(instance.marine_eutrophication_potential_location[location_,
+                scale_list] for location_ in instance.locations)
+    instance.constraint_marine_eutrophication_potential_network = Constraint(
+        *scales, rule=marine_eutrophication_potential_network_rule, doc='marine eutrophication potential for the whole network')
+    constraint_latex_render(marine_eutrophication_potential_network_rule)
+    return instance.constraint_marine_eutrophication_potential_network
diff --git a/src/energiapy/model/constraints/material.py b/src/energiapy/model/constraints/material.py
index d24a2af1..3a727f54 100644
--- a/src/energiapy/model/constraints/material.py
+++ b/src/energiapy/model/constraints/material.py
@@ -16,6 +16,33 @@
 from ...utils.scale_utils import scale_list
 
 
+def constraint_material_mode_process(instance: ConcreteModel, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Calculates material utilization for each process under material mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        process_material_mode_material_dict (dict): materials consumed by each process under material_mode
+        network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+    Returns:
+        Constraint: material_mode_process
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def material_mode_process_rule(instance, location, process, material_mode, material, *scale_list):
+        if material_mode in process_material_mode_material_dict[process].keys():
+            if material in process_material_mode_material_dict[process][material_mode].keys():
+                return instance.material_mode_process[location, process, material_mode, material, scale_list] == process_material_mode_material_dict[process][material_mode][material]*instance.Cap_P_M[location, process, material_mode, scale_list]
+            else:
+                return instance.material_mode_process[location, process, material_mode, material, scale_list] == 0
+        else:
+            return instance.material_mode_process[location, process, material_mode, material, scale_list] == 0
+    instance.constraint_material_mode_process = Constraint(
+        instance.locations, instance.processes, instance.material_modes, instance.materials, *scales, rule=material_mode_process_rule, doc='material utilization for each process')
+    constraint_latex_render(material_mode_process_rule)
+    return instance.constraint_material_mode_process
+
+
 def constraint_material_process(instance: ConcreteModel, process_material_dict: dict, network_scale_level: int = 0) -> Constraint:
     """Calculates material utilization for each process
 
@@ -31,15 +58,39 @@ def constraint_material_process(instance: ConcreteModel, process_material_dict:
 
     def material_process_rule(instance, location, process, material, *scale_list):
         if process_material_dict[process][material] is not None:
-            return instance.material_process[location, process, material, scale_list] == process_material_dict[process][material]*instance.Cap_P[location, process, scale_list]
+            return instance.material_process[location, process, material, scale_list] == sum(instance.material_mode_process[location, process, material_mode_, material, scale_list] for material_mode_ in instance.material_modes)
         else:
-            return Constraint.Skip
+            return instance.material_process[location, process, material, scale_list] == 0
     instance.constraint_material_process = Constraint(
         instance.locations, instance.processes, instance.materials, *scales, rule=material_process_rule, doc='material utilization for each process')
     constraint_latex_render(material_process_rule)
     return instance.constraint_material_process
 
 
+# def constraint_material_process(instance: ConcreteModel, process_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+#     """Calculates material utilization for each process
+
+#     Args:
+#         instance (ConcreteModel): pyomo model instance
+#         process_material_dict (dict): materials consumed by each process
+#         network_scale_level (int, optional): scale for network decisions. Defaults to 0.
+
+#     Returns:
+#         Constraint: material_process
+#     """
+#     scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+#     def material_process_rule(instance, location, process, material, *scale_list):
+#         if process_material_dict[process][material] is not None:
+#             return instance.material_process[location, process, material, scale_list] == process_material_dict[process][material]*instance.Cap_P[location, process, scale_list]
+#         else:
+#             return Constraint.Skip
+#     instance.constraint_material_process = Constraint(
+#         instance.locations, instance.processes, instance.materials, *scales, rule=material_process_rule, doc='material utilization for each process')
+#     constraint_latex_render(material_process_rule)
+#     return instance.constraint_material_process
+
+
 def constraint_material_location(instance: ConcreteModel, network_scale_level: int = 0) -> Constraint:
     """Calculates the material utilization at each location
 
@@ -78,3 +129,131 @@ def material_network_rule(instance, material, *scale_list):
         instance.materials, *scales, rule=material_network_rule, doc='material utilization for the whole network')
     constraint_latex_render(material_network_rule)
     return instance.constraint_material_network
+
+
+def constraint_production_facility_material_mode(instance: ConcreteModel, network_scale_level: int = 0, location_process_dict: dict = None) -> Constraint:
+    """Capacity of process as a sum of the processes under different material modes
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        location_process_dict (dict, optional): dict with processes at location. Defaults to None.
+
+    Returns:
+        Constraint: constraint_production_facility_material_mode
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def production_facility_material_mode_rule(instance, location, process, *scale_list):
+        if process in location_process_dict[location]:
+            return instance.Cap_P[location, process, scale_list] == sum(instance.Cap_P_M[location, i[0], i[1], scale_list] for i in instance.process_material_modes if i[0] == process)
+        else:
+            return Constraint.Skip
+    instance.constraint_production_facility_material_mode = Constraint(
+        instance.locations, instance.processes, *scales, rule=production_facility_material_mode_rule, doc='capacity of process under different material modes')
+
+    constraint_latex_render(production_facility_material_mode_rule)
+    return instance.constraint_production_facility_material_mode
+
+
+def constraint_production_facility_material_mode_binary(instance: ConcreteModel, network_scale_level: int = 0, location_process_dict: dict = None) -> Constraint:
+    """Capacity of process as a sum of the processes under different material modes
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        location_process_dict (dict, optional): dict with processes at location. Defaults to None.
+
+    Returns:
+        Constraint: constraint_production_facility_material_mode_binary
+    """
+    scales = scale_list(instance=instance, scale_levels=network_scale_level+1)
+
+    def production_facility_material_mode_binary_rule(instance, location, process, *scale_list):
+        if process in location_process_dict[location]:
+            return sum(instance.X_M[location, i[0], i[1], scale_list] for i in instance.process_material_modes if i[0] == process) == instance.X_P[location, process, scale_list]
+        else:
+            return Constraint.Skip
+    instance.constraint_production_facility_material_mode_binary = Constraint(
+        instance.locations, instance.processes, *scales, rule=production_facility_material_mode_binary_rule, doc='capacity of process under different material modes')
+
+    constraint_latex_render(production_facility_material_mode_binary_rule)
+    return instance.constraint_production_facility_material_mode_binary
+
+
+def constraint_production_facility_material(instance: ConcreteModel, cap_max: dict, location_process_dict: dict = None,
+                                            network_scale_level: int = 0, process_material_modes_dict: dict = None) -> Constraint:
+    """Determines where production facility of certain capacity is inserted at location in network
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        cap_max (dict): maximum production of process at location
+        location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        process_material_modes_dict (dict, optional): material modes available for processes
+
+    Returns:
+        Constraint: production_facility_material
+    """
+    scales = scale_list(instance=instance,
+                        scale_levels=network_scale_level + 1)
+
+    def production_facility_material_rule(instance, location, process, material_mode, *scale_list):
+        if location_process_dict is not None:
+            if process in location_process_dict[location]:
+                if material_mode in process_material_modes_dict[process]:
+                    return instance.Cap_P_M[location, process, material_mode, scale_list[:network_scale_level + 1]] <= cap_max[location][process][list(cap_max[location][process].keys())[-1:][0]]*instance.X_M[location, process, material_mode, scale_list[:network_scale_level + 1]]
+                else:
+                    return Constraint.Skip
+            else:
+                return instance.Cap_P_M[location, material_mode, process, scale_list[:network_scale_level + 1]] == 0
+        else:
+            return Constraint.Skip
+
+    instance.constraint_production_facility_material = Constraint(
+        instance.locations, instance.processes,  instance.material_modes, *
+        scales, rule=production_facility_material_rule,
+        doc='production facility sizing and location for material mode')
+    constraint_latex_render(production_facility_material_rule)
+    return instance.constraint_production_facility_material
+
+
+def constraint_min_production_facility_material(instance: ConcreteModel, cap_min: dict, location_process_dict: dict = None,
+                                                network_scale_level: int = 0, process_material_modes_dict: dict = None) -> Constraint:
+    """Determines where production facility of certain capacity is inserted at location in network
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        cap_min (dict): minimum production of process at location
+        location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        process_material_modes_dict (dict, optional): material modes available for processes
+
+    Returns:
+        Constraint: min_production_facility_material
+    """
+
+    if location_process_dict is None:
+        location_process_dict = dict()
+
+    scales = scale_list(instance=instance,
+                        scale_levels=network_scale_level + 1)
+
+    def min_production_facility_material_rule(instance, location, process, material_mode, *scale_list):
+        if location_process_dict is not None:
+            if process in location_process_dict[location]:
+                if material_mode in process_material_modes_dict[process]:
+                    return instance.Cap_P_M[location, process, material_mode, scale_list[:network_scale_level + 1]] >= cap_min[location][process][list(cap_min[location][process].keys())[:1][0]] * instance.X_M[location, process, material_mode, scale_list[:network_scale_level + 1]]
+                else:
+                    return Constraint.Skip
+            else:
+                return instance.Cap_P_M[location, process, material_mode, scale_list[:network_scale_level + 1]] == 0
+        else:
+            return Constraint.Skip
+
+    instance.constraint_min_production_facility_material = Constraint(
+        instance.locations, instance.processes, instance.material_modes, *
+        scales, rule=min_production_facility_material_rule,
+        doc='production facility sizing and location for material mode')
+    constraint_latex_render(min_production_facility_material_rule)
+    return instance.constraint_min_production_facility_material
diff --git a/src/energiapy/model/constraints/mode.py b/src/energiapy/model/constraints/mode.py
index 2d89999b..77b34091 100644
--- a/src/energiapy/model/constraints/mode.py
+++ b/src/energiapy/model/constraints/mode.py
@@ -16,12 +16,13 @@
 from ...utils.scale_utils import scale_list, scale_tuple
 
 
-def constraint_production_mode(instance: ConcreteModel, mode_dict: dict, scheduling_scale_level: int = 0) -> Constraint:
+def constraint_production_mode(instance: ConcreteModel, mode_dict: dict, location_process_dict: dict, scheduling_scale_level: int = 0) -> Constraint:
     """The sum of production through all modes equals production at scheduling scale
 
     Args:
         instance (ConcreteModel): pyomo model instance
         mode_dict (dict): dictionary with modes available for process
+        location_process_dict (dict): dictionary with processes in location
         scheduling_scale_level (int, optional): scale for scheduling decisions. Defaults to 0.
 
     Returns:
@@ -32,9 +33,12 @@ def constraint_production_mode(instance: ConcreteModel, mode_dict: dict, schedul
                         scale_levels=scheduling_scale_level + 1)
 
     def production_mode_rule(instance, location, process, *scale_list):
-        return instance.P[location, process, scale_list[:scheduling_scale_level + 1]] == sum(
-            instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] for mode in
-            mode_dict[process])
+        if process in location_process_dict[location]:
+            return instance.P[location, process, scale_list[:scheduling_scale_level + 1]] == sum(
+                instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] for mode in
+                mode_dict[process])
+        else:
+            return Constraint.Skip
 
     instance.constraint_production_mode = Constraint(
         instance.locations, instance.processes, *scales, rule=production_mode_rule,
@@ -43,13 +47,13 @@ def production_mode_rule(instance, location, process, *scale_list):
     return instance.constraint_production_mode
 
 
-def constraint_production_mode_facility(instance: ConcreteModel, prod_max: dict, location_process_dict: dict = None,
+def constraint_production_mode_facility(instance: ConcreteModel, cap_max: dict, location_process_dict: dict = None,
                                         scheduling_scale_level: int = 0) -> Constraint:
     """Constraints production to maximum in mode
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_max (dict): maximum production of process at location
+        cap_max (dict): maximum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         scheduling_scale_level (int, optional): scale of scheduling decisions. Defaults to 0.
 
@@ -65,9 +69,9 @@ def constraint_production_mode_facility(instance: ConcreteModel, prod_max: dict,
 
     def production_mode_facility_rule(instance, location, process, mode, *scale_list):
         if process in location_process_dict[location]:
-            if mode <= list(prod_max[location][process].keys())[-1:][0]:
-                return instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] <= prod_max[location][process][mode] * instance.X_P_m[location, process, mode,
-                                                                                                                                                            scale_list[:scheduling_scale_level + 1]]
+            if mode <= list(cap_max[location][process].keys())[-1:][0]:
+                return instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] <= cap_max[location][process][mode] * instance.X_P_m[location, process, mode,
+                                                                                                                                                           scale_list[:scheduling_scale_level + 1]]
             else:
                 return Constraint.Skip
         else:
@@ -81,13 +85,13 @@ def production_mode_facility_rule(instance, location, process, mode, *scale_list
     return instance.constraint_production_mode_facility
 
 
-def constraint_min_production_mode_facility(instance: ConcreteModel, prod_min: dict, location_process_dict: dict = None,
+def constraint_min_production_mode_facility(instance: ConcreteModel, cap_min: dict, location_process_dict: dict = None,
                                             scheduling_scale_level: int = 0) -> Constraint:
     """Constraints production to minimum in mode
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_min (dict): minimum production of process at location
+        cap_min (dict): minimum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         scheduling_scale_level (int, optional): scale of scheduling decisions. Defaults to 0.
 
@@ -103,9 +107,9 @@ def constraint_min_production_mode_facility(instance: ConcreteModel, prod_min: d
 
     def min_production_mode_facility_rule(instance, location, process, mode, *scale_list):
         if process in location_process_dict[location]:
-            if mode <= list(prod_min[location][process].keys())[-1:][0]:
-                return instance.Cap_P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] >= prod_min[location][process][mode] * instance.X_P_m[location, process, mode,
-                                                                                                                                                                scale_list[:scheduling_scale_level + 1]]
+            if mode <= list(cap_min[location][process].keys())[-1:][0]:
+                return instance.Cap_P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] >= cap_min[location][process][mode] * instance.X_P_m[location, process, mode,
+                                                                                                                                                               scale_list[:scheduling_scale_level + 1]]
             else:
                 return Constraint.Skip
         else:
@@ -168,7 +172,7 @@ def constraint_production_rate1(instance: ConcreteModel, rate_max_dict: dict, sc
 
     def production_rate_rule1(instance, location, process, mode, *scale_list):
         if rate_max_dict[process] is not None:
-            return instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] - instance.P_m[location, process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]] >= - rate_max_dict[process][mode] - max(rate_max_dict['PEM'].values())*(2 - instance.X_P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] - instance.X_P_m[location, process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]])
+            return instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] - instance.P_m[location, process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]] >= - rate_max_dict[process][mode] - max(rate_max_dict[process].values())*(2 - instance.X_P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] - instance.X_P_m[location, process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]])
         else:
             return Constraint.Skip
 
@@ -202,8 +206,8 @@ def production_rate_rule2(instance, location, process, mode, *scale_list):
             lhs = instance.P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]] - instance.P_m[location,
                                                                                                                 process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]]
 
-            rhs = rate_max_dict[process][mode] + max(rate_max_dict['PEM'].values())*(2 - instance.X_P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]
-                                                                                                        ] - instance.X_P_m[location, process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]])
+            rhs = rate_max_dict[process][mode] + max(rate_max_dict[process].values())*(2 - instance.X_P_m[location, process, mode, scale_list[:scheduling_scale_level + 1]
+                                                                                                          ] - instance.X_P_m[location, process, mode, scale_iter[scale_iter.index(scale_list[:scheduling_scale_level + 1]) - 1]])
             return lhs <= rhs
         else:
             return Constraint.Skip
diff --git a/src/energiapy/model/constraints/network.py b/src/energiapy/model/constraints/network.py
index 6982815b..7103b363 100644
--- a/src/energiapy/model/constraints/network.py
+++ b/src/energiapy/model/constraints/network.py
@@ -17,13 +17,13 @@
 from ...model.bounds import CapacityBounds
 
 
-def constraint_production_facility(instance: ConcreteModel, prod_max: dict, location_process_dict: dict = None,
+def constraint_production_facility(instance: ConcreteModel, cap_max: dict, location_process_dict: dict = None,
                                    network_scale_level: int = 0) -> Constraint:
     """Determines where production facility of certain capacity is inserted at location in network
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_max (dict): maximum production of process at location
+        cap_max (dict): maximum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
 
@@ -36,7 +36,7 @@ def constraint_production_facility(instance: ConcreteModel, prod_max: dict, loca
     def production_facility_rule(instance, location, process, *scale_list):
         if location_process_dict is not None:
             if process in location_process_dict[location]:
-                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] <= prod_max[location][process][list(prod_max[location][process].keys())[-1:][0]]*instance.X_P[location, process, scale_list[:network_scale_level + 1]]
+                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] <= cap_max[location][process][list(cap_max[location][process].keys())[-1:][0]]*instance.X_P[location, process, scale_list[:network_scale_level + 1]]
             else:
                 return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] == 0
         else:
@@ -119,13 +119,13 @@ def min_storage_facility_rule(instance, location, resource, *scale_list):
     return instance.constraint_min_storage_facility
 
 
-def constraint_min_production_facility(instance: ConcreteModel, prod_min: dict, location_process_dict: dict = None,
+def constraint_min_production_facility(instance: ConcreteModel, cap_min: dict, location_process_dict: dict = None,
                                        network_scale_level: int = 0) -> Constraint:
     """Determines where production facility of certain capacity is inserted at location in network
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_min (dict): minimum production of process at location
+        cap_min (dict): minimum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
 
@@ -142,7 +142,7 @@ def constraint_min_production_facility(instance: ConcreteModel, prod_min: dict,
     def min_production_facility_rule(instance, location, process, *scale_list):
         if location_process_dict is not None:
             if process in location_process_dict[location]:
-                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] >= prod_min[location][process][list(prod_min[location][process].keys())[:1][0]] * instance.X_P[location, process, scale_list[:network_scale_level + 1]]
+                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] >= cap_min[location][process][list(cap_min[location][process].keys())[:1][0]] * instance.X_P[location, process, scale_list[:network_scale_level + 1]]
             else:
                 return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] == 0
         else:
diff --git a/src/energiapy/model/constraints/production.py b/src/energiapy/model/constraints/production.py
index 269c3b30..31ae7bc4 100644
--- a/src/energiapy/model/constraints/production.py
+++ b/src/energiapy/model/constraints/production.py
@@ -22,7 +22,7 @@ def constraint_production_facility_affix(instance: ConcreteModel, affix_producti
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_max (dict): maximum production of process at location
+        cap_max (dict): maximum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
 
@@ -53,13 +53,13 @@ def production_facility_affix_rule(instance, location, process, *scale_list):
     return instance.constraint_production_facility_affix
 
 
-def constraint_production_facility_fix(instance: ConcreteModel, prod_max: dict, production_binaries: dict,
+def constraint_production_facility_fix(instance: ConcreteModel, cap_max: dict, production_binaries: dict,
                                        location_process_dict: dict = None, network_scale_level: int = 0) -> Constraint:
     """Determines where production facility of certain capacity is inserted at location in network
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_max (dict): maximum production of process at location
+        cap_max (dict): maximum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
 
@@ -75,7 +75,7 @@ def constraint_production_facility_fix(instance: ConcreteModel, prod_max: dict,
 
     def production_facility_fix_rule(instance, location, process, *scale_list):
         if process in location_process_dict[location]:
-            return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] <= prod_max[location][
+            return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] <= cap_max[location][
                 process] * \
                 production_binaries[(
                     location, process, *scale_list[:network_scale_level + 1])]
@@ -135,13 +135,58 @@ def nameplate_production_rule(instance, location, process, *scale_list):
     return instance.constraint_nameplate_production
 
 
-def constraint_production_max(instance: ConcreteModel, prod_max: dict, location_process_dict: dict = None,
+def constraint_nameplate_production_material_mode(instance: ConcreteModel, capacity_factor: dict = None, location_process_dict: dict = None,
+                                                  network_scale_level: int = 0, scheduling_scale_level: int = 0) -> Constraint:
+    """Determines production capacity utilization of facilities at location in network and capacity of facilities
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        capacity_factor (dict, optional): uncertain capacity availability training data. Defaults to {}.
+        location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        scheduling_scale_level (int, optional): scale of scheduling decisions. Defaults to 0.
+
+    Returns:
+        Constraint: nameplate_production_material_mode
+    """
+
+    if capacity_factor is None:
+        capacity_factor = dict()
+
+    if location_process_dict is None:
+        location_process_dict = dict()
+
+    scales = scale_list(instance=instance,
+                        scale_levels=len(instance.scales))
+
+    def nameplate_production_material_mode_rule(instance, location, process, material_mode, *scale_list):
+
+        if process not in location_process_dict[location]:
+            return instance.P_material_m[location, process, material_mode, scale_list[:scheduling_scale_level + 1]] == 0
+
+        else:
+            if process not in instance.processes_varying_capacity:
+                return instance.P_material_m[location, process, material_mode, scale_list[:scheduling_scale_level + 1]] <= instance.Cap_P_M[
+                    location, process, material_mode, scale_list[:network_scale_level + 1]]
+            else:
+                return instance.P_material_m[location, process, material_mode, scale_list[:scheduling_scale_level + 1]] <= capacity_factor[location][process][scale_list[:scheduling_scale_level + 1]] * instance.Cap_P_M[location, process, material_mode,
+                                                                                                                                                                                                                          scale_list[:network_scale_level + 1]]
+
+    instance.constraint_nameplate_production_material_mode = Constraint(
+        instance.locations, instance.processes, instance.material_modes, *
+        scales, rule=nameplate_production_material_mode_rule,
+        doc='nameplate production capacity constraint for material mode')
+    constraint_latex_render(nameplate_production_material_mode_rule)
+    return instance.constraint_nameplate_production_material_mode
+
+
+def constraint_production_max(instance: ConcreteModel, cap_max: dict, location_process_dict: dict = None,
                               network_scale_level: int = 0) -> Constraint:
     """Restricts maximum capacity realized to cap_max, binary network constraints can override
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_max (dict): maximum production of process at location
+        cap_max (dict): maximum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
 
@@ -154,7 +199,7 @@ def constraint_production_max(instance: ConcreteModel, prod_max: dict, location_
     def production_max_rule(instance, location, process, *scale_list):
         if location_process_dict is not None:
             if process in location_process_dict[location]:
-                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] <= prod_max[location][process][list(prod_max[location][process].keys())[-1:][0]]
+                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] <= cap_max[location][process][list(cap_max[location][process].keys())[-1:][0]]
             else:
                 return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] == 0
         else:
@@ -167,13 +212,13 @@ def production_max_rule(instance, location, process, *scale_list):
     return instance.constraint_production_max
 
 
-def constraint_production_min(instance: ConcreteModel, prod_min: dict, location_process_dict: dict = None,
+def constraint_production_min(instance: ConcreteModel, cap_min: dict, location_process_dict: dict = None,
                               network_scale_level: int = 0) -> Constraint:
-    """Restricts minimum capacity of production facility to prod_min
+    """Restricts minimum capacity of production facility to cap_min
 
     Args:
         instance (ConcreteModel): pyomo instance
-        prod_max (dict): maximum production of process at location
+        cap_max (dict): maximum production of process at location
         location_process_dict (dict, optional): production facilities avaiable at location. Defaults to {}.
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
 
@@ -191,7 +236,7 @@ def production_min_rule(instance, location, process, *scale_list):
 
         if location_process_dict is not None:
             if process in location_process_dict[location]:
-                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] >= prod_min[location][process][list(prod_min[location][process].keys())[-1:][0]]
+                return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] >= cap_min[location][process][list(cap_min[location][process].keys())[-1:][0]]
             else:
                 return instance.Cap_P[location, process, scale_list[:network_scale_level + 1]] == 0
         else:
diff --git a/src/energiapy/model/constraints/resource_balance.py b/src/energiapy/model/constraints/resource_balance.py
index 5193361c..5419ac3c 100644
--- a/src/energiapy/model/constraints/resource_balance.py
+++ b/src/energiapy/model/constraints/resource_balance.py
@@ -64,7 +64,7 @@ def resource_consumption_rule(instance, location, resource, *scale_list):
 def constraint_inventory_balance(instance: ConcreteModel, scheduling_scale_level: int = 0,
                                  multiconversion: dict = None, mode_dict: dict = None,
                                  cluster_wt: dict = None, inventory_zero: Dict[Location, Dict[Tuple[Process, Resource], float]] = None,
-                                 location_resource_dict: dict = None) -> Constraint:
+                                 location_resource_dict: dict = None, location_process_dict: dict = None, location_resource_sell_dict: dict = None, location_resource_purch_dict: dict = None, location_resource_store_dict: dict = None) -> Constraint:
     """balances resource across the scheduling horizon
     Mass balance in any temporal discretization has the following within their respective sets:
     - consumption for resources that can be purchased
@@ -85,6 +85,11 @@ def constraint_inventory_balance(instance: ConcreteModel, scheduling_scale_level
         cluster_wt (dict, optional): weight of cluster as determined through scenario aggregation. Defaults to None.
         inventory_zero (Dict[Location, Dict[Tuple[Process, Resource], float]], optional): inventory at the start of the scheduling horizon. Defaults to None.
         location_resource_dict (dict, optional): dict with resources in locations. Defaults to None.
+        location_process_dict (dict, optional): dict with processes in locations. Defaults to None.
+        location_resources_sell_dict (dict, optional): dict with resources in locations which can be sold. Defaults to None.
+        location_resources_purch_dict (dict, optional): dict with resources in locations which can be purchased/consumed. Defaults to None.
+        location_resources_store_dict (dict, optional): dict with resources in locations which can be stored. Defaults to None.
+
     Returns:
         Constraint: inventory_balance
     """
@@ -116,25 +121,34 @@ def constraint_inventory_balance(instance: ConcreteModel, scheduling_scale_level
 
     def inventory_balance_rule(instance, location, resource, *scale_list):
         if resource in instance.resources_purch:
-            consumption = instance.C[location, resource,
-                                     scale_list[:scheduling_scale_level + 1]]
+            if resource in location_resource_purch_dict[location]:
+                consumption = instance.C[location, resource,
+                                         scale_list[:scheduling_scale_level + 1]]
+            else:
+                consumption = 0
         else:
             consumption = 0
 
         if resource in instance.resources_store:
-            if scale_list[:scheduling_scale_level + 1] != scale_iter[0]:
-                storage = instance.Inv[location, resource, scale_list[:scheduling_scale_level + 1]] \
-                    - instance.Inv[location, resource, scale_iter[scale_iter.index(
-                        scale_list[:scheduling_scale_level + 1]) - 1]]
+            if resource in location_resource_store_dict[location]:
+                if scale_list[:scheduling_scale_level + 1] != scale_iter[0]:
+                    storage = instance.Inv[location, resource, scale_list[:scheduling_scale_level + 1]] \
+                        - instance.Inv[location, resource, scale_iter[scale_iter.index(
+                            scale_list[:scheduling_scale_level + 1]) - 1]]
+                else:
+                    storage = instance.Inv[location, resource,
+                                           scale_list[:scheduling_scale_level + 1]] - inventory_zero[location][resource]
             else:
-                storage = instance.Inv[location, resource,
-                                       scale_list[:scheduling_scale_level + 1]] - inventory_zero[location][resource]
+                storage = 0
         else:
             storage = 0
 
         if resource in instance.resources_sell:
-            discharge = instance.S[location, resource,
-                                   scale_list[:scheduling_scale_level + 1]]
+            if resource in location_resource_sell_dict[location]:
+                discharge = instance.S[location, resource,
+                                       scale_list[:scheduling_scale_level + 1]]
+            else:
+                discharge = 0
         else:
             discharge = 0
 
@@ -157,14 +171,28 @@ def inventory_balance_rule(instance, location, resource, *scale_list):
         # produced = sum(conversion[process][resource]*instance.P[location, process, scale_list[:scheduling_scale_level+1]] for process in instance.processes_singlem) \
         #     + sum(instance.P[location, process, scale_list[:scheduling_scale_level+1]] for process in instance.processes_multim)
 
-        produced = sum(sum(multiconversion[process][mode][resource] * instance.P_m[location, process, mode,
-                                                                                   scale_list[:scheduling_scale_level + 1]] for mode in mode_dict[process]) for process in
-                       instance.processes_full)  # includes processes + discharge
+        # produced = sum(sum(multiconversion[process][mode][resource] * instance.P_m[location, process, mode,
+        #                                                                            scale_list[:scheduling_scale_level + 1]] for mode in mode_dict[process]) for process in
+        #                instance.processes_full if process in location_process_dict[location])  # includes processes + discharge
+        produced = 0
+        for process in instance.processes_full:
+            if process in location_process_dict[location]:
+                for mode in mode_dict[process]:
+                    if multiconversion[process][mode][resource]:
+                        produced = produced + multiconversion[process][mode][resource] * instance.P_m[location, process, mode,
+                                                                                                      scale_list[:scheduling_scale_level + 1]]
+                    else:
+                        produced = produced + 0
 
         def weight(x): return 1 if cluster_wt is None else cluster_wt[x]
 
-        return weight(scale_list[:scheduling_scale_level + 1]) * (
-            consumption + produced - discharge + transport) == storage
+        if isinstance(produced, int):
+            if produced == 0:  # slightly unecessary
+                return Constraint.Skip
+
+        else:
+            return weight(scale_list[:scheduling_scale_level + 1]) * (
+                consumption + produced - discharge + transport) == storage
 
     instance.constraint_inventory_balance = Constraint(
         instance.locations, instance.resources, *scales, rule=inventory_balance_rule,
@@ -202,6 +230,62 @@ def weight(x): return 1 if cluster_wt is None else cluster_wt[x]
     return instance.constraint_location_production
 
 
+def constraint_location_production_material_mode_sum(instance: ConcreteModel, process_material_mode_material_dict: dict, network_scale_level: int = 0) -> Constraint:
+    """Determines total production capacity utilization at location
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        scheduling_scale_level (int, optional): scale of scheduling decisions. Defaults to 0.
+    Returns:
+        Constraint: location_production_material_mode_sum
+    """
+
+    scales = scale_list(instance=instance,
+                        scale_levels=network_scale_level + 1)
+
+    def location_production_material_mode_sum_rule(instance, location, process, *scale_list):
+        return instance.P_location[location, process, scale_list] == sum(
+            instance.P_location_material_m[location, process, material_mode_, scale_list] for material_mode_ in instance.material_modes if material_mode_ in process_material_mode_material_dict[process].keys())
+
+    instance.constraint_location_production_material_mode_sum = Constraint(
+        instance.locations, instance.processes, *
+        scales, rule=location_production_material_mode_sum_rule,
+        doc='total production at location')
+    constraint_latex_render(location_production_material_mode_sum_rule)
+    return instance.constraint_location_production_material_mode_sum
+
+
+def constraint_location_production_material_mode(instance: ConcreteModel, cluster_wt: dict,
+                                                 network_scale_level: int = 0, scheduling_scale_level: int = 0) -> Constraint:
+    """Determines total production capacity utilization at location
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        scheduling_scale_level (int, optional): scale of scheduling decisions. Defaults to 0.
+    Returns:
+        Constraint: location_production_material_mode
+    """
+
+    scales = scale_list(instance=instance,
+                        scale_levels=network_scale_level + 1)
+    scale_iter = scale_tuple(
+        instance=instance, scale_levels=scheduling_scale_level+1)
+
+    def location_production_material_mode_rule(instance, location, process, material_mode,  *scale_list):
+        def weight(x): return 1 if cluster_wt is None else cluster_wt[x]
+        return instance.P_location_material_m[location, process, material_mode, scale_list] == sum(
+            weight(scale_) * instance.P_material_m[location, process, material_mode, scale_[:scheduling_scale_level + 1]] for scale_ in scale_iter if scale_[:network_scale_level + 1] == scale_list)
+
+    instance.constraint_location_production_material_mode = Constraint(
+        instance.locations, instance.processes, instance.material_modes, *
+        scales, rule=location_production_material_mode_rule,
+        doc='total production at location')
+    constraint_latex_render(location_production_material_mode_rule)
+    return instance.constraint_location_production_material_mode
+
+
 def constraint_location_discharge(instance: ConcreteModel, cluster_wt: dict,
                                   network_scale_level: int = 0, scheduling_scale_level: int = 0) -> Constraint:
     """Determines total resource discharged/sold at locations in network
diff --git a/src/energiapy/model/constraints/transport.py b/src/energiapy/model/constraints/transport.py
index 7dd8f251..5e80084b 100644
--- a/src/energiapy/model/constraints/transport.py
+++ b/src/energiapy/model/constraints/transport.py
@@ -230,7 +230,83 @@ def transport_capacity_UB_rule(instance, source, sink, transport, *scale_list):
     return instance.constraint_transport_capacity_UB
 
 
-def constraint_transport_capex(instance: ConcreteModel, trans_capex: dict, distance_dict: dict, transport_avail_dict: dict, network_scale_level: int = 0):
+
+def constraint_transport_capacity_LB_no_bin(instance: ConcreteModel, network_scale_level: int = 0,
+                                     trans_min: dict = None, transport_avail_dict: dict = None) -> Constraint:
+    """Minimum capacity bound for transport mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        trans_max (dict, optional): Maximum allowed transportation. Defaults to {}.
+        transport_avail_dict (dict, optional): Modes of transportation available between locations. Defaults to {}.
+
+    Returns:
+        Constraint: transport_capacity_LB_no_bin
+    """
+
+    if trans_min is None:
+        trans_min = dict()
+
+    if transport_avail_dict is None:
+        transport_avail_dict = dict()
+
+    scales = scale_list(instance=instance,
+                        scale_levels=network_scale_level + 1)
+
+    def transport_capacity_LB_no_bin_rule(instance, source, sink,  transport, *scale_list):
+        if transport in transport_avail_dict[(source, sink)]:
+            return instance.Cap_F[source, sink, transport, scale_list[:network_scale_level + 1]] >= \
+                trans_min[transport] 
+        else:
+            return instance.Cap_F[source, sink, transport, scale_list[:network_scale_level + 1]] == 0
+
+    instance.constraint_transport_capacity_LB_no_bin = Constraint(instance.sources, instance.sinks,
+                                                           instance.transports, *scales, rule=transport_capacity_LB_no_bin_rule,
+                                                           doc='LB_no_bin for transport capacity')
+    constraint_latex_render(transport_capacity_LB_no_bin_rule)
+    return instance.constraint_transport_capacity_LB_no_bin
+
+
+def constraint_transport_capacity_UB_no_bin(instance: ConcreteModel, network_scale_level: int = 0,
+                                     trans_max: dict = None, transport_avail_dict: dict = None) -> Constraint:
+    """Maximum capacity bound for transport mode
+
+    Args:
+        instance (ConcreteModel): pyomo model instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+        trans_max (dict, optional): Maximum allowed transportation. Defaults to {}.
+        transport_avail_dict (dict, optional): Modes of transportation available between locations. Defaults to {}.
+
+    Returns:
+        Constraint: transport_capacity_UB_no_bin
+    """
+
+    if trans_max is None:
+        trans_max = dict()
+
+    if transport_avail_dict is None:
+        transport_avail_dict = dict()
+
+    scales = scale_list(instance=instance,
+                        scale_levels=network_scale_level + 1)
+
+    def transport_capacity_UB_no_bin_rule(instance, source, sink, transport, *scale_list):
+        if transport in transport_avail_dict[(source, sink)]:
+            return instance.Cap_F[source, sink, transport, scale_list[:network_scale_level + 1]] <= \
+                trans_max[transport] * instance.X_F[source, sink,
+                                                    transport, scale_list[:network_scale_level + 1]]
+        else:
+            return instance.Cap_F[source, sink, transport, scale_list[:network_scale_level + 1]] == 0
+
+    instance.constraint_transport_capacity_UB_no_bin = Constraint(instance.sources, instance.sinks,
+                                                           instance.transports, *scales, rule=transport_capacity_UB_no_bin_rule,
+                                                           doc='UB_no_bin for transport capacity')
+    constraint_latex_render(transport_capacity_UB_no_bin_rule)
+    return instance.constraint_transport_capacity_UB_no_bin
+
+
+def constraint_transport_capex(instance: ConcreteModel, trans_capex: dict, distance_dict: dict, transport_avail_dict: dict, network_scale_level: int = 0, annualization_factor:float = 1):
     """_summary_
 
     Args:
@@ -239,7 +315,7 @@ def constraint_transport_capex(instance: ConcreteModel, trans_capex: dict, dista
         distance_dict (dict): _description_
         transport_avail_dict (dict): _description_
         network_scale_level (int, optional): _description_. Defaults to 0.
-
+        annualization_factor (float, optional): 
     Returns:
         _type_: _description_
     """
@@ -248,7 +324,7 @@ def constraint_transport_capex(instance: ConcreteModel, trans_capex: dict, dista
 
     def transport_capex_rule(instance, source, sink, transport, *scale_list):
         if transport in transport_avail_dict[(source, sink)]:
-            return instance.Capex_transport[source, sink, transport, scale_list[:network_scale_level + 1]] == distance_dict[(source, sink)]*trans_capex[transport]*instance.Cap_F[source, sink, transport, scale_list[:network_scale_level + 1]]
+            return instance.Capex_transport[source, sink, transport, scale_list[:network_scale_level + 1]] == annualization_factor*distance_dict[(source, sink)]*trans_capex[transport]*instance.Cap_F[source, sink, transport, scale_list[:network_scale_level + 1]]
         else:
             return instance.Capex_transport[source, sink, transport, scale_list[:network_scale_level + 1]] == 0
     instance.constraint_transport_capex = Constraint(
diff --git a/src/energiapy/model/formulate.py b/src/energiapy/model/formulate.py
index cd48e6ae..62365dec 100644
--- a/src/energiapy/model/formulate.py
+++ b/src/energiapy/model/formulate.py
@@ -53,10 +53,53 @@
 from .constraints.emission import (
     constraint_global_warming_potential_location,
     constraint_global_warming_potential_material,
+    constraint_global_warming_potential_material_mode,
     constraint_global_warming_potential_network,
     constraint_global_warming_potential_network_reduction,
     constraint_global_warming_potential_process,
     constraint_global_warming_potential_resource,
+    constraint_global_warming_potential_resource_consumption,
+    constraint_global_warming_potential_resource_discharge,
+    constraint_acidification_potential_location,
+    constraint_acidification_potential_material,
+    constraint_acidification_potential_material_mode,
+    constraint_acidification_potential_network,
+    constraint_acidification_potential_process,
+    constraint_acidification_potential_resource,
+    constraint_acidification_potential_resource_consumption,
+    constraint_acidification_potential_resource_discharge,
+    constraint_ozone_depletion_potential_location,
+    constraint_ozone_depletion_potential_material,
+    constraint_ozone_depletion_potential_material_mode,
+    constraint_ozone_depletion_potential_network,
+    constraint_ozone_depletion_potential_process,
+    constraint_ozone_depletion_potential_resource,
+    constraint_ozone_depletion_potential_resource_consumption,
+    constraint_ozone_depletion_potential_resource_discharge,
+    constraint_terrestrial_eutrophication_potential_location,
+    constraint_terrestrial_eutrophication_potential_material,
+    constraint_terrestrial_eutrophication_potential_material_mode,
+    constraint_terrestrial_eutrophication_potential_network,
+    constraint_terrestrial_eutrophication_potential_process,
+    constraint_terrestrial_eutrophication_potential_resource,
+    constraint_terrestrial_eutrophication_potential_resource_consumption,
+    constraint_terrestrial_eutrophication_potential_resource_discharge,
+    constraint_freshwater_eutrophication_potential_location,
+    constraint_freshwater_eutrophication_potential_material,
+    constraint_freshwater_eutrophication_potential_material_mode,
+    constraint_freshwater_eutrophication_potential_network,
+    constraint_freshwater_eutrophication_potential_process,
+    constraint_freshwater_eutrophication_potential_resource,
+    constraint_freshwater_eutrophication_potential_resource_consumption,
+    constraint_freshwater_eutrophication_potential_resource_discharge,
+    constraint_marine_eutrophication_potential_location,
+    constraint_marine_eutrophication_potential_material,
+    constraint_marine_eutrophication_potential_material_mode,
+    constraint_marine_eutrophication_potential_network,
+    constraint_marine_eutrophication_potential_process,
+    constraint_marine_eutrophication_potential_resource,
+    constraint_marine_eutrophication_potential_resource_consumption,
+    constraint_marine_eutrophication_potential_resource_discharge,
 )
 from .constraints.failure import constraint_nameplate_production_failure
 from .constraints.inventory import (
@@ -84,6 +127,7 @@
     constraint_nameplate_production,
     constraint_production_max,
     constraint_production_min,
+    constraint_nameplate_production_material_mode
 )
 from .constraints.resource_balance import (
     constraint_inventory_balance,
@@ -94,7 +138,9 @@
     constraint_network_discharge,
     constraint_network_production,
     constraint_resource_consumption,
-    constraint_inventory_network
+    constraint_inventory_network,
+    constraint_location_production_material_mode,
+    constraint_location_production_material_mode_sum
 )
 
 from .constraints.demand import (
@@ -118,7 +164,9 @@
     constraint_transport_vopex,
     constraint_transport_network_vopex,
     constraint_transport_fopex,
-    constraint_transport_network_fopex
+    constraint_transport_network_fopex,
+    constraint_transport_capacity_UB_no_bin,
+    constraint_transport_capacity_LB_no_bin
 )
 from .constraints.uncertain import (
     constraint_uncertain_process_capacity,
@@ -140,7 +188,12 @@
 from .constraints.material import (
     constraint_material_process,
     constraint_material_location,
-    constraint_material_network
+    constraint_material_network,
+    constraint_production_facility_material_mode_binary,
+    constraint_production_facility_material_mode,
+    constraint_production_facility_material,
+    constraint_min_production_facility_material,
+    constraint_material_mode_process
 )
 from .objectives import (
     objective_cost,
@@ -149,7 +202,8 @@
     objective_profit,
     objective_gwp_min,
     objective_cost_w_demand_penalty,
-    objective_profit_w_demand_penalty
+    objective_profit_w_demand_penalty,
+    objective_emission_min
 )
 
 from .sets import generate_sets
@@ -212,6 +266,10 @@ class Objective(Enum):
     """
     Maximized profit with penalty for unmet resource demand
     """
+    EMISSION = auto()
+    """
+    Minimize emission using weighted sum method
+    """
 
 
 def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objective: Objective = None,
@@ -279,17 +337,20 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
         generate_sets(instance=instance, scenario=scenario)
 
         generate_scheduling_vars(
-            instance=instance, scale_level=scenario.scheduling_scale_level, mode_dict=scenario.mode_dict)
+            instance=instance, scale_level=scenario.scheduling_scale_level, mode_dict=scenario.mode_dict, scenario=scenario)
         generate_network_vars(
             instance=instance, scale_level=scenario.network_scale_level)
         generate_costing_vars(instance=instance)
 
+        generate_material_vars(
+            instance=instance, scale_level=scenario.network_scale_level)
+
         if Constraints.UNCERTAIN in constraints:
             generate_uncertainty_vars(
                 instance=instance, scale_level=scenario.scheduling_scale_level)
 
             constraint_uncertain_process_capacity(
-                instance=instance, capacity=scenario.prod_max, network_scale_level=scenario.network_scale_level)
+                instance=instance, capacity=scenario.cap_max, network_scale_level=scenario.network_scale_level)
             constraint_uncertain_resource_demand(
                 instance=instance, demand=demand, scheduling_scale_level=scenario.scheduling_scale_level)
 
@@ -386,6 +447,13 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
                 network_scale_level=scenario.network_scale_level)
 
             constraint_global_warming_potential_resource(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_global_warming_potential_resource_consumption(
+                instance=instance, resource_gwp_dict=scenario.resource_gwp_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_global_warming_potential_resource_discharge(
                 instance=instance, resource_gwp_dict=scenario.resource_gwp_dict,
                 network_scale_level=scenario.network_scale_level)
 
@@ -395,12 +463,154 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
             constraint_global_warming_potential_network(
                 instance=instance, network_scale_level=scenario.network_scale_level)
 
+            constraint_ozone_depletion_potential_process(
+                instance=instance, process_odp_dict=scenario.process_odp_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_ozone_depletion_potential_resource(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_ozone_depletion_potential_resource_consumption(
+                instance=instance, resource_odp_dict=scenario.resource_odp_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_ozone_depletion_potential_resource_discharge(
+                instance=instance, resource_odp_dict=scenario.resource_odp_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_ozone_depletion_potential_location(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_ozone_depletion_potential_network(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_acidification_potential_process(
+                instance=instance, process_acid_dict=scenario.process_acid_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_acidification_potential_resource(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_acidification_potential_resource_consumption(
+                instance=instance, resource_acid_dict=scenario.resource_acid_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_acidification_potential_resource_discharge(
+                instance=instance, resource_acid_dict=scenario.resource_acid_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_acidification_potential_location(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_acidification_potential_network(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_terrestrial_eutrophication_potential_process(
+                instance=instance, process_eutt_dict=scenario.process_eutt_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_terrestrial_eutrophication_potential_resource(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_terrestrial_eutrophication_potential_resource_consumption(
+                instance=instance, resource_eutt_dict=scenario.resource_eutt_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_terrestrial_eutrophication_potential_resource_discharge(
+                instance=instance, resource_eutt_dict=scenario.resource_eutt_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_terrestrial_eutrophication_potential_location(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_terrestrial_eutrophication_potential_network(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_freshwater_eutrophication_potential_process(
+                instance=instance, process_eutf_dict=scenario.process_eutf_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_freshwater_eutrophication_potential_resource(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_freshwater_eutrophication_potential_resource_consumption(
+                instance=instance, resource_eutf_dict=scenario.resource_eutf_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_freshwater_eutrophication_potential_resource_discharge(
+                instance=instance, resource_eutf_dict=scenario.resource_eutf_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_freshwater_eutrophication_potential_location(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_freshwater_eutrophication_potential_network(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_marine_eutrophication_potential_process(
+                instance=instance, process_eutm_dict=scenario.process_eutm_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_marine_eutrophication_potential_resource(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_marine_eutrophication_potential_resource_consumption(
+                instance=instance, resource_eutm_dict=scenario.resource_eutm_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_marine_eutrophication_potential_resource_discharge(
+                instance=instance, resource_eutm_dict=scenario.resource_eutm_dict,
+                network_scale_level=scenario.network_scale_level)
+
+            constraint_marine_eutrophication_potential_location(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
+            constraint_marine_eutrophication_potential_network(
+                instance=instance, network_scale_level=scenario.network_scale_level)
+
             if Constraints.MATERIAL in constraints:
 
                 constraint_global_warming_potential_material(
-                    instance=instance, material_gwp_dict=scenario.material_gwp_dict,
-                    process_material_dict=scenario.process_material_dict, network_scale_level=scenario.network_scale_level)
+                    instance=instance, network_scale_level=scenario.network_scale_level)
+
+                constraint_global_warming_potential_material_mode(instance=instance, material_gwp_dict=scenario.material_gwp_dict,
+                                                                  process_material_mode_material_dict=scenario.process_material_mode_material_dict,
+                                                                  network_scale_level=scenario.network_scale_level)
+
+                constraint_ozone_depletion_potential_material(
+                    instance=instance, network_scale_level=scenario.network_scale_level)
+
+                constraint_ozone_depletion_potential_material_mode(instance=instance, material_odp_dict=scenario.material_odp_dict,
+                                                                   process_material_mode_material_dict=scenario.process_material_mode_material_dict,
+                                                                   network_scale_level=scenario.network_scale_level)
+
+                constraint_acidification_potential_material(
+                    instance=instance, network_scale_level=scenario.network_scale_level)
+
+                constraint_acidification_potential_material_mode(instance=instance, material_acid_dict=scenario.material_acid_dict,
+                                                                 process_material_mode_material_dict=scenario.process_material_mode_material_dict,
+                                                                 network_scale_level=scenario.network_scale_level)
+
+                constraint_terrestrial_eutrophication_potential_material(
+                    instance=instance, network_scale_level=scenario.network_scale_level)
+
+                constraint_terrestrial_eutrophication_potential_material_mode(instance=instance, material_eutt_dict=scenario.material_eutt_dict,
+                                                                              process_material_mode_material_dict=scenario.process_material_mode_material_dict,
+                                                                              network_scale_level=scenario.network_scale_level)
+
+                constraint_freshwater_eutrophication_potential_material(
+                    instance=instance, network_scale_level=scenario.network_scale_level)
+
+                constraint_freshwater_eutrophication_potential_material_mode(instance=instance, material_eutf_dict=scenario.material_eutf_dict,
+                                                                             process_material_mode_material_dict=scenario.process_material_mode_material_dict,
+                                                                             network_scale_level=scenario.network_scale_level)
+
+                constraint_marine_eutrophication_potential_material(
+                    instance=instance, network_scale_level=scenario.network_scale_level)
 
+                constraint_marine_eutrophication_potential_material_mode(instance=instance, material_eutm_dict=scenario.material_eutm_dict,
+                                                                         process_material_mode_material_dict=scenario.process_material_mode_material_dict,
+                                                                         network_scale_level=scenario.network_scale_level)
         if Constraints.FAILURE in constraints:
             constraint_nameplate_production_failure(instance=instance, fail_factor=scenario.fail_factor,
                                                     network_scale_level=scenario.network_scale_level,
@@ -421,7 +631,7 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
 
         if Constraints.PRODUCTION in constraints:
 
-            constraint_production_mode(instance=instance, mode_dict=scenario.mode_dict,
+            constraint_production_mode(instance=instance, location_process_dict=scenario.location_process_dict, mode_dict=scenario.mode_dict,
                                        scheduling_scale_level=scenario.scheduling_scale_level)
 
             # *----------------nameplate production capacity---------------------------------------------
@@ -437,16 +647,16 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
 
             # *----------------production capacity bounds---------------------------------------------
 
-            # instance.constraint_production_max = make_constraint(instance=instance, type_cons=Cons.X_LEQ_BY, variable_x='Cap_P', variable_y='X_P', b_max=scenario.prod_max, location_set=instance.locations, component_set=instance.processes,
+            # instance.constraint_production_max = make_constraint(instance=instance, type_cons=Cons.X_LEQ_BY, variable_x='Cap_P', variable_y='X_P', b_max=scenario.cap_max, location_set=instance.locations, component_set=instance.processes,
             #                                                      loc_comp_dict=scenario.location_process_dict, x_scale_level=scenario.network_scale_level, y_scale_level=scenario.network_scale_level, label='restricts nameplate capacity to some UB')
 
-            # instance.constraint_production_min = make_constraint(instance=instance, type_cons=Cons.X_GEQ_BY, variable_x='Cap_P', variable_y='X_P', b_max=scenario.prod_min, location_set=instance.locations, component_set=instance.processes,
+            # instance.constraint_production_min = make_constraint(instance=instance, type_cons=Cons.X_GEQ_BY, variable_x='Cap_P', variable_y='X_P', b_max=scenario.cap_min, location_set=instance.locations, component_set=instance.processes,
             #                                                      loc_comp_dict=scenario.location_process_dict, x_scale_level=scenario.network_scale_level, y_scale_level=scenario.network_scale_level, label='restricts nameplate capacity to some LB')
 
-            instance.constraint_production_max = make_constraint(instance=instance, type_cons=Cons.X_LEQ_B, variable_x='Cap_P', b_max=scenario.prod_max, location_set=instance.locations, component_set=instance.processes,
+            instance.constraint_production_max = make_constraint(instance=instance, type_cons=Cons.X_LEQ_B, variable_x='Cap_P', b_max=scenario.cap_max, location_set=instance.locations, component_set=instance.processes,
                                                                  loc_comp_dict=scenario.location_process_dict, x_scale_level=scenario.network_scale_level, label='restricts nameplate capacity to some UB')
 
-            instance.constraint_production_min = make_constraint(instance=instance, type_cons=Cons.X_GEQ_B, variable_x='Cap_P', b_max=scenario.prod_min, location_set=instance.locations, component_set=instance.processes,
+            instance.constraint_production_min = make_constraint(instance=instance, type_cons=Cons.X_GEQ_B, variable_x='Cap_P', b_max=scenario.cap_min, location_set=instance.locations, component_set=instance.processes,
                                                                  loc_comp_dict=scenario.location_process_dict, x_scale_level=scenario.network_scale_level, label='restricts nameplate capacity to some LB')
 
         if Constraints.LAND in constraints:
@@ -487,7 +697,9 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
         if Constraints.RESOURCE_BALANCE in constraints:
             constraint_inventory_balance(instance=instance, scheduling_scale_level=scenario.scheduling_scale_level,
                                          multiconversion=scenario.multiconversion, mode_dict=scenario.mode_dict, inventory_zero=inventory_zero,
-                                         location_resource_dict=scenario.location_resource_dict)
+                                         location_resource_dict=scenario.location_resource_dict, location_process_dict=scenario.location_process_dict,
+                                         location_resource_purch_dict=scenario.location_resource_purch_dict, location_resource_sell_dict=scenario.location_resource_sell_dict,
+                                         location_resource_store_dict=scenario.location_resource_store_dict)
 
             # constraint_network_production(
             #     instance=instance, network_scale_level=scenario.network_scale_level)
@@ -575,13 +787,9 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
                 constraint_export(instance=instance, scheduling_scale_level=scenario.scheduling_scale_level,
                                   network_scale_level=scenario.network_scale_level, location_transport_resource_dict=scenario.location_transport_resource_dict,
                                   transport_capacity_factor=scenario.transport_capacity_factor, transport_capacity_scale_level=scenario.transport_capacity_scale_level)
-                constraint_transport_capacity_UB(instance=instance, network_scale_level=scenario.network_scale_level,
-                                                 transport_avail_dict=scenario.transport_avail_dict, trans_max=scenario.trans_max)
-                constraint_transport_capacity_LB(instance=instance, network_scale_level=scenario.network_scale_level,
-                                                 transport_avail_dict=scenario.transport_avail_dict, trans_min=scenario.trans_min)
 
                 constraint_transport_capex(instance=instance, trans_capex=scenario.trans_capex, distance_dict=scenario.distance_dict,
-                                           transport_avail_dict=scenario.transport_avail_dict, network_scale_level=scenario.network_scale_level)
+                                           transport_avail_dict=scenario.transport_avail_dict, network_scale_level=scenario.network_scale_level, annualization_factor=scenario.annualization_factor)
 
                 constraint_transport_network_capex(
                     instance=instance, network_scale_level=scenario.network_scale_level)
@@ -597,6 +805,11 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
                                            transport_avail_dict=scenario.transport_avail_dict, network_scale_level=scenario.network_scale_level)
                 constraint_transport_network_fopex(
                     instance=instance, network_scale_level=scenario.network_scale_level)
+
+                constraint_transport_capacity_UB_no_bin(instance=instance, network_scale_level=scenario.network_scale_level,
+                                                        transport_avail_dict=scenario.transport_avail_dict, trans_max=scenario.trans_max)
+                constraint_transport_capacity_LB_no_bin(instance=instance, network_scale_level=scenario.network_scale_level,
+                                                        transport_avail_dict=scenario.transport_avail_dict, trans_min=scenario.trans_min)
                 # constraint_transport_import(instance=instance, scheduling_scale_level=scenario.scheduling_scale_level,
                 #                             transport_avail_dict=scenario.transport_avail_dict)
                 # constraint_transport_exp_UB(instance=instance, scheduling_scale_level=scenario.scheduling_scale_level,
@@ -625,11 +838,11 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
                                         location_resource_dict=scenario.location_resource_dict,
                                         network_scale_level=scenario.network_scale_level)
 
-            constraint_production_facility(instance=instance, prod_max=scenario.prod_max,
+            constraint_production_facility(instance=instance, cap_max=scenario.cap_max,
                                            location_process_dict=scenario.location_process_dict,
                                            network_scale_level=scenario.network_scale_level)
 
-            constraint_min_production_facility(instance=instance, prod_min=scenario.prod_min,
+            constraint_min_production_facility(instance=instance, cap_min=scenario.cap_min,
                                                location_process_dict=scenario.location_process_dict,
                                                network_scale_level=scenario.network_scale_level)
 
@@ -640,6 +853,16 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
             instance.del_component(instance.constraint_storage_min)
             instance.del_component(instance.constraint_production_min)
 
+            if len(scenario.location_set) > 1:
+                constraint_transport_capacity_UB(instance=instance, network_scale_level=scenario.network_scale_level,
+                                                 transport_avail_dict=scenario.transport_avail_dict, trans_max=scenario.trans_max)
+                constraint_transport_capacity_LB(instance=instance, network_scale_level=scenario.network_scale_level,
+                                                 transport_avail_dict=scenario.transport_avail_dict, trans_min=scenario.trans_min)
+
+                instance.del_component(
+                    instance.constraint_transport_capacity_UB_no_bin)
+                instance.del_component(
+                    instance.constraint_transport_capacity_LB_no_bin)
         if Constraints.PRESERVE_NETWORK in constraints:
 
             constraint_preserve_capacity_facility(
@@ -649,10 +872,10 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
             generate_mode_vars(
                 instance=instance, scale_level=scenario.scheduling_scale_level, mode_dict=scenario.mode_dict)
 
-            constraint_production_mode_facility(instance=instance, prod_max=scenario.prod_max,
+            constraint_production_mode_facility(instance=instance, cap_max=scenario.cap_max,
                                                 location_process_dict=scenario.location_process_dict,
                                                 scheduling_scale_level=scenario.scheduling_scale_level)
-            constraint_min_production_mode_facility(instance=instance, prod_min=scenario.prod_min,
+            constraint_min_production_mode_facility(instance=instance, cap_min=scenario.cap_min,
                                                     location_process_dict=scenario.location_process_dict,
                                                     scheduling_scale_level=scenario.scheduling_scale_level)
             constraint_production_mode_binary(instance=instance, mode_dict=scenario.mode_dict,
@@ -666,8 +889,6 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
                 instance=instance, mode_dict=scenario.mode_dict, scheduling_scale_level=scenario.scheduling_scale_level)
 
         if Constraints.MATERIAL in constraints:
-            generate_material_vars(
-                instance=instance, scale_level=scenario.network_scale_level)
 
             constraint_material_process(
                 instance=instance, process_material_dict=scenario.process_material_dict, network_scale_level=scenario.network_scale_level)
@@ -675,6 +896,26 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
                 instance=instance, network_scale_level=scenario.network_scale_level)
             constraint_material_network(
                 instance=instance, network_scale_level=scenario.network_scale_level)
+            constraint_production_facility_material_mode(
+                instance=instance, network_scale_level=scenario.network_scale_level, location_process_dict=scenario.location_process_dict)
+            constraint_production_facility_material_mode_binary(
+                instance=instance, network_scale_level=scenario.network_scale_level, location_process_dict=scenario.location_process_dict)
+
+            constraint_production_facility_material(instance=instance, cap_max=scenario.cap_max, location_process_dict=scenario.location_process_dict,
+                                                    network_scale_level=scenario.network_scale_level, process_material_modes_dict=scenario.process_material_modes_dict)
+            constraint_min_production_facility_material(instance=instance, cap_min=scenario.cap_min, location_process_dict=scenario.location_process_dict,
+                                                        network_scale_level=scenario.network_scale_level, process_material_modes_dict=scenario.process_material_modes_dict)
+            constraint_material_mode_process(
+                instance=instance, process_material_mode_material_dict=scenario.process_material_mode_material_dict, network_scale_level=scenario.network_scale_level)
+
+            constraint_nameplate_production_material_mode(instance=instance, capacity_factor=scenario.capacity_factor, location_process_dict=scenario.location_process_dict,
+                                                          network_scale_level=scenario.network_scale_level, scheduling_scale_level=scenario.scheduling_scale_level)
+
+            constraint_location_production_material_mode(instance=instance, cluster_wt=scenario.cluster_wt,
+                                                         network_scale_level=scenario.network_scale_level, scheduling_scale_level=scenario.scheduling_scale_level)
+
+            constraint_location_production_material_mode_sum(
+                instance=instance, network_scale_level=scenario.network_scale_level,  process_material_mode_material_dict=scenario.process_material_mode_material_dict)
 
         if gwp is not None:
             constraint_global_warming_potential_network_reduction(
@@ -712,7 +953,7 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
             if Constraints.DEMAND in constraints:
                 constraint_demand(instance=instance, demand_scale_level=scenario.demand_scale_level,
                                   scheduling_scale_level=scenario.scheduling_scale_level, demand=demand,
-                                  demand_factor=scenario.demand_factor, location_resource_dict=scenario.location_resource_dict, sign=demand_sign)
+                                  demand_factor=scenario.demand_factor, location_resource_dict=scenario.location_resource_sell_dict, sign=demand_sign)
 
         if objective == Objective.COST:
 
@@ -756,6 +997,11 @@ def formulate(scenario: Scenario, constraints: Set[Constraints] = None, objectiv
             objective_gwp_min(
                 instance=instance, network_scale_level=scenario.network_scale_level)
 
+        if objective == Objective.EMISSION:
+
+            objective_emission_min(instance=instance, network_scale_level=scenario.network_scale_level, gwp_w=scenario.emission_weights.gwp, odp_w=scenario.emission_weights.odp, acid_w=scenario.emission_weights.acid,
+                                   eutt_w=scenario.emission_weights.eutt, eutf_w=scenario.emission_weights.eutf, eutm_w=scenario.emission_weights.eutm)
+
         if scenario.capacity_bounds is not None:
             constraint_min_capacity_facility(instance=instance, location_process_dict=scenario.location_process_dict,
                                              network_scale_level=scenario.network_scale_level, capacity_bounds=scenario.capacity_bounds)
diff --git a/src/energiapy/model/objectives.py b/src/energiapy/model/objectives.py
index 0a3e8c40..8b6c956a 100644
--- a/src/energiapy/model/objectives.py
+++ b/src/energiapy/model/objectives.py
@@ -22,13 +22,12 @@
 from ..model.constraints.constraints import Constraints
 
 
-def objective_cost(instance: ConcreteModel, constraints: Set[Constraints], network_scale_level: int = 0, annualization_factor: float = 1) -> Objective:
+def objective_cost(instance: ConcreteModel, constraints: Set[Constraints], network_scale_level: int = 0) -> Objective:
     """Objective to minimize total cost
 
     Args:
         instance (ConcreteModel): pyomo instance
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
-        annualization_factor (float, optional): fraction of capital expenditure incurred on an annual basis
 
     Returns:
         Objective: cost objective
@@ -60,13 +59,18 @@ def objective_cost_rule(instance):
             credit = 0
 
         if len(instance.locations) > 1:
-            cost_trans = sum(
-                instance.Capex_transport_network[scale_] for scale_ in scale_iter) + sum(
-                instance.Vopex_transport_network[scale_] for scale_ in scale_iter) + sum(
+            cost_trans_capex = sum(
+                instance.Capex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_vopex = sum(
+                instance.Vopex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_fopex = sum(
                 instance.Fopex_transport_network[scale_] for scale_ in scale_iter)
         else:
-            cost_trans = 0
-        return annualization_factor*capex + vopex + fopex + cost_purch + cost_trans + incidental + land_cost - credit + storage_cost
+            cost_trans_capex = 0
+            cost_trans_vopex = 0
+            cost_trans_fopex = 0
+
+        return capex + cost_trans_capex + vopex + fopex + cost_purch + cost_trans_vopex + cost_trans_fopex + incidental + land_cost - credit + storage_cost
 
     instance.objective_cost = Objective(
         rule=objective_cost_rule, doc='total cost')
@@ -75,15 +79,13 @@ def objective_cost_rule(instance):
 
 
 def objective_cost_w_demand_penalty(instance: ConcreteModel, demand_penalty: Dict[Location, Dict[Resource, float]], constraints: Set[Constraints],
-                                    network_scale_level: int = 0, demand_scale_level: int = 0, annualization_factor: float = 1) -> Objective:
+                                    network_scale_level: int = 0, demand_scale_level: int = 0) -> Objective:
     """Objective to minimize total cost with demand penalty
 
     Args:
         instance (ConcreteModel): pyomo instance
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
         demand_penalty (Dict[Location, Resource]): penalty for unmet demand for resource at each location
-        annualization_factor (float, optional): fraction of capital expenditure incurred on an annual basis
-
 
     Returns:
         Objective: cost objective
@@ -116,16 +118,20 @@ def objective_cost_w_demand_penalty_rule(instance):
             credit = 0
 
         if len(instance.locations) > 1:
-            cost_trans = sum(
-                instance.Capex_transport_network[scale_] for scale_ in scale_iter) + sum(
-                instance.Vopex_transport_network[scale_] for scale_ in scale_iter) + sum(
+            cost_trans_capex = sum(
+                instance.Capex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_vopex = sum(
+                instance.Vopex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_fopex = sum(
                 instance.Fopex_transport_network[scale_] for scale_ in scale_iter)
         else:
-            cost_trans = 0
+            cost_trans_capex = 0
+            cost_trans_vopex = 0
+            cost_trans_fopex = 0
 
         penalty = sum(demand_penalty[location_][resource_]*instance.Demand_penalty[location_, resource_, scale_] for location_, resource_, scale_ in product(
             instance.locations, instance.resources_demand, scale_iter_penalty))
-        return annualization_factor*capex + vopex + fopex + cost_purch + cost_trans + incidental + land_cost - credit + penalty
+        return capex + cost_trans_capex + vopex + fopex + cost_purch + cost_trans_vopex + cost_trans_fopex + incidental + land_cost - credit + penalty
     instance.objective_cost_w_demand_penalty = Objective(
         rule=objective_cost_w_demand_penalty_rule, doc='total cost with penalty for demand')
     constraint_latex_render(objective_cost_w_demand_penalty_rule)
@@ -133,14 +139,12 @@ def objective_cost_w_demand_penalty_rule(instance):
 
 
 def objective_uncertainty_cost(instance: ConcreteModel, penalty: float, network_scale_level: int = 0,
-                               uncertainty_scale_level: int = 0, annualization_factor: float = 1) -> Objective:
+                               uncertainty_scale_level: int = 0) -> Objective:
     """Objective to minimize total cost
 
     Args:
         instance (ConcreteModel): pyomo instance
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
-        annualization_factor (float, optional): fraction of capital expenditure incurred on an annual basis
-
 
     Returns:
         Objective: cost objective
@@ -159,13 +163,17 @@ def uncertainty_cost_objective_rule(instance):
         cap_penalty = penalty * sum(instance.Demand_slack[location_, scale_] for location_, scale_ in
                                     product(instance.locations, scale_iter_uncertainty))
         if len(instance.locations) > 1:
-            cost_trans = sum(
-                instance.Capex_transport_network[scale_] for scale_ in scale_iter) + sum(
-                instance.Vopex_transport_network[scale_] for scale_ in scale_iter) + sum(
+            cost_trans_capex = sum(
+                instance.Capex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_vopex = sum(
+                instance.Vopex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_fopex = sum(
                 instance.Fopex_transport_network[scale_] for scale_ in scale_iter)
         else:
-            cost_trans = 0
-        return annualization_factor*capex + vopex + fopex + cost_purch + cost_trans + cap_penalty
+            cost_trans_capex = 0
+            cost_trans_vopex = 0
+            cost_trans_fopex = 0
+        return capex + cost_trans_capex + vopex + fopex + cost_purch + cost_trans_vopex + cost_trans_fopex + cap_penalty
 
     instance.uncertainty_cost_objective = Objective(rule=uncertainty_cost_objective_rule,
                                                     doc='total purchase from network')
@@ -238,14 +246,12 @@ def objective_discharge_max_rule(instance, *scale_list):
     return instance.objective_discharge_max
 
 
-def objective_profit(instance: ConcreteModel, constraints: Set[Constraints], network_scale_level: int = 0, annualization_factor: float = 1) -> Objective:
+def objective_profit(instance: ConcreteModel, constraints: Set[Constraints], network_scale_level: int = 0) -> Objective:
     """Objective to maximize total profit
 
     Args:
         instance (ConcreteModel): pyomo instance
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
-        annualization_factor (float, optional): fraction of capital expenditure incurred on an annual basis
-
 
     Returns:
         Objective: profit objective
@@ -279,13 +285,17 @@ def objective_profit_rule(instance):
             credit = 0
 
         if len(instance.locations) > 1:
-            cost_trans = sum(
-                instance.Capex_transport_network[scale_] for scale_ in scale_iter) + sum(
-                instance.Vopex_transport_network[scale_] for scale_ in scale_iter) + sum(
+            cost_trans_capex = sum(
+                instance.Capex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_vopex = sum(
+                instance.Vopex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_fopex = sum(
                 instance.Fopex_transport_network[scale_] for scale_ in scale_iter)
         else:
-            cost_trans = 0
-        return -(annualization_factor*capex + vopex + fopex + cost_purch + cost_trans + incidental + land_cost) + credit + revenue
+            cost_trans_capex = 0
+            cost_trans_vopex = 0
+            cost_trans_fopex = 0
+        return -(capex + cost_trans_capex + vopex + fopex + cost_purch + cost_trans_vopex + cost_trans_fopex + incidental + land_cost) + credit + revenue
 
     instance.objective_profit = Objective(
         rule=objective_profit_rule, sense=maximize, doc='total profit')
@@ -294,13 +304,12 @@ def objective_profit_rule(instance):
 
 
 def objective_profit_w_demand_penalty(instance: ConcreteModel, demand_penalty: Dict[Location, Dict[Resource, float]], constraints: Set[Constraints],
-                                      network_scale_level: int = 0, demand_scale_level: int = 0, annualization_factor: float = 1) -> Objective:
+                                      network_scale_level: int = 0, demand_scale_level: int = 0) -> Objective:
     """Objective to maximize total profit with a penalty for unmet demand
 
     Args:
         instance (ConcreteModel): pyomo instance
         network_scale_level (int, optional): scale of network decisions. Defaults to 0.
-        annualization_factor (float, optional): fraction of capital expenditure incurred on an annual basis
 
     Returns:
         Objective: profit objective
@@ -336,16 +345,20 @@ def objective_profit_w_demand_penalty_rule(instance):
             credit = 0
 
         if len(instance.locations) > 1:
-            cost_trans = sum(
-                instance.Capex_transport_network[scale_] for scale_ in scale_iter) + sum(
-                instance.Vopex_transport_network[scale_] for scale_ in scale_iter) + sum(
+            cost_trans_capex = sum(
+                instance.Capex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_vopex = sum(
+                instance.Vopex_transport_network[scale_] for scale_ in scale_iter)
+            cost_trans_fopex = sum(
                 instance.Fopex_transport_network[scale_] for scale_ in scale_iter)
         else:
-            cost_trans = 0
+            cost_trans_capex = 0
+            cost_trans_vopex = 0
+            cost_trans_fopex = 0
 
         penalty = sum(demand_penalty[location_][resource_]*instance.Demand_penalty[location_, resource_, scale_] for location_, resource_, scale_ in product(
             instance.locations, instance.resources_demand, scale_iter_penalty))
-        return -(annualization_factor*capex + vopex + fopex + cost_purch + cost_trans + incidental + land_cost + penalty) + credit + revenue
+        return -(capex + cost_trans_capex + vopex + fopex + cost_purch + cost_trans_vopex + cost_trans_fopex + incidental + land_cost + penalty) + credit + revenue
 
     instance.objective_profit_w_demand_penalty = Objective(
         rule=objective_profit_w_demand_penalty_rule, sense=maximize, doc='total profit w demand_penalty')
@@ -373,3 +386,29 @@ def objective_gwp_min_rule(instance, *scale_list):
         rule=objective_gwp_min_rule, doc='minimize total gwp for network')
     constraint_latex_render(objective_gwp_min_rule)
     return instance.objective_gwp_min
+
+
+def objective_emission_min(instance: ConcreteModel, network_scale_level: int = 0, gwp_w: float = 0, odp_w: float = 0, acid_w: float = 0,
+                           eutt_w: float = 0, eutf_w: float = 0, eutm_w: float = 0) -> Objective:
+    """Minimize emission at network level using weighted sum method
+
+    Args:
+        instance (ConcreteModel): pyomo instance
+        network_scale_level (int, optional): scale of network decisions. Defaults to 0.
+
+    Returns:
+        Objective: objective_emission_min
+    """
+    scale_iter = scale_tuple(
+        instance=instance, scale_levels=network_scale_level + 1)
+
+    def objective_emission_min_rule(instance, *scale_list):
+        return gwp_w*sum(instance.global_warming_potential_network[scale_] for scale_ in scale_iter) + odp_w*sum(instance.ozone_depletion_potential_network[scale_] for scale_ in scale_iter) + \
+            acid_w*sum(instance.acidification_potential_network[scale_] for scale_ in scale_iter) + eutt_w*sum(instance.terrestrial_eutrophication_potential_network[scale_] for scale_ in scale_iter) + \
+            eutf_w*sum(instance.freshwater_eutrophication_potential_network[scale_] for scale_ in scale_iter) + eutm_w*sum(
+                instance.marine_eutrophication_potential_network[scale_] for scale_ in scale_iter)
+
+    instance.objective_emission_min = Objective(
+        rule=objective_emission_min_rule, doc='minimize total emission for network')
+    constraint_latex_render(objective_emission_min_rule)
+    return instance.objective_emission_min
diff --git a/src/energiapy/model/sets.py b/src/energiapy/model/sets.py
index 7b17fb61..db1d3ed1 100644
--- a/src/energiapy/model/sets.py
+++ b/src/energiapy/model/sets.py
@@ -147,6 +147,15 @@ def generate_sets(instance: ConcreteModel, scenario: Scenario):
     instance.processes_segments = Set(
         initialize=sets['processes_segments'], doc='Set of processes with PWL process segments')
 
+    instance.process_modes = Set(
+        scenario.set_dict['processes_full'], initialize=scenario.mode_dict, doc='Set of processes and thier modes')
+
+    instance.process_material_modes = Set(
+        initialize=sets['process_material_modes'], doc='Set of process and material combinations')
+
+    instance.material_modes = Set(
+        initialize=sets['material_modes'], doc='Set of material modes')
+
     if len(instance.locations) > 1:
 
         instance.transports_varying_capacity = Set(
@@ -176,14 +185,15 @@ def generate_sets(instance: ConcreteModel, scenario: Scenario):
         instance.transports_uncertain_vopex = Set(
             initialize=sets['transports_uncertain_vopex'], doc='Set of transports with uncertain vopex')
 
-    mode_lens = []
-    for j in scenario.location_set:
-        for i in scenario.process_set:
-            if i.name in scenario.location_process_dict[j.name]:
-                mode_lens.append(len(scenario.prod_max[j.name][i.name].keys()))
+    # mode_lens = []
+    # for j in scenario.location_set:
+    #     for i in scenario.process_set:
+    #         if i.name in scenario.location_process_dict[j.name]:
+    #             if isinstance(scenario.cap_max[j.name][i.name], dict) is True:
+    #                 mode_lens.append(len(scenario.cap_max[j.name][i.name].keys()))
 
-    instance.modes = Set(initialize=list(
-        range(max(mode_lens))), doc='Set of process modes')
+    # instance.modes = Set(initialize=list(
+    #     range(max(mode_lens))), doc='Set of process modes')
 
     if scenario.source_locations is not None:
         instance.sources = Set(
diff --git a/src/energiapy/model/solve.py b/src/energiapy/model/solve.py
index 72218e28..575670ae 100644
--- a/src/energiapy/model/solve.py
+++ b/src/energiapy/model/solve.py
@@ -50,7 +50,7 @@ def solve(solver: str, name: str, instance: ConcreteModel = None, matrix: dict =
             prog.solver.solvers['lp'] = 'gurobi'
             # prog.warnings()
             prog.display_warnings()
-            prog.process_constraints()
+            # prog.process_constraints()
             results = solve_mpqp(prog, mpqp_algorithm.combinatorial)
 
     else:
diff --git a/src/energiapy/model/variables/emission.py b/src/energiapy/model/variables/emission.py
index e5fc9a63..cca1d2e0 100644
--- a/src/energiapy/model/variables/emission.py
+++ b/src/energiapy/model/variables/emission.py
@@ -29,15 +29,109 @@ def generate_emission_vars(instance: ConcreteModel, scale_level: int = 0):
         instance.scales_emission_network, within=NonNegativeReals, doc='Carbon emissions across network at network_scale')
     instance.carbon_emission_location = Var(instance.locations, instance.scales_emission_network,
                                             within=NonNegativeReals, doc='Carbon emissions at location at network_scale')
+
     instance.global_warming_potential_location = Var(
         instance.locations, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused at each location')
     instance.global_warming_potential_network = Var(
         instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused at network scale')
     instance.global_warming_potential_process = Var(
         instance.locations, instance.processes, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each process')
+    instance.global_warming_potential_resource_consumption = Var(
+        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each resource at consumption')
+    # instance.global_warming_potential_resource_consumption_negative = Var(
+    #     instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each resource at consumption')
+    instance.global_warming_potential_resource_discharge = Var(
+        instance.locations, instance.resources_sell, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each resource at consumption')
     instance.global_warming_potential_resource = Var(
-        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each resource')
+        instance.locations, instance.resources, instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each resource')
     instance.global_warming_potential_material = Var(instance.locations, instance.processes_materials,
                                                      instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each material')
+    instance.global_warming_potential_material_mode = Var(instance.locations, instance.processes_materials, instance.material_modes,
+                                                          instance.scales_emission_network, within=NonNegativeReals, doc='global warming potential caused by each material')
+
+    instance.ozone_depletion_potential_location = Var(
+        instance.locations, instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused at each location')
+    instance.ozone_depletion_potential_network = Var(
+        instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused at network scale')
+    instance.ozone_depletion_potential_process = Var(
+        instance.locations, instance.processes, instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused by each process')
+    instance.ozone_depletion_potential_resource_consumption = Var(
+        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused by each resource at consumption')
+    instance.ozone_depletion_potential_resource_discharge = Var(
+        instance.locations, instance.resources_sell, instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused by each resource at consumption')
+    instance.ozone_depletion_potential_resource = Var(
+        instance.locations, instance.resources, instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused by each resource')
+    instance.ozone_depletion_potential_material = Var(instance.locations, instance.processes_materials,
+                                                      instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused by each material')
+    instance.ozone_depletion_potential_material_mode = Var(instance.locations, instance.processes_materials, instance.material_modes,
+                                                           instance.scales_emission_network, within=NonNegativeReals, doc='ozone depletion potential caused by each material')
+
+    instance.acidification_potential_location = Var(
+        instance.locations, instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused at each location')
+    instance.acidification_potential_network = Var(
+        instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused at network scale')
+    instance.acidification_potential_process = Var(
+        instance.locations, instance.processes, instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused by each process')
+    instance.acidification_potential_resource_consumption = Var(
+        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused by each resource at consumption')
+    instance.acidification_potential_resource_discharge = Var(
+        instance.locations, instance.resources_sell, instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused by each resource at consumption')
+    instance.acidification_potential_resource = Var(
+        instance.locations, instance.resources, instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused by each resource')
+    instance.acidification_potential_material = Var(instance.locations, instance.processes_materials,
+                                                    instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused by each material')
+    instance.acidification_potential_material_mode = Var(instance.locations, instance.processes_materials, instance.material_modes,
+                                                         instance.scales_emission_network, within=NonNegativeReals, doc='acidification potential caused by each material')
+
+    instance.terrestrial_eutrophication_potential_location = Var(
+        instance.locations, instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused at each location')
+    instance.terrestrial_eutrophication_potential_network = Var(
+        instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused at network scale')
+    instance.terrestrial_eutrophication_potential_process = Var(
+        instance.locations, instance.processes, instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused by each process')
+    instance.terrestrial_eutrophication_potential_resource_consumption = Var(
+        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused by each resource at consumption')
+    instance.terrestrial_eutrophication_potential_resource_discharge = Var(
+        instance.locations, instance.resources_sell, instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused by each resource at consumption')
+    instance.terrestrial_eutrophication_potential_resource = Var(
+        instance.locations, instance.resources, instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused by each resource')
+    instance.terrestrial_eutrophication_potential_material = Var(instance.locations, instance.processes_materials,
+                                                                 instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused by each material')
+    instance.terrestrial_eutrophication_potential_material_mode = Var(instance.locations, instance.processes_materials, instance.material_modes,
+                                                                      instance.scales_emission_network, within=NonNegativeReals, doc='terrestrial eutrophication potential caused by each material')
+
+    instance.freshwater_eutrophication_potential_location = Var(
+        instance.locations, instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused at each location')
+    instance.freshwater_eutrophication_potential_network = Var(
+        instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused at network scale')
+    instance.freshwater_eutrophication_potential_process = Var(
+        instance.locations, instance.processes, instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused by each process')
+    instance.freshwater_eutrophication_potential_resource_consumption = Var(
+        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused by each resource at consumption')
+    instance.freshwater_eutrophication_potential_resource_discharge = Var(
+        instance.locations, instance.resources_sell, instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused by each resource at consumption')
+    instance.freshwater_eutrophication_potential_resource = Var(
+        instance.locations, instance.resources, instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused by each resource')
+    instance.freshwater_eutrophication_potential_material = Var(instance.locations, instance.processes_materials,
+                                                                instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused by each material')
+    instance.freshwater_eutrophication_potential_material_mode = Var(instance.locations, instance.processes_materials, instance.material_modes,
+                                                                     instance.scales_emission_network, within=NonNegativeReals, doc='freshwater eutrophication potential caused by each material')
+
+    instance.marine_eutrophication_potential_location = Var(
+        instance.locations, instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused at each location')
+    instance.marine_eutrophication_potential_network = Var(
+        instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused at network scale')
+    instance.marine_eutrophication_potential_process = Var(
+        instance.locations, instance.processes, instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused by each process')
+    instance.marine_eutrophication_potential_resource_consumption = Var(
+        instance.locations, instance.resources_purch, instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused by each resource at consumption')
+    instance.marine_eutrophication_potential_resource_discharge = Var(
+        instance.locations, instance.resources_sell, instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused by each resource at consumption')
+    instance.marine_eutrophication_potential_resource = Var(
+        instance.locations, instance.resources, instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused by each resource')
+    instance.marine_eutrophication_potential_material = Var(instance.locations, instance.processes_materials,
+                                                            instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused by each material')
+    instance.marine_eutrophication_potential_material_mode = Var(instance.locations, instance.processes_materials, instance.material_modes,
+                                                                 instance.scales_emission_network, within=NonNegativeReals, doc='marine eutrophication potential caused by each material')
 
     return
diff --git a/src/energiapy/model/variables/material.py b/src/energiapy/model/variables/material.py
index fd45f459..d842f2eb 100644
--- a/src/energiapy/model/variables/material.py
+++ b/src/energiapy/model/variables/material.py
@@ -10,7 +10,7 @@
 __email__ = "cacodcar@tamu.edu"
 __status__ = "Production"
 
-from pyomo.environ import ConcreteModel, NonNegativeReals, Var
+from pyomo.environ import ConcreteModel, NonNegativeReals, Var, Binary
 
 from ...utils.scale_utils import scale_pyomo_set
 
@@ -22,13 +22,20 @@ def generate_material_vars(instance: ConcreteModel, scale_level: int = 0):
         instance (ConcreteModel): pyomo instance
         scale_level (int, optional):  scale for network variables. Defaults to 0.
     """
-    instance.scales_material_network = scale_pyomo_set(
-        instance=instance, scale_level=scale_level)
 
-    instance.material_process = Var(instance.locations, instance.processes, instance.materials,
-                                    instance.scales_material_network, within=NonNegativeReals, doc='materials utilized by each process')
-    instance.material_location = Var(instance.locations, instance.materials, instance.scales_material_network,
-                                     within=NonNegativeReals, doc='materials utilized at each location')
-    instance.material_network = Var(instance.materials, instance.scales_material_network,
-                                    within=NonNegativeReals, doc='materials utilized at network scale')
+    if hasattr(instance, 'materials') is True:
+        instance.scales_material_network = scale_pyomo_set(
+            instance=instance, scale_level=scale_level)
+        instance.material_mode_process = Var(instance.locations, instance.processes, instance.material_modes, instance.materials,
+                                             instance.scales_material_network, within=NonNegativeReals, doc='materials utilized in material mode for each process')
+        instance.material_process = Var(instance.locations, instance.processes, instance.materials,
+                                        instance.scales_material_network, within=NonNegativeReals, doc='materials utilized by each process')
+        instance.material_location = Var(instance.locations, instance.materials, instance.scales_material_network,
+                                         within=NonNegativeReals, doc='materials utilized at each location')
+        instance.material_network = Var(instance.materials, instance.scales_material_network,
+                                        within=NonNegativeReals, doc='materials utilized at network scale')
+        instance.X_M = Var(instance.locations, instance.process_material_modes,
+                           instance.scales_material_network, within=Binary, doc='binaries process material combinations')
+        instance.Cap_P_M = Var(instance.locations, instance.processes, instance.material_modes, instance.scales_material_network,
+                               within=NonNegativeReals, doc='capacity for process material combinations')
     return
diff --git a/src/energiapy/model/variables/mode.py b/src/energiapy/model/variables/mode.py
index 10f84fd3..11906437 100644
--- a/src/energiapy/model/variables/mode.py
+++ b/src/energiapy/model/variables/mode.py
@@ -32,6 +32,8 @@ def generate_mode_vars(instance: ConcreteModel, scale_level: int = 0, mode_dict:
 
     if mode_dict is None:
         mode_dict = dict()
+
+    
     instance.X_P_m = Var(instance.locations, [(i, j) for i in mode_dict.keys(
     ) for j in mode_dict[i]], instance.scales_scheduling, within=Binary, doc='Production mode binaries')
     instance.Cap_P_m = Var(instance.locations, [(i, j) for i in mode_dict.keys(
diff --git a/src/energiapy/model/variables/network.py b/src/energiapy/model/variables/network.py
index 7b73be71..10829198 100644
--- a/src/energiapy/model/variables/network.py
+++ b/src/energiapy/model/variables/network.py
@@ -31,6 +31,10 @@ def generate_network_vars(instance: ConcreteModel, scale_level: int = 0):
 
     instance.P_location = Var(instance.locations, instance.processes, instance.scales_network,
                               within=NonNegativeReals, doc='Total production at location')
+
+    instance.P_location_material_m = Var(instance.locations, instance.processes, instance.material_modes, instance.scales_network,
+                                         within=NonNegativeReals, doc='Total production at location in material mode')
+
     instance.S_location = Var(instance.locations, instance.resources_sell, instance.scales_network,
                               within=NonNegativeReals, doc='Total resource discharge at location')
     instance.R_location = Var(instance.locations, instance.resources_sell, instance.scales_network,
diff --git a/src/energiapy/model/variables/schedule.py b/src/energiapy/model/variables/schedule.py
index b43c41e8..9297feb4 100644
--- a/src/energiapy/model/variables/schedule.py
+++ b/src/energiapy/model/variables/schedule.py
@@ -11,12 +11,12 @@
 __email__ = "cacodcar@tamu.edu"
 __status__ = "Production"
 
-from pyomo.environ import ConcreteModel, NonNegativeReals, Var
-
+from pyomo.environ import ConcreteModel, NonNegativeReals, Var, Set
+from ...components.scenario import Scenario
 from ...utils.scale_utils import scale_pyomo_set
 
 
-def generate_scheduling_vars(instance: ConcreteModel, scale_level: int = 0, mode_dict: dict = None):
+def generate_scheduling_vars(instance: ConcreteModel, scenario: Scenario, scale_level: int = 0, mode_dict: dict = None):
     """declares pyomo variables for scheduling at the chosen scales
 
 
@@ -31,13 +31,21 @@ def generate_scheduling_vars(instance: ConcreteModel, scale_level: int = 0, mode
 
     instance.scales_scheduling = scale_pyomo_set(
         instance=instance, scale_level=scale_level)
-    instance.P = Var(instance.locations, instance.processes_full,
+    instance.P = Var(Set(initialize=[(i, j) for i in scenario.location_process_dict for j in scenario.location_process_dict[i]]),
                      instance.scales_scheduling, within=NonNegativeReals, doc='Production')
-    instance.B = Var(instance.locations, instance.resources_purch,
+    # instance.P = Var(instance.locations, instance.processes_full,
+    #                  instance.scales_scheduling, within=NonNegativeReals, doc='Production')
+    # instance.B = Var(instance.locations, instance.resources_purch,
+    #  instance.scales_scheduling, within=NonNegativeReals, doc='Purchase Expenditure')
+    instance.B = Var(Set(initialize=[(i, j) for i in scenario.location_resource_purch_dict for j in scenario.location_resource_purch_dict[i]]),
                      instance.scales_scheduling, within=NonNegativeReals, doc='Purchase Expenditure')
-    instance.C = Var(instance.locations, instance.resources_purch,
-                     instance.scales_scheduling, within=NonNegativeReals, doc='Resource Consumption')
-    instance.S = Var(instance.locations, instance.resources_sell,
+    # instance.C = Var(instance.locations, instance.resources_purch,
+    #  instance.scales_scheduling, within=NonNegativeReals, doc='Resource Consumption')
+    instance.C = Var(Set(initialize=[(i, j) for i in scenario.location_resource_purch_dict for j in scenario.location_resource_purch_dict[i]]),
+                     instance.scales_scheduling, within=NonNegativeReals, doc='Purchase Consumption')
+    # instance.S = Var(instance.locations, instance.resources_sell,
+    #  instance.scales_scheduling, within=NonNegativeReals, doc='Resource Dispensed/Sold')
+    instance.S = Var(Set(initialize=[(i, j) for i in scenario.location_resource_sell_dict for j in scenario.location_resource_sell_dict[i]]),
                      instance.scales_scheduling, within=NonNegativeReals, doc='Resource Dispensed/Sold')
     instance.R = Var(instance.locations, instance.resources_sell,
                      instance.scales_scheduling, within=NonNegativeReals, doc='Revenue from resource Sold')
@@ -48,8 +56,15 @@ def generate_scheduling_vars(instance: ConcreteModel, scale_level: int = 0, mode
     #                        instance.scales_scheduling, within=NonNegativeReals, doc='Resource import')
     #     instance.Exp = Var(instance.sources, instance.sinks, instance.resources_trans,
     #                        instance.scales_scheduling, within=NonNegativeReals, doc='Resource export')
-    instance.P_m = Var(instance.locations, [(i, j) for i in mode_dict.keys(
-    ) for j in mode_dict[i]], instance.scales_scheduling, within=NonNegativeReals, doc='Production modes')
+    # instance.P_m = Var(instance.locations, [(i, j) for i in mode_dict.keys(
+    # ) for j in mode_dict[i]], instance.scales_scheduling, within=NonNegativeReals, doc='Production modes')
+    instance.P_m = Var(Set(initialize=[(i, j, k) for i in scenario.location_process_dict for j in scenario.location_process_dict[i]
+                       for k in mode_dict[j]]), instance.scales_scheduling, within=NonNegativeReals, doc='Production modes')
+    # instance.P_m = Var(Set(initialize=[(instance.locations, [(i, j) for i in mode_dict.keys(
+    # ) for j in mode_dict[i]])]), instance.scales_scheduling, within=NonNegativeReals, doc='Production modes')
+
+    instance.P_material_m = Var(instance.locations, instance.processes, instance.material_modes,
+                                instance.scales_scheduling, within=NonNegativeReals, doc='Production in material modes')
     return
 
 
diff --git a/src/energiapy/model/weights.py b/src/energiapy/model/weights.py
new file mode 100644
index 00000000..ca9b8baa
--- /dev/null
+++ b/src/energiapy/model/weights.py
@@ -0,0 +1,43 @@
+"""Weights for multiobjective optimization (MOO)
+"""
+
+__author__ = "Rahul Kakodkar"
+__copyright__ = "Copyright 2023, Multi-parametric Optimization & Control Lab"
+__credits__ = ["Rahul Kakodkar", "Efstratios N. Pistikopoulos"]
+__license__ = "MIT"
+__version__ = "2.0.0"
+__maintainer__ = "Rahul Kakodkar"
+__email__ = "cacodcar@tamu.edu"
+__status__ = "Production"
+
+from dataclasses import dataclass
+from math import isclose
+from warnings import warn
+
+
+@dataclass
+class EmissionWeights:
+    """Weights for emission objective 
+
+    Args:
+        gwp (float): global warming potential 
+        odp (float): ozone depletion potential
+        acid (float): acidification potential 
+        eutt (float): terrestrial eutrophication potential
+        eutf (float): freshwater eutrophication potential
+        eutm (float): marine eutrophication potential
+    """
+
+    gwp: float
+    odp: float
+    acid: float
+    eutt: float
+    eutf: float
+    eutm: float
+
+    def __post_init__(self):
+
+        self.total = self.gwp + self.odp + self.acid + self.eutt + self.eutf + self.eutm
+
+        if isclose(self.total, 1, abs_tol=1e-2) is not True:
+            warn('Total of weights should be equal to 1, check self.total')
diff --git a/src/energiapy/plot/__init__.py b/src/energiapy/plot/__init__.py
index e69de29b..e3fb248a 100644
--- a/src/energiapy/plot/__init__.py
+++ b/src/energiapy/plot/__init__.py
@@ -0,0 +1,1 @@
+from .plot_results import CostX, CostY
diff --git a/src/energiapy/plot/plot_results.py b/src/energiapy/plot/plot_results.py
index 08ad5bac..f589aa2b 100644
--- a/src/energiapy/plot/plot_results.py
+++ b/src/energiapy/plot/plot_results.py
@@ -169,7 +169,7 @@ def capacity_utilization(results: Result, location: str, process: str = None, fi
         rc('text', usetex=usetex)
         fig, ax = plt.subplots(figsize=fig_size)
         y_ = [100*results.output['Cap_P'][i]/results.components['processes'][i[1]]
-              ['prod_max'] for i in results.output['Cap_P'].keys() if location in i]
+              ['cap_max'] for i in results.output['Cap_P'].keys() if location in i]
 
         title = f"Capacity utilization in {results.components['locations'][location]['label']}"
         plt.ylabel("\%")
diff --git a/src/energiapy/utils/data_utils.py b/src/energiapy/utils/data_utils.py
index c622a47d..704ba340 100644
--- a/src/energiapy/utils/data_utils.py
+++ b/src/energiapy/utils/data_utils.py
@@ -367,3 +367,23 @@ def calculate_hourly(data: pandas.DataFrame, column_name: str, what: str = 'mean
     results = pandas.DataFrame(results)
     results = results.drop(columns=['Date', 'Hour'])
     return results
+
+
+def get_depth(dictionary: dict) -> int:
+    """ finds depth of dictionary
+    
+    Args:
+        dictionary (dict): dictionary
+
+    Returns:
+        int: depth of dictionary
+    """
+    if not isinstance(dictionary, dict) or not dictionary:
+        # If the input is not a dictionary or is an empty dictionary, return 0
+        return 0
+    
+    # Recursively find the maximum depth of nested dictionaries
+    max_depth = max(get_depth(value) for value in dictionary.values())
+    
+    # Return one more than the maximum depth found
+    return 1 + max_depth
\ No newline at end of file
diff --git a/src/energiapy/utils/math_utils.py b/src/energiapy/utils/math_utils.py
index 20ba2a54..475533ce 100644
--- a/src/energiapy/utils/math_utils.py
+++ b/src/energiapy/utils/math_utils.py
@@ -13,7 +13,7 @@
 
 import numpy
 import pandas
-from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
 from typing import Union
 from math import erf, sqrt, pi, exp
 
@@ -132,7 +132,10 @@ def normalize(data: Union[numpy.array, pandas.DataFrame]) -> Union[numpy.array,
     Returns:
         Union[numpy.array, pandas.DataFrame]: min-maxed data array
     """
-    max_data = numpy.max(data)
-    data = data / max_data
+    scaler = MinMaxScaler()
+    data = numpy.array(data).reshape(-1, 1)
+    data = scaler.fit_transform(data)
+    # max_data = numpy.max(data)
+    # data = data / max_data
 
     return data
diff --git a/src/energiapy/utils/process_utils.py b/src/energiapy/utils/process_utils.py
index 2ebd7c11..e6aec0f5 100644
--- a/src/energiapy/utils/process_utils.py
+++ b/src/energiapy/utils/process_utils.py
@@ -22,7 +22,7 @@ def create_storage_process(process) -> Process:
     Returns:
         Process: Dummy process for storage
     """
-    process_dummy = Process(name=process.name+'_discharge', conversion=process.conversion_discharge, prod_min=process.prod_min,
-                            prod_max=process.prod_max, introduce=process.introduce, retire=process.retire, capex=0, vopex=0, fopex=0,
-                            lifetime=process.lifetime, label=process.label + '_storage')
+    process_dummy = Process(name=process.name+'_discharge', conversion=process.conversion_discharge, cap_min=process.cap_min,
+                            cap_max=process.cap_max, introduce=process.introduce, retire=process.retire, capex=0, vopex=0, fopex=0,
+                            lifetime=process.lifetime, label=process.label + '_storage', material_cons=None)
     return process_dummy


Test patch:
diff --git a/tests/component_tests/__init__.py b/tests/component_tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/component_tests/location_test.py b/tests/component_tests/location_test.py
new file mode 100644
index 00000000..d2d397af
--- /dev/null
+++ b/tests/component_tests/location_test.py
@@ -0,0 +1,10 @@
+from tests.test_fixtures import location_no_variability
+
+
+# def test_location_no_variability(location_no_variability):
+#     assert (location_no_variability.cap_max == {'Process1': {0: 100}, 'Process2': {
+#             0: 100}, 'Process3': {0: 10, 1: 50}, 'Process1_discharge': {0: 100}})
+#     assert (location_no_variability.cap_min == {'Process1': {0: 0.1}, 'Process2': {
+#             0: 0.1}, 'Process3': {0: 0, 1: 10}, 'Process1_discharge': {0: 0.1}})
+#     assert (location_no_variability.storage_cost_dict ==
+#             {'Process1_Resource2_stored': 0.1})
diff --git a/tests/component_tests/process_test.py b/tests/component_tests/process_test.py
new file mode 100644
index 00000000..92b9fc80
--- /dev/null
+++ b/tests/component_tests/process_test.py
@@ -0,0 +1,27 @@
+# , process_multiple_modes
+from tests.test_fixtures import process_material_modes, process_storage
+from src.energiapy.components.process import MaterialMode, ProcessMode, VaryingProcess
+
+
+def test_process_material_modes(process_material_modes):
+    assert (process_material_modes.resource_req == {'Resource1', 'Resource2'})
+    assert (process_material_modes.material_modes == {'Mode1', 'Mode2'})
+    assert (process_material_modes.capacity_segments == ['Mode1', 'Mode2'])
+    assert (process_material_modes.capex_segments == [2000, 1000])
+    assert (process_material_modes.materialmode == MaterialMode.MULTI)
+    assert (process_material_modes.processmode == ProcessMode.MULTI)
+
+
+def test_process_storage(process_storage):
+    assert (process_storage.conversion == {
+            process_storage.storage: -1, process_storage.resource_storage: 1})
+    assert (process_storage.processmode == ProcessMode.STORAGE)
+    assert (process_storage.resource_req == {
+            'Process1_Resource1_stored', 'Resource1'})
+    assert (process_storage.conversion_discharge == {
+            process_storage.storage: 0.99, process_storage.resource_storage: -1})
+
+
+# def test_process_multiple_modes(process_multiple_modes):
+#     assert (VaryingProcess.MULTIMODE in process_multiple_modes.varying)
+#     assert (process_multiple_modes.processmode == ProcessMode.MULTI)
diff --git a/tests/component_tests/resource_test.py b/tests/component_tests/resource_test.py
new file mode 100644
index 00000000..a795978f
--- /dev/null
+++ b/tests/component_tests/resource_test.py
@@ -0,0 +1,1 @@
+# from tests.test_fixtures import resource_deterministic_availability, resource_deterministic_demand, resource_deterministic_price, resource_deterministic_revenue
diff --git a/tests/component_tests/scenario_test.py b/tests/component_tests/scenario_test.py
new file mode 100644
index 00000000..d54bc2ea
--- /dev/null
+++ b/tests/component_tests/scenario_test.py
@@ -0,0 +1,82 @@
+from tests.test_fixtures import single_location_scenario_variability
+
+
+def test_single_location_scenario_variability_sets(single_location_scenario_variability):
+    assert (single_location_scenario_variability.set_dict['resources'] == ['process_storage_resource_deterministic_demand_stored', 'resource_certain_availability',
+            'resource_deterministic_availability', 'resource_deterministic_demand', 'resource_deterministic_price', 'resource_deterministic_revenue'])
+    assert (single_location_scenario_variability.set_dict['resources_nosell'] == [
+            'process_storage_resource_deterministic_demand_stored', 'resource_certain_availability', 'resource_deterministic_availability', 'resource_deterministic_price'])
+    assert (single_location_scenario_variability.set_dict['resources_sell'] == [
+            'resource_deterministic_demand', 'resource_deterministic_revenue'])
+    assert (single_location_scenario_variability.set_dict['resources_store'] == [
+            'process_storage_resource_deterministic_demand_stored'])
+    assert (single_location_scenario_variability.set_dict['resources_purch'] == [
+            'resource_certain_availability', 'resource_deterministic_availability', 'resource_deterministic_price'])
+    assert (single_location_scenario_variability.set_dict['resources_varying_demand'] == [
+            'resource_deterministic_demand'])
+    assert (single_location_scenario_variability.set_dict['resources_certain_demand'] == [
+            'resource_deterministic_revenue'])
+    assert (
+        single_location_scenario_variability.set_dict['resources_uncertain_demand'] == [])
+    assert (single_location_scenario_variability.set_dict['resources_varying_price'] == [
+            'resource_deterministic_price'])
+    assert (single_location_scenario_variability.set_dict['resources_certain_price'] == [
+            'resource_certain_availability', 'resource_deterministic_availability'])
+    assert (
+        single_location_scenario_variability.set_dict['resources_uncertain_price'] == [])
+    assert (single_location_scenario_variability.set_dict['resources_varying_revenue'] == [
+            'resource_deterministic_revenue'])
+    assert (single_location_scenario_variability.set_dict['resources_certain_revenue'] == [
+            'resource_deterministic_demand'])
+    assert (
+        single_location_scenario_variability.set_dict['resources_uncertain_revenue'] == [])
+    assert (single_location_scenario_variability.set_dict['resources_varying_availability'] == [
+            'resource_deterministic_availability'])
+    assert (single_location_scenario_variability.set_dict['resources_certain_availability'] == [
+            'resource_certain_availability', 'resource_deterministic_price'])
+    assert (
+        single_location_scenario_variability.set_dict['resources_uncertain_availability'] == [])
+    assert (single_location_scenario_variability.set_dict['resources_demand'] == [
+            'resource_deterministic_demand', 'resource_deterministic_revenue'])
+    assert (
+        single_location_scenario_variability.set_dict['resources_implicit'] == [])
+    assert (single_location_scenario_variability.set_dict['processes'] == [
+            'process_certain_capacity', 'process_deterministic_capacity', 'process_storage', 'process_storage_discharge'])
+    assert (single_location_scenario_variability.set_dict['processes_full'] == [
+            'process_certain_capacity', 'process_deterministic_capacity', 'process_storage', 'process_storage_discharge'])
+    assert (
+        single_location_scenario_variability.set_dict['processes_failure'] == [])
+    assert (single_location_scenario_variability.set_dict['processes_materials'] == [
+            'process_certain_capacity', 'process_deterministic_capacity', 'process_storage', 'process_storage_discharge'])
+    assert (single_location_scenario_variability.set_dict['processes_storage'] == [
+            'process_storage'])
+    assert (
+        single_location_scenario_variability.set_dict['processes_multim'] == [])
+    assert (single_location_scenario_variability.set_dict['processes_singlem'] == [
+            'process_certain_capacity', 'process_deterministic_capacity', 'process_storage', 'process_storage_discharge'])
+    assert (single_location_scenario_variability.set_dict['processes_certain_capacity'] == [
+            'process_certain_capacity', 'process_storage', 'process_storage_discharge'])
+    assert (single_location_scenario_variability.set_dict['processes_varying_capacity'] == [
+            'process_deterministic_capacity'])
+    assert (
+        single_location_scenario_variability.set_dict['processes_uncertain_capacity'] == [])
+    assert (single_location_scenario_variability.set_dict['processes_certain_expenditure'] == [
+            'process_certain_capacity', 'process_storage', 'process_storage_discharge'])
+    assert (
+        single_location_scenario_variability.set_dict['processes_varying_expenditure'] == [])
+    assert (
+        single_location_scenario_variability.set_dict['processes_uncertain_expenditure'] == [])
+    assert (
+        single_location_scenario_variability.set_dict['processes_segments'] == [])
+    assert (
+        single_location_scenario_variability.set_dict['locations'] == ['location'])
+    assert (single_location_scenario_variability.set_dict['materials'] == [])
+    assert (
+        single_location_scenario_variability.set_dict['process_material_modes'] == [])
+    assert (
+        single_location_scenario_variability.set_dict['material_modes'] == [])
+    assert (single_location_scenario_variability.set_dict['sources'] == [])
+    assert (single_location_scenario_variability.set_dict['sinks'] == [])
+    assert (single_location_scenario_variability.set_dict['transports'] == [])
+    assert (
+        single_location_scenario_variability.set_dict['resources_trans'] == [])
diff --git a/tests/component_tests/temporal_scale_test.py b/tests/component_tests/temporal_scale_test.py
new file mode 100644
index 00000000..70d975b9
--- /dev/null
+++ b/tests/component_tests/temporal_scale_test.py
@@ -0,0 +1,20 @@
+from tests.test_fixtures import temporal_scale
+
+
+def test_temporal_scale_levels(temporal_scale):
+    assert (temporal_scale.scale_levels == 2)
+
+
+def test_temporal_scale_scale(temporal_scale):
+    assert (temporal_scale.scale == {0: [0], 1: [0, 1, 2, 3]})
+
+
+def test_temporal_scale_list(temporal_scale):
+    assert (temporal_scale.list == [0, 1])
+
+
+def test_temporal_scale_scale_iter(temporal_scale):
+    assert (temporal_scale.scale_iter(0) == [(0,)])
+    assert (temporal_scale.scale_iter(1) == [(0, 0), (0, 1), (0, 2), (0, 3)])
+
+
diff --git a/tests/problem_tests/__init__.py b/tests/problem_tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/problem_tests/lp_test.py b/tests/problem_tests/lp_test.py
new file mode 100644
index 00000000..2fc5caa6
--- /dev/null
+++ b/tests/problem_tests/lp_test.py
@@ -0,0 +1,355 @@
+from tests.test_fixtures import single_location_scenario_variability, single_location_lp_variability_cost, single_location_lp_variability_profit
+from src.energiapy.model.solve import solve
+from src.energiapy.model.formulate import formulate
+
+
+def test_results_single_location_lp_variability_cost(single_location_scenario_variability, single_location_lp_variability_cost):
+    results = solve(scenario=single_location_scenario_variability,
+                    instance=single_location_lp_variability_cost, solver='gurobi', name='LP')
+
+    assert (results.output == {'termination': 'optimal',
+                               'LB': 47423.33333333333,
+                               'UB': 47423.33333333333,
+                               'n_cons': 154,
+                               'n_vars': 138,
+                               'n_binvars': 0,
+                               'n_intvars': 0,
+                               'n_convars': 138,
+                               'n_nonzero': 341,
+                               'P': {('location', 'process_certain_capacity', 0, 0): 25.0,
+                                     ('location', 'process_certain_capacity', 0, 1): 25.0,
+                                     ('location', 'process_certain_capacity', 0, 2): 25.0,
+                                     ('location', 'process_certain_capacity', 0, 3): 25.0,
+                                     ('location', 'process_deterministic_capacity', 0, 0): 41.666666666666664,
+                                     ('location', 'process_deterministic_capacity', 0, 1): 20.833333333333332,
+                                     ('location', 'process_deterministic_capacity', 0, 2): 33.333333333333336,
+                                     ('location', 'process_deterministic_capacity', 0, 3): 10.416666666666666,
+                                     ('location', 'process_storage', 0, 0): 16.666666666666668,
+                                     ('location', 'process_storage', 0, 1): 0.0,
+                                     ('location', 'process_storage', 0, 2): 8.333333333333334,
+                                     ('location', 'process_storage', 0, 3): 0.0,
+                                     ('location', 'process_storage_discharge', 0, 0): 0.0,
+                                     ('location', 'process_storage_discharge', 0, 1): 16.666666666666668,
+                                     ('location', 'process_storage_discharge', 0, 2): 0.0,
+                                     ('location', 'process_storage_discharge', 0, 3): 8.333333333333334},
+                               'B': {('location', 'resource_certain_availability', 0, 0): 83.33333333333333,
+                                     ('location', 'resource_certain_availability', 0, 1): 41.666666666666664,
+                                     ('location', 'resource_certain_availability', 0, 2): 66.66666666666667,
+                                     ('location', 'resource_certain_availability', 0, 3): 20.833333333333332,
+                                     ('location', 'resource_deterministic_availability', 0, 0): 62.5,
+                                     ('location', 'resource_deterministic_availability', 0, 1): 62.5,
+                                     ('location', 'resource_deterministic_availability', 0, 2): 62.5,
+                                     ('location', 'resource_deterministic_availability', 0, 3): 62.5,
+                                     ('location', 'resource_deterministic_price', 0, 0): 15.625,
+                                     ('location', 'resource_deterministic_price', 0, 1): 62.5,
+                                     ('location', 'resource_deterministic_price', 0, 2): 31.25,
+                                     ('location', 'resource_deterministic_price', 0, 3): 46.875},
+                               'C': {('location', 'resource_certain_availability', 0, 0): 41.666666666666664,
+                                     ('location', 'resource_certain_availability', 0, 1): 20.833333333333332,
+                                     ('location', 'resource_certain_availability', 0, 2): 33.333333333333336,
+                                     ('location', 'resource_certain_availability', 0, 3): 10.416666666666666,
+                                     ('location', 'resource_deterministic_availability', 0, 0): 12.5,
+                                     ('location', 'resource_deterministic_availability', 0, 1): 12.5,
+                                     ('location', 'resource_deterministic_availability', 0, 2): 12.5,
+                                     ('location', 'resource_deterministic_availability', 0, 3): 12.5,
+                                     ('location', 'resource_deterministic_price', 0, 0): 6.25,
+                                     ('location', 'resource_deterministic_price', 0, 1): 6.25,
+                                     ('location', 'resource_deterministic_price', 0, 2): 6.25,
+                                     ('location', 'resource_deterministic_price', 0, 3): 6.25},
+                               'S': {('location', 'resource_deterministic_demand', 0, 0): 12.5,
+                                     ('location', 'resource_deterministic_demand', 0, 1): 25.0,
+                                     ('location', 'resource_deterministic_demand', 0, 2): 12.5,
+                                     ('location', 'resource_deterministic_demand', 0, 3): 6.25,
+                                     ('location', 'resource_deterministic_revenue', 0, 0): 25.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 1): 25.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 2): 25.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 3): 25.0},
+                               'R': {('location', 'resource_deterministic_demand', 0, 0): None,
+                                     ('location', 'resource_deterministic_demand', 0, 1): None,
+                                     ('location', 'resource_deterministic_demand', 0, 2): None,
+                                     ('location', 'resource_deterministic_demand', 0, 3): None,
+                                     ('location', 'resource_deterministic_revenue', 0, 0): None,
+                                     ('location', 'resource_deterministic_revenue', 0, 1): None,
+                                     ('location', 'resource_deterministic_revenue', 0, 2): None,
+                                     ('location', 'resource_deterministic_revenue', 0, 3): None},
+                               'Inv': {('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        0): 16.666666666666668,
+                                       ('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        1): 0.0,
+                                       ('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        2): 8.333333333333334,
+                                       ('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        3): 0.0},
+                               'P_m': {('location', 'process_storage', 0, 0, 0): 16.666666666666668,
+                                       ('location', 'process_storage', 0, 0, 1): 0.0,
+                                       ('location', 'process_storage', 0, 0, 2): 8.333333333333334,
+                                       ('location', 'process_storage', 0, 0, 3): 0.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 0): 25.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 1): 25.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 2): 25.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 3): 25.0,
+                                       ('location', 'process_storage_discharge', 0, 0, 0): 0.0,
+                                       ('location', 'process_storage_discharge', 0, 0, 1): 16.666666666666668,
+                                       ('location', 'process_storage_discharge', 0, 0, 2): 0.0,
+                                       ('location', 'process_storage_discharge', 0, 0, 3): 8.333333333333334,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 0): 41.666666666666664,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 1): 20.833333333333332,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 2): 33.333333333333336,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 3): 10.416666666666666},
+                               'P_material_m': {},
+                               'Cap_P': {('location', 'process_certain_capacity', 0): 25.0,
+                                         ('location', 'process_deterministic_capacity', 0): 41.666666666666664,
+                                         ('location', 'process_storage', 0): 16.666666666666668,
+                                         ('location', 'process_storage_discharge', 0): 50.0},
+                               'Cap_S': {('location',
+                                          'process_storage_resource_deterministic_demand_stored',
+                                          0): 25.0},
+                               'P_location': {('location', 'process_certain_capacity', 0): 100.0,
+                                              ('location', 'process_deterministic_capacity', 0): 106.25,
+                                              ('location', 'process_storage', 0): 25.0,
+                                              ('location', 'process_storage_discharge', 0): 25.0},
+                               'P_location_material_m': {},
+                               'S_location': {('location', 'resource_deterministic_demand', 0): 56.25,
+                                              ('location', 'resource_deterministic_revenue', 0): 100.0},
+                               'R_location': {('location', 'resource_deterministic_demand', 0): None,
+                                              ('location', 'resource_deterministic_revenue', 0): None},
+                               'C_location': {('location',
+                                               'resource_certain_availability',
+                                               0): 106.25000000000001,
+                                              ('location', 'resource_deterministic_availability', 0): 50.0,
+                                              ('location', 'resource_deterministic_price', 0): 25.0},
+                               'B_location': {('location',
+                                               'resource_certain_availability',
+                                               0): 212.50000000000003,
+                                              ('location', 'resource_deterministic_availability', 0): 250.0,
+                                              ('location', 'resource_deterministic_price', 0): 156.25},
+                               'P_network': {('process_certain_capacity', 0): 100.0,
+                                             ('process_deterministic_capacity', 0): 106.25,
+                                             ('process_storage', 0): 25.0,
+                                             ('process_storage_discharge', 0): 25.0},
+                               'S_network': {('resource_deterministic_demand', 0): 56.25,
+                                             ('resource_deterministic_revenue', 0): 100.0},
+                               'R_network': {('resource_deterministic_demand', 0): None,
+                                             ('resource_deterministic_revenue', 0): None},
+                               'C_network': {('resource_certain_availability', 0): 106.25000000000001,
+                                             ('resource_deterministic_availability', 0): 50.0,
+                                             ('resource_deterministic_price', 0): 25.0},
+                               'B_network': {('resource_certain_availability', 0): 212.50000000000003,
+                                             ('resource_deterministic_availability', 0): 250.0,
+                                             ('resource_deterministic_price', 0): 156.25},
+                               'Fopex_process': {('location', 'process_certain_capacity', 0): 250.0,
+                                                 ('location', 'process_deterministic_capacity', 0): 416.66666666666663,
+                                                 ('location', 'process_storage', 0): 83.33333333333334,
+                                                 ('location', 'process_storage_discharge', 0): 0.0},
+                               'Vopex_process': {('location', 'process_certain_capacity', 0): 100.0,
+                                                 ('location', 'process_deterministic_capacity', 0): 106.25,
+                                                 ('location', 'process_storage', 0): 12.5,
+                                                 ('location', 'process_storage_discharge', 0): 0.0},
+                               'Capex_process': {('location', 'process_certain_capacity', 0): 2500.0,
+                                                 ('location', 'process_deterministic_capacity', 0): 41666.666666666664,
+                                                 ('location', 'process_storage', 0): 1666.6666666666667,
+                                                 ('location', 'process_storage_discharge', 0): 0.0},
+                               'Incidental_process': {('location', 'process_certain_capacity', 0): 0.0,
+                                                      ('location', 'process_deterministic_capacity', 0): 0.0,
+                                                      ('location', 'process_storage', 0): 0.0,
+                                                      ('location', 'process_storage_discharge', 0): 0.0},
+                               'Fopex_location': {('location', 0): 750.0},
+                               'Vopex_location': {('location', 0): 218.75},
+                               'Capex_location': {('location', 0): 45833.33333333333},
+                               'Incidental_location': {('location', 0): 0.0},
+                               'Fopex_network': {0: 750.0},
+                               'Vopex_network': {0: 218.75},
+                               'Capex_network': {0: 45833.33333333333},
+                               'Incidental_network': {0: 0.0},
+                               'Inv_network': {('location',
+                                                'process_storage_resource_deterministic_demand_stored',
+                                                0): 25.0},
+                               'Cost': {None: None},
+                               'Inv_cost': {('location',
+                                             'process_storage_resource_deterministic_demand_stored',
+                                             0): 2.5},
+                               'Inv_cost_location': {('location', 0): 2.5},
+                               'Inv_cost_network': {0: 2.5},
+                               'objective': 47423.33333333333})
+
+
+def test_results_single_location_lp_variability_profit(single_location_scenario_variability, single_location_lp_variability_profit):
+    results = solve(scenario=single_location_scenario_variability,
+                    instance=single_location_lp_variability_profit, solver='gurobi', name='LP')
+
+    assert (results.output == {'termination': 'optimal',
+                               'LB': 15982.8125,
+                               'UB': 15982.8125,
+                               'n_cons': 159,
+                               'n_vars': 138,
+                               'n_binvars': 0,
+                               'n_intvars': 0,
+                               'n_convars': 138,
+                               'n_nonzero': 367,
+                               'P': {('location', 'process_certain_capacity', 0, 0): 0.0,
+                                     ('location', 'process_certain_capacity', 0, 1): 75.0,
+                                     ('location', 'process_certain_capacity', 0, 2): 0.0,
+                                     ('location', 'process_certain_capacity', 0, 3): 62.5,
+                                     ('location', 'process_deterministic_capacity', 0, 0): 25.0,
+                                     ('location', 'process_deterministic_capacity', 0, 1): 12.5,
+                                     ('location', 'process_deterministic_capacity', 0, 2): 25.0,
+                                     ('location', 'process_deterministic_capacity', 0, 3): 6.25,
+                                     ('location', 'process_storage', 0, 0): 25.0,
+                                     ('location', 'process_storage', 0, 1): 0.0,
+                                     ('location', 'process_storage', 0, 2): 25.0,
+                                     ('location', 'process_storage', 0, 3): 0.0,
+                                     ('location', 'process_storage_discharge', 0, 0): 0.0,
+                                     ('location', 'process_storage_discharge', 0, 1): 25.0,
+                                     ('location', 'process_storage_discharge', 0, 2): 0.0,
+                                     ('location', 'process_storage_discharge', 0, 3): 25.0},
+                               'B': {('location', 'resource_certain_availability', 0, 0): 50.0,
+                                     ('location', 'resource_certain_availability', 0, 1): 25.0,
+                                     ('location', 'resource_certain_availability', 0, 2): 50.0,
+                                     ('location', 'resource_certain_availability', 0, 3): 12.5,
+                                     ('location', 'resource_deterministic_availability', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_availability', 0, 1): 187.5,
+                                     ('location', 'resource_deterministic_availability', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_availability', 0, 3): 156.25,
+                                     ('location', 'resource_deterministic_price', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_price', 0, 1): 187.5,
+                                     ('location', 'resource_deterministic_price', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_price', 0, 3): 117.1875},
+                               'C': {('location', 'resource_certain_availability', 0, 0): 25.0,
+                                     ('location', 'resource_certain_availability', 0, 1): 12.5,
+                                     ('location', 'resource_certain_availability', 0, 2): 25.0,
+                                     ('location', 'resource_certain_availability', 0, 3): 6.25,
+                                     ('location', 'resource_deterministic_availability', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_availability', 0, 1): 37.5,
+                                     ('location', 'resource_deterministic_availability', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_availability', 0, 3): 31.25,
+                                     ('location', 'resource_deterministic_price', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_price', 0, 1): 18.75,
+                                     ('location', 'resource_deterministic_price', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_price', 0, 3): 15.625},
+                               'S': {('location', 'resource_deterministic_demand', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_demand', 0, 1): 0.0,
+                                     ('location', 'resource_deterministic_demand', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_demand', 0, 3): 0.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 1): 75.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 3): 62.5},
+                               'R': {('location', 'resource_deterministic_demand', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_demand', 0, 1): 0.0,
+                                     ('location', 'resource_deterministic_demand', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_demand', 0, 3): 0.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 0): 0.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 1): 37500.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 2): 0.0,
+                                     ('location', 'resource_deterministic_revenue', 0, 3): 15625.0},
+                               'Inv': {('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        0): 25.0,
+                                       ('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        1): 0.0,
+                                       ('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        2): 25.0,
+                                       ('location',
+                                        'process_storage_resource_deterministic_demand_stored',
+                                        0,
+                                        3): 0.0},
+                               'P_m': {('location', 'process_storage', 0, 0, 0): 25.0,
+                                       ('location', 'process_storage', 0, 0, 1): 0.0,
+                                       ('location', 'process_storage', 0, 0, 2): 25.0,
+                                       ('location', 'process_storage', 0, 0, 3): 0.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 0): 0.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 1): 75.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 2): 0.0,
+                                       ('location', 'process_certain_capacity', 0, 0, 3): 62.5,
+                                       ('location', 'process_storage_discharge', 0, 0, 0): 0.0,
+                                       ('location', 'process_storage_discharge', 0, 0, 1): 25.0,
+                                       ('location', 'process_storage_discharge', 0, 0, 2): 0.0,
+                                       ('location', 'process_storage_discharge', 0, 0, 3): 25.0,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 0): 25.0,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 1): 12.5,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 2): 25.0,
+                                       ('location', 'process_deterministic_capacity', 0, 0, 3): 6.25},
+                               'P_material_m': {},
+                               'Cap_P': {('location', 'process_certain_capacity', 0): 75.0,
+                                         ('location', 'process_deterministic_capacity', 0): 25.0,
+                                         ('location', 'process_storage', 0): 25.0,
+                                         ('location', 'process_storage_discharge', 0): 50.0},
+                               'Cap_S': {('location',
+                                          'process_storage_resource_deterministic_demand_stored',
+                                          0): 25.0},
+                               'P_location': {('location', 'process_certain_capacity', 0): 137.5,
+                                              ('location', 'process_deterministic_capacity', 0): 68.75,
+                                              ('location', 'process_storage', 0): 50.0,
+                                              ('location', 'process_storage_discharge', 0): 50.0},
+                               'P_location_material_m': {},
+                               'S_location': {('location', 'resource_deterministic_demand', 0): 0.0,
+                                              ('location', 'resource_deterministic_revenue', 0): 137.5},
+                               'R_location': {('location', 'resource_deterministic_demand', 0): 0.0,
+                                              ('location', 'resource_deterministic_revenue', 0): 53125.0},
+                               'C_location': {('location', 'resource_certain_availability', 0): 68.75,
+                                              ('location', 'resource_deterministic_availability', 0): 68.75,
+                                              ('location', 'resource_deterministic_price', 0): 34.375},
+                               'B_location': {('location', 'resource_certain_availability', 0): 137.5,
+                                              ('location', 'resource_deterministic_availability', 0): 343.75,
+                                              ('location', 'resource_deterministic_price', 0): 304.6875},
+                               'P_network': {('process_certain_capacity', 0): 137.5,
+                                             ('process_deterministic_capacity', 0): 68.75,
+                                             ('process_storage', 0): 50.0,
+                                             ('process_storage_discharge', 0): 50.0},
+                               'S_network': {('resource_deterministic_demand', 0): 0.0,
+                                             ('resource_deterministic_revenue', 0): 137.5},
+                               'R_network': {('resource_deterministic_demand', 0): 0.0,
+                                             ('resource_deterministic_revenue', 0): 53125.0},
+                               'C_network': {('resource_certain_availability', 0): 68.75,
+                                             ('resource_deterministic_availability', 0): 68.75,
+                                             ('resource_deterministic_price', 0): 34.375},
+                               'B_network': {('resource_certain_availability', 0): 137.5,
+                                             ('resource_deterministic_availability', 0): 343.75,
+                                             ('resource_deterministic_price', 0): 304.6875},
+                               'Fopex_process': {('location', 'process_certain_capacity', 0): 750.0,
+                                                 ('location', 'process_deterministic_capacity', 0): 250.0,
+                                                 ('location', 'process_storage', 0): 125.0,
+                                                 ('location', 'process_storage_discharge', 0): 0.0},
+                               'Vopex_process': {('location', 'process_certain_capacity', 0): 137.5,
+                                                 ('location', 'process_deterministic_capacity', 0): 68.75,
+                                                 ('location', 'process_storage', 0): 25.0,
+                                                 ('location', 'process_storage_discharge', 0): 0.0},
+                               'Capex_process': {('location', 'process_certain_capacity', 0): 7500.0,
+                                                 ('location', 'process_deterministic_capacity', 0): 25000.0,
+                                                 ('location', 'process_storage', 0): 2500.0,
+                                                 ('location', 'process_storage_discharge', 0): 0.0},
+                               'Incidental_process': {('location', 'process_certain_capacity', 0): 0.0,
+                                                      ('location', 'process_deterministic_capacity', 0): 0.0,
+                                                      ('location', 'process_storage', 0): 0.0,
+                                                      ('location', 'process_storage_discharge', 0): 0.0},
+                               'Fopex_location': {('location', 0): 1125.0},
+                               'Vopex_location': {('location', 0): 231.25},
+                               'Capex_location': {('location', 0): 35000.0},
+                               'Incidental_location': {('location', 0): 0.0},
+                               'Fopex_network': {0: 1125.0},
+                               'Vopex_network': {0: 231.25},
+                               'Capex_network': {0: 35000.0},
+                               'Incidental_network': {0: 0.0},
+                               'Inv_network': {('location',
+                                                'process_storage_resource_deterministic_demand_stored',
+                                                0): 50.0},
+                               'Cost': {None: 37142.1875},
+                               'Inv_cost': {('location',
+                                             'process_storage_resource_deterministic_demand_stored',
+                                             0): 5.0},
+                               'Inv_cost_location': {('location', 0): 5.0},
+                               'Inv_cost_network': {0: 5.0},
+                               'objective': 15982.8125})
diff --git a/tests/problem_tests/milp_test.py b/tests/problem_tests/milp_test.py
new file mode 100644
index 00000000..34e0c7da
--- /dev/null
+++ b/tests/problem_tests/milp_test.py
@@ -0,0 +1,686 @@
+from tests.test_fixtures import single_location_milp_variability_cost, multi_location_milp_variability_cost
+from src.energiapy.model.solve import solve
+from src.energiapy.model.formulate import formulate
+import copy
+
+# Function to round all numerical values to 3 decimal places
+
+
+def round_values(d):
+    if isinstance(d, dict):
+        for key, value in d.items():
+            if isinstance(value, (float, int)):
+                # Round the numerical value to 3 decimal places
+                d[key] = round(value, 3)
+            elif isinstance(value, dict):
+                round_values(value)
+    elif isinstance(d, list):
+        for i, item in enumerate(d):
+            if isinstance(item, (float, int)):
+                # Round the numerical value to 3 decimal places
+                d[i] = round(item, 3)
+            elif isinstance(item, (dict, list)):
+                round_values(item)
+
+
+def test_results_multi_location_milp_variability_cost(multi_location_milp_variability_cost):
+    results = multi_location_milp_variability_cost.solve(solver='gurobi')
+    results_rounded = copy.deepcopy(results.results['scenario'].output)
+    round_values(results_rounded)
+
+    assert ({'termination': 'optimal',
+             'LB': 108530.375,
+             'UB': 108530.375,
+             'n_cons': 438,
+             'n_vars': 436,
+             'n_binvars': 17,
+             'n_intvars': 17,
+             'n_convars': 402,
+             'n_nonzero': 777,
+             'P': {('location1', 'process_certain_capacity', 0, 0): 0.0,
+                   ('location1', 'process_certain_capacity', 0, 1): 0.0,
+                   ('location1', 'process_certain_capacity', 0, 2): 0.0,
+                   ('location1', 'process_certain_capacity', 0, 3): 0.0,
+                   ('location1', 'process_certain_capacity2', 0, 0): 0.0,
+                   ('location1', 'process_certain_capacity2', 0, 1): 0.0,
+                   ('location1', 'process_certain_capacity2', 0, 2): 0.0,
+                   ('location1', 'process_certain_capacity2', 0, 3): 0.0,
+                   ('location1', 'process_deterministic_capacity', 0, 0): 15.0,
+                   ('location1', 'process_deterministic_capacity', 0, 1): 20.0,
+                   ('location1', 'process_deterministic_capacity', 0, 2): 10.0,
+                   ('location1', 'process_deterministic_capacity', 0, 3): 25.0,
+                   ('location2', 'process_certain_capacity', 0, 0): 30.0,
+                   ('location2', 'process_certain_capacity', 0, 1): 40.0,
+                   ('location2', 'process_certain_capacity', 0, 2): 20.0,
+                   ('location2', 'process_certain_capacity', 0, 3): 50.0,
+                   ('location2', 'process_certain_capacity2', 0, 0): 0.0,
+                   ('location2', 'process_certain_capacity2', 0, 1): 0.0,
+                   ('location2', 'process_certain_capacity2', 0, 2): 0.0,
+                   ('location2', 'process_certain_capacity2', 0, 3): 0.0,
+                   ('location2', 'process_deterministic_capacity', 0, 0): 0.0,
+                   ('location2', 'process_deterministic_capacity', 0, 1): 0.0,
+                   ('location2', 'process_deterministic_capacity', 0, 2): 0.0,
+                   ('location2', 'process_deterministic_capacity', 0, 3): 0.0,
+                   ('location3', 'process_certain_capacity', 0, 0): 0.0,
+                   ('location3', 'process_certain_capacity', 0, 1): 0.0,
+                   ('location3', 'process_certain_capacity', 0, 2): 0.0,
+                   ('location3', 'process_certain_capacity', 0, 3): 0.0,
+                   ('location3', 'process_certain_capacity2', 0, 0): 30.0,
+                   ('location3', 'process_certain_capacity2', 0, 1): 40.0,
+                   ('location3', 'process_certain_capacity2', 0, 2): 20.0,
+                   ('location3', 'process_certain_capacity2', 0, 3): 50.0,
+                   ('location3', 'process_deterministic_capacity', 0, 0): 0.0,
+                   ('location3', 'process_deterministic_capacity', 0, 1): 0.0,
+                   ('location3', 'process_deterministic_capacity', 0, 2): 0.0,
+                   ('location3', 'process_deterministic_capacity', 0, 3): 0.0},
+             'B': {('location1', 'resource_certain_availability', 0, 0): 0.0,
+                   ('location1', 'resource_certain_availability', 0, 1): 0.0,
+                   ('location1', 'resource_certain_availability', 0, 2): 0.0,
+                   ('location1', 'resource_certain_availability', 0, 3): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 0): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 1): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 2): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 3): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 0): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 1): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 2): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 3): 0.0,
+                   ('location2', 'resource_deterministic_price', 0, 0): 50.625,
+                   ('location2', 'resource_deterministic_price', 0, 1): 72.0,
+                   ('location2', 'resource_deterministic_price', 0, 2): 11.25,
+                   ('location2', 'resource_deterministic_price', 0, 3): 112.5,
+                   ('location3', 'resource_certain_availability', 0, 0): 0.0,
+                   ('location3', 'resource_certain_availability', 0, 1): 0.0,
+                   ('location3', 'resource_certain_availability', 0, 2): 0.0,
+                   ('location3', 'resource_certain_availability', 0, 3): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 0): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 1): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 2): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 3): 0.0},
+             'C': {('location1', 'resource_certain_availability', 0, 0): 18.75,
+                   ('location1', 'resource_certain_availability', 0, 1): 25.0,
+                   ('location1', 'resource_certain_availability', 0, 2): 12.5,
+                   ('location1', 'resource_certain_availability', 0, 3): 31.25,
+                   ('location1', 'resource_deterministic_price', 0, 0): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 1): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 2): 0.0,
+                   ('location1', 'resource_deterministic_price', 0, 3): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 0): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 1): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 2): 0.0,
+                   ('location2', 'resource_certain_availability', 0, 3): 0.0,
+                   ('location2', 'resource_deterministic_price', 0, 0): 22.5,
+                   ('location2', 'resource_deterministic_price', 0, 1): 30.0,
+                   ('location2', 'resource_deterministic_price', 0, 2): 15.0,
+                   ('location2', 'resource_deterministic_price', 0, 3): 37.5,
+                   ('location3', 'resource_certain_availability', 0, 0): 0.0,
+                   ('location3', 'resource_certain_availability', 0, 1): 0.0,
+                   ('location3', 'resource_certain_availability', 0, 2): 0.0,
+                   ('location3', 'resource_certain_availability', 0, 3): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 0): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 1): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 2): 0.0,
+                   ('location3', 'resource_deterministic_price', 0, 3): 0.0},
+             'S': {('location1', 'resource_deterministic_demand', 0, 0): -0.0,
+                   ('location1', 'resource_deterministic_demand', 0, 1): -0.0,
+                   ('location1', 'resource_deterministic_demand', 0, 2): -0.0,
+                   ('location1', 'resource_deterministic_demand', 0, 3): -0.0,
+                   ('location2', 'resource_deterministic_demand', 0, 0): -0.0,
+                   ('location2', 'resource_deterministic_demand', 0, 1): -0.0,
+                   ('location2', 'resource_deterministic_demand', 0, 2): -0.0,
+                   ('location2', 'resource_deterministic_demand', 0, 3): -0.0,
+                   ('location3', 'resource_deterministic_demand', 0, 0): 30.0,
+                   ('location3', 'resource_deterministic_demand', 0, 1): 40.0,
+                   ('location3', 'resource_deterministic_demand', 0, 2): 20.0,
+                   ('location3', 'resource_deterministic_demand', 0, 3): 50.0},
+             'R': {('location1', 'resource_deterministic_demand', 0, 0): None,
+                   ('location1', 'resource_deterministic_demand', 0, 1): None,
+                   ('location1', 'resource_deterministic_demand', 0, 2): None,
+                   ('location1', 'resource_deterministic_demand', 0, 3): None,
+                   ('location2', 'resource_deterministic_demand', 0, 0): None,
+                   ('location2', 'resource_deterministic_demand', 0, 1): None,
+                   ('location2', 'resource_deterministic_demand', 0, 2): None,
+                   ('location2', 'resource_deterministic_demand', 0, 3): None,
+                   ('location3', 'resource_deterministic_demand', 0, 0): None,
+                   ('location3', 'resource_deterministic_demand', 0, 1): None,
+                   ('location3', 'resource_deterministic_demand', 0, 2): None,
+                   ('location3', 'resource_deterministic_demand', 0, 3): None},
+             'Inv': {},
+             'P_m': {('location1', 'process_certain_capacity2', 0, 0, 0): -0.0,
+                     ('location1', 'process_certain_capacity2', 0, 0, 1): -0.0,
+                     ('location1', 'process_certain_capacity2', 0, 0, 2): -0.0,
+                     ('location1', 'process_certain_capacity2', 0, 0, 3): -0.0,
+                     ('location1', 'process_deterministic_capacity', 0, 0, 0): 15.0,
+                     ('location1', 'process_deterministic_capacity', 0, 0, 1): 20.0,
+                     ('location1', 'process_deterministic_capacity', 0, 0, 2): 10.0,
+                     ('location1', 'process_deterministic_capacity', 0, 0, 3): 25.0,
+                     ('location1', 'process_certain_capacity', 0, 0, 0): -0.0,
+                     ('location1', 'process_certain_capacity', 0, 0, 1): -0.0,
+                     ('location1', 'process_certain_capacity', 0, 0, 2): -0.0,
+                     ('location1', 'process_certain_capacity', 0, 0, 3): -0.0,
+                     ('location2', 'process_certain_capacity2', 0, 0, 0): -0.0,
+                     ('location2', 'process_certain_capacity2', 0, 0, 1): -0.0,
+                     ('location2', 'process_certain_capacity2', 0, 0, 2): -0.0,
+                     ('location2', 'process_certain_capacity2', 0, 0, 3): -0.0,
+                     ('location2', 'process_deterministic_capacity', 0, 0, 0): -0.0,
+                     ('location2', 'process_deterministic_capacity', 0, 0, 1): -0.0,
+                     ('location2', 'process_deterministic_capacity', 0, 0, 2): -0.0,
+                     ('location2', 'process_deterministic_capacity', 0, 0, 3): -0.0,
+                     ('location2', 'process_certain_capacity', 0, 0, 0): 30.0,
+                     ('location2', 'process_certain_capacity', 0, 0, 1): 40.0,
+                     ('location2', 'process_certain_capacity', 0, 0, 2): 20.0,
+                     ('location2', 'process_certain_capacity', 0, 0, 3): 50.0,
+                     ('location3', 'process_certain_capacity2', 0, 0, 0): 30.0,
+                     ('location3', 'process_certain_capacity2', 0, 0, 1): 40.0,
+                     ('location3', 'process_certain_capacity2', 0, 0, 2): 20.0,
+                     ('location3', 'process_certain_capacity2', 0, 0, 3): 50.0,
+                     ('location3', 'process_deterministic_capacity', 0, 0, 0): -0.0,
+                     ('location3', 'process_deterministic_capacity', 0, 0, 1): -0.0,
+                     ('location3', 'process_deterministic_capacity', 0, 0, 2): -0.0,
+                     ('location3', 'process_deterministic_capacity', 0, 0, 3): -0.0,
+                     ('location3', 'process_certain_capacity', 0, 0, 0): -0.0,
+                     ('location3', 'process_certain_capacity', 0, 0, 1): -0.0,
+                     ('location3', 'process_certain_capacity', 0, 0, 2): -0.0,
+                     ('location3', 'process_certain_capacity', 0, 0, 3): -0.0},
+             'P_material_m': {},
+             'Cap_P': {('location1', 'process_certain_capacity', 0): 0.0,
+                       ('location1', 'process_certain_capacity2', 0): 0.0,
+                       ('location1', 'process_deterministic_capacity', 0): 0.0,
+                       ('location2', 'process_certain_capacity', 0): 50.0,
+                       ('location2', 'process_certain_capacity2', 0): 0.0,
+                       ('location2', 'process_deterministic_capacity', 0): 0.0,
+                       ('location3', 'process_certain_capacity', 0): 0.0,
+                       ('location3', 'process_certain_capacity2', 0): 50.0,
+                       ('location3', 'process_deterministic_capacity', 0): 0.0},
+             'Cap_S': {},
+             'P_location': {('location1', 'process_certain_capacity', 0): 0.0,
+                            ('location1', 'process_certain_capacity2', 0): 0.0,
+                            ('location1', 'process_deterministic_capacity', 0): 70.0,
+                            ('location2', 'process_certain_capacity', 0): 140.0,
+                            ('location2', 'process_certain_capacity2', 0): 0.0,
+                            ('location2', 'process_deterministic_capacity', 0): 0.0,
+                            ('location3', 'process_certain_capacity', 0): 0.0,
+                            ('location3', 'process_certain_capacity2', 0): 140.0,
+                            ('location3', 'process_deterministic_capacity', 0): 0.0},
+             'P_location_material_m': {},
+             'S_location': {('location1', 'resource_deterministic_demand', 0): 0.0,
+                            ('location2', 'resource_deterministic_demand', 0): 0.0,
+                            ('location3', 'resource_deterministic_demand', 0): 140.0},
+             'R_location': {('location1', 'resource_deterministic_demand', 0): None,
+                            ('location2', 'resource_deterministic_demand', 0): None,
+                            ('location3', 'resource_deterministic_demand', 0): None},
+             'C_location': {('location1', 'resource_certain_availability', 0): 87.5,
+                            ('location1', 'resource_deterministic_price', 0): 0.0,
+                            ('location2', 'resource_certain_availability', 0): 0.0,
+                            ('location2', 'resource_deterministic_price', 0): 105.0,
+                            ('location3', 'resource_certain_availability', 0): 0.0,
+                            ('location3', 'resource_deterministic_price', 0): 0.0},
+             'B_location': {('location1', 'resource_certain_availability', 0): 0.0,
+                            ('location1', 'resource_deterministic_price', 0): 0.0,
+                            ('location2', 'resource_certain_availability', 0): 0.0,
+                            ('location2', 'resource_deterministic_price', 0): 246.375,
+                            ('location3', 'resource_certain_availability', 0): 0.0,
+                            ('location3', 'resource_deterministic_price', 0): 0.0},
+             'P_network': {('process_certain_capacity', 0): 140.0,
+                           ('process_certain_capacity2', 0): 140.0,
+                           ('process_deterministic_capacity', 0): 70.0},
+             'S_network': {('resource_deterministic_demand', 0): 140.0},
+             'R_network': {('resource_deterministic_demand', 0): None},
+             'C_network': {('resource_certain_availability', 0): 87.5,
+                           ('resource_deterministic_price', 0): 105.0},
+             'B_network': {('resource_certain_availability', 0): 0.0,
+                           ('resource_deterministic_price', 0): 246.375},
+             'Trans_cost_network': {('transport', 0): None, ('transport2', 0): None},
+             'Fopex_process': {('location1', 'process_certain_capacity', 0): 0.0,
+                               ('location1', 'process_certain_capacity2', 0): 0.0,
+                               ('location1', 'process_deterministic_capacity', 0): 0.0,
+                               ('location2', 'process_certain_capacity', 0): 1250.0,
+                               ('location2', 'process_certain_capacity2', 0): 0.0,
+                               ('location2', 'process_deterministic_capacity', 0): 0.0,
+                               ('location3', 'process_certain_capacity', 0): 0.0,
+                               ('location3', 'process_certain_capacity2', 0): 50.0,
+                               ('location3', 'process_deterministic_capacity', 0): 0.0},
+             'Vopex_process': {('location1', 'process_certain_capacity', 0): 0.0,
+                               ('location1', 'process_certain_capacity2', 0): 0.0,
+                               ('location1', 'process_deterministic_capacity', 0): 70.0,
+                               ('location2', 'process_certain_capacity', 0): 700.0,
+                               ('location2', 'process_certain_capacity2', 0): 0.0,
+                               ('location2', 'process_deterministic_capacity', 0): 0.0,
+                               ('location3', 'process_certain_capacity', 0): 0.0,
+                               ('location3', 'process_certain_capacity2', 0): 14.0,
+                               ('location3', 'process_deterministic_capacity', 0): 0.0},
+             'Capex_process': {('location1', 'process_certain_capacity', 0): 0.0,
+                               ('location1', 'process_certain_capacity2', 0): 0.0,
+                               ('location1', 'process_deterministic_capacity', 0): 0.0,
+                               ('location2', 'process_certain_capacity', 0): 10000.0,
+                               ('location2', 'process_certain_capacity2', 0): 0.0,
+                               ('location2', 'process_deterministic_capacity', 0): 0.0,
+                               ('location3', 'process_certain_capacity', 0): 0.0,
+                               ('location3', 'process_certain_capacity2', 0): 500.0,
+                               ('location3', 'process_deterministic_capacity', 0): 0.0},
+             'Incidental_process': {('location1', 'process_certain_capacity', 0): 0.0,
+                                    ('location1', 'process_certain_capacity2', 0): 0.0,
+                                    ('location1', 'process_deterministic_capacity', 0): 0.0,
+                                    ('location2', 'process_certain_capacity', 0): 0.0,
+                                    ('location2', 'process_certain_capacity2', 0): 0.0,
+                                    ('location2', 'process_deterministic_capacity', 0): 0.0,
+                                    ('location3', 'process_certain_capacity', 0): 0.0,
+                                    ('location3', 'process_certain_capacity2', 0): 0.0,
+                                    ('location3', 'process_deterministic_capacity', 0): 0.0},
+             'Fopex_location': {('location1', 0): 0.0,
+                                ('location2', 0): 1250.0,
+                                ('location3', 0): 50.0},
+             'Vopex_location': {('location1', 0): 70.0,
+                                ('location2', 0): 700.0,
+                                ('location3', 0): 14.0},
+             'Capex_location': {('location1', 0): 0.0,
+                                ('location2', 0): 10000.0,
+                                ('location3', 0): 500.0},
+             'Incidental_location': {('location1', 0): 0.0,
+                                     ('location2', 0): 0.0,
+                                     ('location3', 0): 0.0},
+             'Fopex_network': {0: 1300.0},
+             'Vopex_network': {0: 784.0},
+             'Capex_network': {0: 10500.0},
+             'Incidental_network': {0: 0.0},
+             'Inv_network': {},
+             'Cost': {None: None},
+             'Inv_cost': {},
+             'Inv_cost_location': {('location1', 0): 0.0,
+                                   ('location2', 0): 0.0,
+                                   ('location3', 0): 0.0},
+             'Inv_cost_network': {0: 0.0},
+             'X_F': {('location1', 'location2', 'transport', 0): 1.0,
+                     ('location1', 'location2', 'transport2', 0): None,
+                     ('location1', 'location3', 'transport', 0): None,
+                     ('location1', 'location3', 'transport2', 0): None,
+                     ('location2', 'location2', 'transport', 0): None,
+                     ('location2', 'location2', 'transport2', 0): None,
+                     ('location2', 'location3', 'transport', 0): None,
+                     ('location2', 'location3', 'transport2', 0): 1.0},
+             'Cap_F': {('location1', 'location2', 'transport', 0): 25.0,
+                       ('location1', 'location2', 'transport2', 0): 0.0,
+                       ('location1', 'location3', 'transport', 0): 0.0,
+                       ('location1', 'location3', 'transport2', 0): 0.0,
+                       ('location2', 'location2', 'transport', 0): 0.0,
+                       ('location2', 'location2', 'transport2', 0): 0.0,
+                       ('location2', 'location3', 'transport', 0): 0.0,
+                       ('location2', 'location3', 'transport2', 0): 50.0},
+             'Exp_R': {('location1', 'location2', 'resource_implicit', 0, 0): 15.0,
+                       ('location1', 'location2', 'resource_implicit', 0, 1): 20.0,
+                       ('location1', 'location2', 'resource_implicit', 0, 2): 10.0,
+                       ('location1', 'location2', 'resource_implicit', 0, 3): 25.0,
+                       ('location1', 'location2', 'resource_implicit2', 0, 0): 0.0,
+                       ('location1', 'location2', 'resource_implicit2', 0, 1): 0.0,
+                       ('location1', 'location2', 'resource_implicit2', 0, 2): 0.0,
+                       ('location1', 'location2', 'resource_implicit2', 0, 3): 0.0,
+                       ('location1', 'location3', 'resource_implicit', 0, 0): 0.0,
+                       ('location1', 'location3', 'resource_implicit', 0, 1): 0.0,
+                       ('location1', 'location3', 'resource_implicit', 0, 2): 0.0,
+                       ('location1', 'location3', 'resource_implicit', 0, 3): 0.0,
+                       ('location1', 'location3', 'resource_implicit2', 0, 0): 0.0,
+                       ('location1', 'location3', 'resource_implicit2', 0, 1): 0.0,
+                       ('location1', 'location3', 'resource_implicit2', 0, 2): 0.0,
+                       ('location1', 'location3', 'resource_implicit2', 0, 3): 0.0,
+                       ('location2', 'location2', 'resource_implicit', 0, 0): 0.0,
+                       ('location2', 'location2', 'resource_implicit', 0, 1): 0.0,
+                       ('location2', 'location2', 'resource_implicit', 0, 2): 0.0,
+                       ('location2', 'location2', 'resource_implicit', 0, 3): 0.0,
+                       ('location2', 'location2', 'resource_implicit2', 0, 0): 0.0,
+                       ('location2', 'location2', 'resource_implicit2', 0, 1): 0.0,
+                       ('location2', 'location2', 'resource_implicit2', 0, 2): 0.0,
+                       ('location2', 'location2', 'resource_implicit2', 0, 3): 0.0,
+                       ('location2', 'location3', 'resource_implicit', 0, 0): 0.0,
+                       ('location2', 'location3', 'resource_implicit', 0, 1): 0.0,
+                       ('location2', 'location3', 'resource_implicit', 0, 2): 0.0,
+                       ('location2', 'location3', 'resource_implicit', 0, 3): 0.0,
+                       ('location2', 'location3', 'resource_implicit2', 0, 0): 30.0,
+                       ('location2', 'location3', 'resource_implicit2', 0, 1): 40.0,
+                       ('location2', 'location3', 'resource_implicit2', 0, 2): 20.0,
+                       ('location2', 'location3', 'resource_implicit2', 0, 3): 50.0},
+             'Exp_F': {('location1', 'location2', 'transport', 0, 0): 15.0,
+                       ('location1', 'location2', 'transport', 0, 1): 20.0,
+                       ('location1', 'location2', 'transport', 0, 2): 10.0,
+                       ('location1', 'location2', 'transport', 0, 3): 25.0,
+                       ('location1', 'location2', 'transport2', 0, 0): 0.0,
+                       ('location1', 'location2', 'transport2', 0, 1): 0.0,
+                       ('location1', 'location2', 'transport2', 0, 2): 0.0,
+                       ('location1', 'location2', 'transport2', 0, 3): 0.0,
+                       ('location1', 'location3', 'transport', 0, 0): 0.0,
+                       ('location1', 'location3', 'transport', 0, 1): 0.0,
+                       ('location1', 'location3', 'transport', 0, 2): 0.0,
+                       ('location1', 'location3', 'transport', 0, 3): 0.0,
+                       ('location1', 'location3', 'transport2', 0, 0): 0.0,
+                       ('location1', 'location3', 'transport2', 0, 1): 0.0,
+                       ('location1', 'location3', 'transport2', 0, 2): 0.0,
+                       ('location1', 'location3', 'transport2', 0, 3): 0.0,
+                       ('location2', 'location2', 'transport', 0, 0): 0.0,
+                       ('location2', 'location2', 'transport', 0, 1): 0.0,
+                       ('location2', 'location2', 'transport', 0, 2): 0.0,
+                       ('location2', 'location2', 'transport', 0, 3): 0.0,
+                       ('location2', 'location2', 'transport2', 0, 0): 0.0,
+                       ('location2', 'location2', 'transport2', 0, 1): 0.0,
+                       ('location2', 'location2', 'transport2', 0, 2): 0.0,
+                       ('location2', 'location2', 'transport2', 0, 3): 0.0,
+                       ('location2', 'location3', 'transport', 0, 0): 0.0,
+                       ('location2', 'location3', 'transport', 0, 1): 0.0,
+                       ('location2', 'location3', 'transport', 0, 2): 0.0,
+                       ('location2', 'location3', 'transport', 0, 3): 0.0,
+                       ('location2', 'location3', 'transport2', 0, 0): 30.0,
+                       ('location2', 'location3', 'transport2', 0, 1): 40.0,
+                       ('location2', 'location3', 'transport2', 0, 2): 20.0,
+                       ('location2', 'location3', 'transport2', 0, 3): 50.0},
+             'Exp_F_network': {('location1', 'location2', 'transport', 0): 70.0,
+                               ('location1', 'location2', 'transport2', 0): 0.0,
+                               ('location1', 'location3', 'transport', 0): 0.0,
+                               ('location1', 'location3', 'transport2', 0): 0.0,
+                               ('location2', 'location2', 'transport', 0): 0.0,
+                               ('location2', 'location2', 'transport2', 0): 0.0,
+                               ('location2', 'location3', 'transport', 0): 0.0,
+                               ('location2', 'location3', 'transport2', 0): 140.0},
+             'Exp': {('location1',
+                      'location2',
+                      'transport',
+                      'resource_implicit',
+                      0,
+                      0): 15.0,
+                     ('location1', 'location2', 'transport', 'resource_implicit', 0, 1): 20.0,
+                     ('location1', 'location2', 'transport', 'resource_implicit', 0, 2): 10.0,
+                     ('location1', 'location2', 'transport', 'resource_implicit', 0, 3): 25.0,
+                     ('location1', 'location2', 'transport', 'resource_implicit2', 0, 0): None,
+                     ('location1', 'location2', 'transport', 'resource_implicit2', 0, 1): None,
+                     ('location1', 'location2', 'transport', 'resource_implicit2', 0, 2): None,
+                     ('location1', 'location2', 'transport', 'resource_implicit2', 0, 3): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit', 0, 0): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit', 0, 1): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit', 0, 2): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit', 0, 3): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit2', 0, 0): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit2', 0, 1): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit2', 0, 2): None,
+                     ('location1', 'location2', 'transport2', 'resource_implicit2', 0, 3): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit', 0, 0): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit', 0, 1): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit', 0, 2): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit', 0, 3): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit2', 0, 0): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit2', 0, 1): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit2', 0, 2): None,
+                     ('location1', 'location3', 'transport', 'resource_implicit2', 0, 3): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit', 0, 0): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit', 0, 1): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit', 0, 2): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit', 0, 3): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit2', 0, 0): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit2', 0, 1): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit2', 0, 2): None,
+                     ('location1', 'location3', 'transport2', 'resource_implicit2', 0, 3): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit', 0, 0): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit', 0, 1): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit', 0, 2): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit', 0, 3): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit2', 0, 0): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit2', 0, 1): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit2', 0, 2): None,
+                     ('location2', 'location2', 'transport', 'resource_implicit2', 0, 3): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit', 0, 0): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit', 0, 1): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit', 0, 2): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit', 0, 3): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit2', 0, 0): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit2', 0, 1): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit2', 0, 2): None,
+                     ('location2', 'location2', 'transport2', 'resource_implicit2', 0, 3): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit', 0, 0): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit', 0, 1): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit', 0, 2): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit', 0, 3): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit2', 0, 0): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit2', 0, 1): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit2', 0, 2): None,
+                     ('location2', 'location3', 'transport', 'resource_implicit2', 0, 3): None,
+                     ('location2', 'location3', 'transport2', 'resource_implicit', 0, 0): None,
+                     ('location2', 'location3', 'transport2', 'resource_implicit', 0, 1): None,
+                     ('location2', 'location3', 'transport2', 'resource_implicit', 0, 2): None,
+                     ('location2', 'location3', 'transport2', 'resource_implicit', 0, 3): None,
+                     ('location2', 'location3', 'transport2', 'resource_implicit2', 0, 0): 30.0,
+                     ('location2', 'location3', 'transport2', 'resource_implicit2', 0, 1): 40.0,
+                     ('location2', 'location3', 'transport2', 'resource_implicit2', 0, 2): 20.0,
+                     ('location2', 'location3', 'transport2', 'resource_implicit2', 0, 3): 50.0},
+             'Capex_transport': {('location1', 'location2', 'transport', 0): 10000.0,
+                                 ('location1', 'location2', 'transport2', 0): 0.0,
+                                 ('location1', 'location3', 'transport', 0): 0.0,
+                                 ('location1', 'location3', 'transport2', 0): 0.0,
+                                 ('location2', 'location2', 'transport', 0): 0.0,
+                                 ('location2', 'location2', 'transport2', 0): 0.0,
+                                 ('location2', 'location3', 'transport', 0): 0.0,
+                                 ('location2', 'location3', 'transport2', 0): 50000.0},
+             'Vopex_transport': {('location1', 'location2', 'transport', 0): 700.0,
+                                 ('location1', 'location2', 'transport2', 0): 0.0,
+                                 ('location1', 'location3', 'transport', 0): 0.0,
+                                 ('location1', 'location3', 'transport2', 0): 0.0,
+                                 ('location2', 'location2', 'transport', 0): 0.0,
+                                 ('location2', 'location2', 'transport2', 0): 0.0,
+                                 ('location2', 'location3', 'transport', 0): 0.0,
+                                 ('location2', 'location3', 'transport2', 0): 35000.0},
+             'Fopex_transport': {('location1', 'location2', 'transport', 0): 0.0,
+                                 ('location1', 'location2', 'transport2', 0): 0.0,
+                                 ('location1', 'location3', 'transport', 0): 0.0,
+                                 ('location1', 'location3', 'transport2', 0): 0.0,
+                                 ('location2', 'location2', 'transport', 0): 0.0,
+                                 ('location2', 'location2', 'transport2', 0): 0.0,
+                                 ('location2', 'location3', 'transport', 0): 0.0,
+                                 ('location2', 'location3', 'transport2', 0): 0.0},
+             'Capex_transport_network': {0: 60000.0},
+             'Vopex_transport_network': {0: 35700.0},
+             'Fopex_transport_network': {0: 0.0},
+             'X_P': {('location1', 'process_certain_capacity', 0): None,
+                     ('location1', 'process_certain_capacity2', 0): None,
+                     ('location1', 'process_deterministic_capacity', 0): 1.0,
+                     ('location2', 'process_certain_capacity', 0): 1.0,
+                     ('location2', 'process_certain_capacity2', 0): None,
+                     ('location2', 'process_deterministic_capacity', 0): None,
+                     ('location3', 'process_certain_capacity', 0): None,
+                     ('location3', 'process_certain_capacity2', 0): 1.0,
+                     ('location3', 'process_deterministic_capacity', 0): None},
+             'X_S': {},
+             'objective': 108530.375})
+
+
+def test_results_single_location_milp_variability_cost(single_location_milp_variability_cost):
+    results = solve(scenario=single_location_milp_variability_cost[0],
+                    instance=single_location_milp_variability_cost[1], solver='gurobi', name='MILP')
+    results_rounded = copy.deepcopy(results.output)
+    round_values(results_rounded)
+
+    assert (results_rounded == {'termination': 'optimal',
+                                'LB': 47423.333,
+                                'UB': 47423.333,
+                                'n_cons': 176,
+                                'n_vars': 159,
+                                'n_binvars': 6,
+                                'n_intvars': 6,
+                                'n_convars': 147,
+                                'n_nonzero': 399,
+                                'P': {('location', 'process_certain_capacity', 0, 0): 25.0,
+                                      ('location', 'process_certain_capacity', 0, 1): 25.0,
+                                      ('location', 'process_certain_capacity', 0, 2): 25.0,
+                                      ('location', 'process_certain_capacity', 0, 3): 25.0,
+                                      ('location', 'process_deterministic_capacity', 0, 0): 41.667,
+                                      ('location', 'process_deterministic_capacity', 0, 1): 20.833,
+                                      ('location', 'process_deterministic_capacity', 0, 2): 33.333,
+                                      ('location', 'process_deterministic_capacity', 0, 3): 10.417,
+                                      ('location', 'process_deterministic_capacity2', 0, 0): 0.0,
+                                      ('location', 'process_deterministic_capacity2', 0, 1): 0.0,
+                                      ('location', 'process_deterministic_capacity2', 0, 2): 0.0,
+                                      ('location', 'process_deterministic_capacity2', 0, 3): 0.0,
+                                      ('location', 'process_storage', 0, 0): 16.667,
+                                      ('location', 'process_storage', 0, 1): 0.0,
+                                      ('location', 'process_storage', 0, 2): 8.333,
+                                      ('location', 'process_storage', 0, 3): 0.0,
+                                      ('location', 'process_storage_discharge', 0, 0): 0.0,
+                                      ('location', 'process_storage_discharge', 0, 1): 16.667,
+                                      ('location', 'process_storage_discharge', 0, 2): 0.0,
+                                      ('location', 'process_storage_discharge', 0, 3): 8.333},
+                                'B': {('location', 'resource_certain_availability', 0, 0): 83.333,
+                                      ('location', 'resource_certain_availability', 0, 1): 41.667,
+                                      ('location', 'resource_certain_availability', 0, 2): 66.667,
+                                      ('location', 'resource_certain_availability', 0, 3): 20.833,
+                                      ('location', 'resource_deterministic_availability', 0, 0): 62.5,
+                                      ('location', 'resource_deterministic_availability', 0, 1): 62.5,
+                                      ('location', 'resource_deterministic_availability', 0, 2): 62.5,
+                                      ('location', 'resource_deterministic_availability', 0, 3): 62.5,
+                                      ('location', 'resource_deterministic_price', 0, 0): 15.625,
+                                      ('location', 'resource_deterministic_price', 0, 1): 62.5,
+                                      ('location', 'resource_deterministic_price', 0, 2): 31.25,
+                                      ('location', 'resource_deterministic_price', 0, 3): 46.875},
+                                'C': {('location', 'resource_certain_availability', 0, 0): 41.667,
+                                      ('location', 'resource_certain_availability', 0, 1): 20.833,
+                                      ('location', 'resource_certain_availability', 0, 2): 33.333,
+                                      ('location', 'resource_certain_availability', 0, 3): 10.417,
+                                      ('location', 'resource_deterministic_availability', 0, 0): 12.5,
+                                      ('location', 'resource_deterministic_availability', 0, 1): 12.5,
+                                      ('location', 'resource_deterministic_availability', 0, 2): 12.5,
+                                      ('location', 'resource_deterministic_availability', 0, 3): 12.5,
+                                      ('location', 'resource_deterministic_price', 0, 0): 6.25,
+                                      ('location', 'resource_deterministic_price', 0, 1): 6.25,
+                                      ('location', 'resource_deterministic_price', 0, 2): 6.25,
+                                      ('location', 'resource_deterministic_price', 0, 3): 6.25},
+                                'S': {('location', 'resource_deterministic_demand', 0, 0): 12.5,
+                                      ('location', 'resource_deterministic_demand', 0, 1): 25.0,
+                                      ('location', 'resource_deterministic_demand', 0, 2): 12.5,
+                                      ('location', 'resource_deterministic_demand', 0, 3): 6.25,
+                                      ('location', 'resource_deterministic_revenue', 0, 0): 25.0,
+                                      ('location', 'resource_deterministic_revenue', 0, 1): 25.0,
+                                      ('location', 'resource_deterministic_revenue', 0, 2): 25.0,
+                                      ('location', 'resource_deterministic_revenue', 0, 3): 25.0},
+                                'R': {('location', 'resource_deterministic_demand', 0, 0): None,
+                                      ('location', 'resource_deterministic_demand', 0, 1): None,
+                                      ('location', 'resource_deterministic_demand', 0, 2): None,
+                                      ('location', 'resource_deterministic_demand', 0, 3): None,
+                                      ('location', 'resource_deterministic_revenue', 0, 0): None,
+                                      ('location', 'resource_deterministic_revenue', 0, 1): None,
+                                      ('location', 'resource_deterministic_revenue', 0, 2): None,
+                                      ('location', 'resource_deterministic_revenue', 0, 3): None},
+                                'Inv': {('location',
+                                         'process_storage_resource_deterministic_demand_stored',
+                                         0,
+                                         0): 16.667,
+                                        ('location',
+                                         'process_storage_resource_deterministic_demand_stored',
+                                         0,
+                                         1): 0.0,
+                                        ('location',
+                                         'process_storage_resource_deterministic_demand_stored',
+                                         0,
+                                         2): 8.333,
+                                        ('location',
+                                         'process_storage_resource_deterministic_demand_stored',
+                                         0,
+                                         3): 0.0},
+                                'P_m': {('location', 'process_deterministic_capacity2', 0, 0, 0): 0.0,
+                                        ('location', 'process_deterministic_capacity2', 0, 0, 1): 0.0,
+                                        ('location', 'process_deterministic_capacity2', 0, 0, 2): 0.0,
+                                        ('location', 'process_deterministic_capacity2', 0, 0, 3): 0.0,
+                                        ('location', 'process_certain_capacity', 0, 0, 0): 25.0,
+                                        ('location', 'process_certain_capacity', 0, 0, 1): 25.0,
+                                        ('location', 'process_certain_capacity', 0, 0, 2): 25.0,
+                                        ('location', 'process_certain_capacity', 0, 0, 3): 25.0,
+                                        ('location', 'process_deterministic_capacity', 0, 0, 0): 41.667,
+                                        ('location', 'process_deterministic_capacity', 0, 0, 1): 20.833,
+                                        ('location', 'process_deterministic_capacity', 0, 0, 2): 33.333,
+                                        ('location', 'process_deterministic_capacity', 0, 0, 3): 10.417,
+                                        ('location', 'process_storage_discharge', 0, 0, 0): 0.0,
+                                        ('location', 'process_storage_discharge', 0, 0, 1): 16.667,
+                                        ('location', 'process_storage_discharge', 0, 0, 2): 0.0,
+                                        ('location', 'process_storage_discharge', 0, 0, 3): 8.333,
+                                        ('location', 'process_storage', 0, 0, 0): 16.667,
+                                        ('location', 'process_storage', 0, 0, 1): 0.0,
+                                        ('location', 'process_storage', 0, 0, 2): 8.333,
+                                        ('location', 'process_storage', 0, 0, 3): 0.0},
+                                'P_material_m': {},
+                                'Cap_P': {('location', 'process_certain_capacity', 0): 25.0,
+                                          ('location', 'process_deterministic_capacity', 0): 41.667,
+                                          ('location', 'process_deterministic_capacity2', 0): 0.0,
+                                          ('location', 'process_storage', 0): 16.667,
+                                          ('location', 'process_storage_discharge', 0): 50.0},
+                                'Cap_S': {('location',
+                                           'process_storage_resource_deterministic_demand_stored',
+                                           0): 25.0},
+                                'P_location': {('location', 'process_certain_capacity', 0): 100.0,
+                                               ('location', 'process_deterministic_capacity', 0): 106.25,
+                                               ('location', 'process_deterministic_capacity2', 0): 0.0,
+                                               ('location', 'process_storage', 0): 25.0,
+                                               ('location', 'process_storage_discharge', 0): 25.0},
+                                'P_location_material_m': {},
+                                'S_location': {('location', 'resource_deterministic_demand', 0): 56.25,
+                                               ('location', 'resource_deterministic_revenue', 0): 100.0},
+                                'R_location': {('location', 'resource_deterministic_demand', 0): None,
+                                               ('location', 'resource_deterministic_revenue', 0): None},
+                                'C_location': {('location', 'resource_certain_availability', 0): 106.25,
+                                               ('location', 'resource_deterministic_availability', 0): 50.0,
+                                               ('location', 'resource_deterministic_price', 0): 25.0},
+                                'B_location': {('location', 'resource_certain_availability', 0): 212.5,
+                                               ('location', 'resource_deterministic_availability', 0): 250.0,
+                                               ('location', 'resource_deterministic_price', 0): 156.25},
+                                'P_network': {('process_certain_capacity', 0): 100.0,
+                                              ('process_deterministic_capacity', 0): 106.25,
+                                              ('process_deterministic_capacity2', 0): 0.0,
+                                              ('process_storage', 0): 25.0,
+                                              ('process_storage_discharge', 0): 25.0},
+                                'S_network': {('resource_deterministic_demand', 0): 56.25,
+                                              ('resource_deterministic_revenue', 0): 100.0},
+                                'R_network': {('resource_deterministic_demand', 0): None,
+                                              ('resource_deterministic_revenue', 0): None},
+                                'C_network': {('resource_certain_availability', 0): 106.25,
+                                              ('resource_deterministic_availability', 0): 50.0,
+                                              ('resource_deterministic_price', 0): 25.0},
+                                'B_network': {('resource_certain_availability', 0): 212.5,
+                                              ('resource_deterministic_availability', 0): 250.0,
+                                              ('resource_deterministic_price', 0): 156.25},
+                                'Fopex_process': {('location', 'process_certain_capacity', 0): 250.0,
+                                                  ('location', 'process_deterministic_capacity', 0): 416.667,
+                                                  ('location', 'process_deterministic_capacity2', 0): 0.0,
+                                                  ('location', 'process_storage', 0): 83.333,
+                                                  ('location', 'process_storage_discharge', 0): 0.0},
+                                'Vopex_process': {('location', 'process_certain_capacity', 0): 100.0,
+                                                  ('location', 'process_deterministic_capacity', 0): 106.25,
+                                                  ('location', 'process_deterministic_capacity2', 0): 0.0,
+                                                  ('location', 'process_storage', 0): 12.5,
+                                                  ('location', 'process_storage_discharge', 0): 0.0},
+                                'Capex_process': {('location', 'process_certain_capacity', 0): 2500.0,
+                                                  ('location', 'process_deterministic_capacity', 0): 41666.667,
+                                                  ('location', 'process_deterministic_capacity2', 0): 0.0,
+                                                  ('location', 'process_storage', 0): 1666.667,
+                                                  ('location', 'process_storage_discharge', 0): 0.0},
+                                'Incidental_process': {('location', 'process_certain_capacity', 0): 0.0,
+                                                       ('location', 'process_deterministic_capacity', 0): 0.0,
+                                                       ('location', 'process_deterministic_capacity2', 0): 0.0,
+                                                       ('location', 'process_storage', 0): 0.0,
+                                                       ('location', 'process_storage_discharge', 0): 0.0},
+                                'Fopex_location': {('location', 0): 750.0},
+                                'Vopex_location': {('location', 0): 218.75},
+                                'Capex_location': {('location', 0): 45833.333},
+                                'Incidental_location': {('location', 0): 0.0},
+                                'Fopex_network': {0: 750.0},
+                                'Vopex_network': {0: 218.75},
+                                'Capex_network': {0: 45833.333},
+                                'Incidental_network': {0: 0.0},
+                                'Inv_network': {('location',
+                                                 'process_storage_resource_deterministic_demand_stored',
+                                                 0): 25.0},
+                                'Cost': {None: None},
+                                'Inv_cost': {('location',
+                                              'process_storage_resource_deterministic_demand_stored',
+                                              0): 2.5},
+                                'Inv_cost_location': {('location', 0): 2.5},
+                                'Inv_cost_network': {0: 2.5},
+                                'X_P': {('location', 'process_certain_capacity', 0): 1.0,
+                                        ('location', 'process_deterministic_capacity', 0): 1.0,
+                                        ('location', 'process_deterministic_capacity2', 0): -0.0,
+                                        ('location', 'process_storage', 0): 1.0,
+                                        ('location', 'process_storage_discharge', 0): 1.0},
+                                'X_S': {('location',
+                                         'process_storage_resource_deterministic_demand_stored',
+                                         0): 1.0},
+                                'objective': 47423.333})
diff --git a/tests/problem_tests/scratch_pad.py b/tests/problem_tests/scratch_pad.py
new file mode 100644
index 00000000..b79183b0
--- /dev/null
+++ b/tests/problem_tests/scratch_pad.py
@@ -0,0 +1,174 @@
+
+
+# %%
+# # %%
+
+from src.energiapy.model.solve import solve
+from src.energiapy.model.formulate import formulate, Constraints, Objective
+from src.energiapy.components.scenario import Scenario
+from src.energiapy.components.location import Location
+from src.energiapy.components.material import Material
+from src.energiapy.components.process import Process, VaryingProcess
+from src.energiapy.components.temporal_scale import TemporalScale
+from src.energiapy.components.resource import Resource, VaryingResource
+import pandas
+import sys
+sys.path.append('../../')
+
+
+# #%%
+
+demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+scales = TemporalScale(discretization_list=[1, 4])
+
+Resource_certain_availability = Resource(
+    name='resource_certain_availability', cons_max=100, price=2)
+
+Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+                                               VaryingResource.DETERMINISTIC_AVAILABILITY])
+Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+                                         VaryingResource.DETERMINISTIC_DEMAND])
+Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                        VaryingResource.DETERMINISTIC_PRICE])
+Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=500, varying=[
+                                          VaryingResource.DETERMINISTIC_REVENUE])
+
+Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                         capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=0, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+                                   Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+                                   capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                          capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+Place = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity, Process_storage}, scales=scales,
+                 demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                 demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor},
+                 price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                 revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+Occurance = Scenario(name='scenario', scales=scales, network=Place, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                     capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                     demand={Place: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+# LP = formulate(scenario=Occurance, constraints={Constraints.COST, Constraints.INVENTORY,
+#                Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE, Constraints.DEMAND}, objective=Objective.COST)
+LP = formulate(scenario=Occurance, constraints={Constraints.COST, Constraints.INVENTORY,
+               Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE}, objective=Objective.PROFIT)
+
+results = solve(scenario=Occurance, instance=LP, solver='gurobi', name='LP')
+
+# %%
+
+
+demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+capacity_factor2 = pandas.DataFrame(data={'Value': [0.75, 1, 0.25, 0.5]})
+availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+scales = TemporalScale(discretization_list=[1, 4])
+
+Resource_certain_availability = Resource(
+    name='resource_certain_availability', cons_max=100, price=2)
+
+Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+                                               VaryingResource.DETERMINISTIC_AVAILABILITY])
+Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+                                         VaryingResource.DETERMINISTIC_DEMAND])
+Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                        VaryingResource.DETERMINISTIC_PRICE])
+Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=500, varying=[
+                                          VaryingResource.DETERMINISTIC_REVENUE])
+
+Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                         capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=10, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+
+Process_deterministic_capacity2 = Process(name='process_deterministic_capacity2', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                          capex=2000, fopex=20, vopex=5, cap_max=100, cap_min=10, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+
+Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+                                   Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+                                   capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                          capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+Place = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity2, Process_deterministic_capacity, Process_storage}, scales=scales,
+                 demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                 demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor, Process_deterministic_capacity2: capacity_factor2},
+                 price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                 revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+Occurance = Scenario(name='scenario', scales=scales, network=Place, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                     capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                     demand={Place: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+# LP = formulate(scenario=Occurance, constraints={Constraints.COST, Constraints.INVENTORY,
+#                Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE, Constraints.DEMAND}, objective=Objective.COST)
+MILP = formulate(scenario=Occurance, constraints={Constraints.COST, Constraints.NETWORK, Constraints.INVENTORY,
+                                                  Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE}, objective=Objective.PROFIT)
+
+results = solve(scenario=Occurance, instance=MILP,
+                solver='gurobi', name='MILP')
+
+# %%
+
+
+demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+capacity_factor2 = pandas.DataFrame(data={'Value': [0.75, 1, 0.25, 0.5]})
+availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+scales = TemporalScale(discretization_list=[1, 4])
+
+Resource_certain_availability = Resource(
+    name='resource_certain_availability', cons_max=100, price=2)
+
+Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+                                               VaryingResource.DETERMINISTIC_AVAILABILITY])
+Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+                                         VaryingResource.DETERMINISTIC_DEMAND])
+Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                        VaryingResource.DETERMINISTIC_PRICE])
+Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=500, varying=[
+                                          VaryingResource.DETERMINISTIC_REVENUE])
+
+Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                         capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=10, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+
+Process_deterministic_capacity2 = Process(name='process_deterministic_capacity2', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                          capex=2000, fopex=20, vopex=5, cap_max=100, cap_min=10, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+
+Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+                                   Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+                                   capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                          capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+Place = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity2, Process_deterministic_capacity, Process_storage}, scales=scales,
+                 demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                 demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor, Process_deterministic_capacity2: capacity_factor2},
+                 price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                 revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+Occurance = Scenario(name='scenario', scales=scales, network=Place, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                     capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                     demand={Place: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+# LP = formulate(scenario=Occurance, constraints={Constraints.COST, Constraints.INVENTORY,
+#                Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE, Constraints.DEMAND}, objective=Objective.COST)
+MILP = formulate(scenario=Occurance, constraints={Constraints.COST, Constraints.NETWORK, Constraints.INVENTORY,
+                                                  Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE, Constraints.DEMAND}, objective=Objective.COST)
+
+results = solve(scenario=Occurance, instance=MILP,
+                solver='gurobi', name='MILP')
+
+# %%
diff --git a/tests/test_fixtures.py b/tests/test_fixtures.py
new file mode 100644
index 00000000..80ed612e
--- /dev/null
+++ b/tests/test_fixtures.py
@@ -0,0 +1,328 @@
+import pandas
+import pytest
+from src.energiapy.components.resource import Resource, VaryingResource
+from src.energiapy.components.temporal_scale import TemporalScale
+from src.energiapy.components.process import Process, VaryingProcess
+from src.energiapy.components.location import Location
+from src.energiapy.components.scenario import Scenario
+from src.energiapy.components.material import Material
+from src.energiapy.components.transport import Transport
+from src.energiapy.components.network import Network
+from src.energiapy.components.case_study import CaseStudy
+from src.energiapy.model.formulate import formulate, Constraints, Objective
+from src.energiapy.model.solve import solve
+
+
+@pytest.fixture()
+def temporal_scale():
+    """Temporal scale with 1 main period and 4 sub periods"""
+    return TemporalScale(discretization_list=[1, 4])
+
+
+@pytest.fixture()
+def process_storage():
+    """Storage process"""
+    Resource1 = Resource(name='Resource1')
+    return Process(name='Process1', storage=Resource1, capex=1000, fopex=100, vopex=10,
+                   cap_max=100, cap_min=0.1, store_max=100, storage_loss=0.01, storage_cost=0.1)
+
+
+@pytest.fixture()
+def process_material_modes():
+    """Process with material modes"""
+    Resource1 = Resource(name='Resource1', cons_max=1000)
+    Resource2 = Resource(name='Resource2')
+    Material1 = Material(name='Material1', gwp=100)
+    Material2 = Material(name='Material2', gwp=200)
+    return Process(name='Process1', conversion={'Mode1': {Resource1: -5, Resource2: 1}, 'Mode2': {Resource1: -10, Resource2: 1}},
+                   capex={'Mode1': 2000, 'Mode2': 1000}, fopex={'Mode1': 100, 'Mode2': 200}, vopex={'Mode1': 50, 'Mode2': 10},
+                   material_cons={'Mode1': {Material1: 50, Material2: 20}, 'Mode2': {
+                       Material1: 100, Material2: 25}},
+                   cap_max=100, cap_min=0.1)
+
+
+# @pytest.fixture()
+# def process_multiple_modes():
+#     """Process with multiple modes and ramping rates"""
+#     cap_max = {0: 10, 1: 50}
+#     cap_min = {0: 0, 1: 10}
+#     rate_max = {0: 10, 1: 15}
+#     mode_ramp = {(0, 1): 0.5}
+#     Resource1 = Resource(name='Resource1', cons_max=1000)
+#     Resource2 = Resource(name='Resource2')
+#     return Process(name='Process1', conversion={0: {Resource1: -1, Resource2: 0.5}, 1: {Resource1: -1, Resource2: 0.75}},
+#                    rate_max=rate_max, mode_ramp=mode_ramp, cap_max=cap_max, cap_min=cap_min,
+#                    capex=1000, fopex=100, vopex=10)
+
+
+@pytest.fixture()
+def location_no_variability():
+    """Location with no variability"""
+    scales = TemporalScale(discretization_list=[1, 4])
+    Resource1 = Resource(name='Resource1', cons_max=1000)
+    Resource2 = Resource(name='Resource2')
+    Material1 = Material(name='Material1', gwp=100)
+    Material2 = Material(name='Material2', gwp=200)
+    Process1 = Process(name='Process1', storage=Resource2, capex=1000, fopex=100, vopex=10,
+                       cap_max=100, cap_min=0.1, store_max=100, storage_loss=0.01, storage_cost=0.1)
+    Process2 = Process(name='Process2', conversion={'Mode1': {Resource1: -5, Resource2: 1}, 'Mode2': {Resource1: -10, Resource2: 1}},
+                       capex={'Mode1': 2000, 'Mode2': 1000}, fopex={'Mode1': 100, 'Mode2': 200}, vopex={'Mode1': 50, 'Mode2': 10},
+                       material_cons={'Mode1': {Material1: 50, Material2: 20}, 'Mode2': {
+                           Material1: 100, Material2: 25}},
+                       cap_max=100, cap_min=0.1)
+    cap_max = {0: 10, 1: 50}
+    cap_min = {0: 0, 1: 10}
+    rate_max = {0: 10, 1: 15}
+    mode_ramp = {(0, 1): 0.5}
+    Process3 = Process(name='Process3', conversion={0: {Resource1: -1, Resource2: 0.5}, 1: {Resource1: -1, Resource2: 0.75}},
+                       rate_max=rate_max, mode_ramp=mode_ramp, cap_max=cap_max, cap_min=cap_min,
+                       capex=1000, fopex=100, vopex=10)
+    return Location(name='Location1', processes={Process1, Process2, Process3}, scales=scales)
+
+
+@pytest.fixture()
+def single_location_scenario_variability():
+    """Scenario with variability"""
+    demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+    capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+    availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+    price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+    revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+    scales = TemporalScale(discretization_list=[1, 4])
+
+    Resource_certain_availability = Resource(
+        name='resource_certain_availability', cons_max=100, price=2)
+
+    Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+        VaryingResource.DETERMINISTIC_AVAILABILITY])
+    Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+        VaryingResource.DETERMINISTIC_DEMAND])
+    Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                            VaryingResource.DETERMINISTIC_PRICE])
+    Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=20, varying=[
+        VaryingResource.DETERMINISTIC_REVENUE])
+
+    Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                             capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=0, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+    Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+        Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+        capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+    Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                              capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+    Location1 = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity, Process_storage}, scales=scales,
+                         demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                         demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor},
+                         price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                         revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+    return Scenario(name='scenario', scales=scales, network=Location1, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                    capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                    demand={Location1: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+
+@pytest.fixture()
+def single_location_lp_variability_cost():
+    """LP for scenario with variability"""
+    demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+    capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+    availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+    price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+    revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+    scales = TemporalScale(discretization_list=[1, 4])
+
+    Resource_certain_availability = Resource(
+        name='resource_certain_availability', cons_max=100, price=2)
+
+    Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+        VaryingResource.DETERMINISTIC_AVAILABILITY])
+    Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+        VaryingResource.DETERMINISTIC_DEMAND])
+    Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                            VaryingResource.DETERMINISTIC_PRICE])
+    Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=500, varying=[
+        VaryingResource.DETERMINISTIC_REVENUE])
+
+    Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                             capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=0, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+    Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+        Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+        capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+    Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                              capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+    Location1 = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity, Process_storage}, scales=scales,
+                         demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                         demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor},
+                         price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                         revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+    Scenario1 = Scenario(name='scenario', scales=scales, network=Location1, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                         capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                         demand={Location1: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+    return formulate(scenario=Scenario1, constraints={Constraints.COST, Constraints.INVENTORY,
+                                                      Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE, Constraints.DEMAND}, objective=Objective.COST)
+
+
+@pytest.fixture()
+def single_location_lp_variability_profit():
+    """LP for scenario with variability"""
+    demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+    capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+    availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+    price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+    revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+    scales = TemporalScale(discretization_list=[1, 4])
+
+    Resource_certain_availability = Resource(
+        name='resource_certain_availability', cons_max=100, price=2)
+
+    Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+        VaryingResource.DETERMINISTIC_AVAILABILITY])
+    Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+        VaryingResource.DETERMINISTIC_DEMAND])
+    Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                            VaryingResource.DETERMINISTIC_PRICE])
+    Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=500, varying=[
+        VaryingResource.DETERMINISTIC_REVENUE])
+
+    Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                             capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=0, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+    Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+        Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+        capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+    Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                              capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+    Location1 = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity, Process_storage}, scales=scales,
+                         demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                         demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor},
+                         price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                         revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+    Scenario1 = Scenario(name='scenario', scales=scales, network=Location1, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                         capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                         demand={Location1: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+    return formulate(scenario=Scenario1, constraints={Constraints.COST, Constraints.INVENTORY,
+                                                      Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE}, objective=Objective.PROFIT)
+
+
+@pytest.fixture()
+def single_location_milp_variability_cost():
+    demand_factor = pandas.DataFrame(data={'Value': [0.5, 1, 0.5, 0.25]})
+    capacity_factor = pandas.DataFrame(data={'Value': [1, 0.5, 1, 0.25]})
+    capacity_factor2 = pandas.DataFrame(data={'Value': [0.75, 1, 0.25, 0.5]})
+    availability_factor = pandas.DataFrame(data={'Value': [1, 1, 0.5, 0.5]})
+    price_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.5, 0.75]})
+    revenue_factor = pandas.DataFrame(data={'Value': [0.25, 1, 0.25, 0.5]})
+
+    scales = TemporalScale(discretization_list=[1, 4])
+
+    Resource_certain_availability = Resource(
+        name='resource_certain_availability', cons_max=100, price=2)
+
+    Resource_deterministic_availability = Resource(name='resource_deterministic_availability', cons_max=100, price=5, varying=[
+        VaryingResource.DETERMINISTIC_AVAILABILITY])
+    Resource_deterministic_demand = Resource(name='resource_deterministic_demand', demand=True, varying=[
+        VaryingResource.DETERMINISTIC_DEMAND])
+    Resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=10, varying=[
+                                            VaryingResource.DETERMINISTIC_PRICE])
+    Resource_deterministic_revenue = Resource(name='resource_deterministic_revenue', demand=True, revenue=500, varying=[
+        VaryingResource.DETERMINISTIC_REVENUE])
+
+    Process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                             capex=1000, fopex=10, vopex=1, cap_max=100, cap_min=10, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+
+    Process_deterministic_capacity2 = Process(name='process_deterministic_capacity2', conversion={Resource_certain_availability: -1, Resource_deterministic_demand: 1},
+                                              capex=2000, fopex=20, vopex=5, cap_max=100, cap_min=10, varying=[VaryingProcess.DETERMINISTIC_CAPACITY])
+
+    Process_certain_capacity = Process(name='process_certain_capacity', conversion={
+        Resource_deterministic_demand: -0.5, Resource_deterministic_availability: -0.5, Resource_deterministic_price: -0.25, Resource_deterministic_revenue: 1},
+        capex=100, fopex=10, vopex=1, cap_max=100, cap_min=0)
+    Process_storage = Process(name='process_storage', storage=Resource_deterministic_demand,
+                              capex=100, fopex=5, vopex=0.5, cap_max=50, cap_min=0, store_max=25, storage_cost=0.1)
+
+    Location1 = Location(name='location', processes={Process_certain_capacity, Process_deterministic_capacity2, Process_deterministic_capacity, Process_storage}, scales=scales,
+                         demand_scale_level=1, capacity_scale_level=1, price_scale_level=1, availability_scale_level=1,
+                         demand_factor={Resource_deterministic_demand: demand_factor}, capacity_factor={Process_deterministic_capacity: capacity_factor, Process_deterministic_capacity2: capacity_factor2},
+                         price_factor={Resource_deterministic_price: price_factor}, availability_factor={Resource_deterministic_availability: availability_factor},
+                         revenue_factor={Resource_deterministic_revenue: revenue_factor})
+
+    Scenario1 = Scenario(name='scenario', scales=scales, network=Location1, demand_scale_level=1, network_scale_level=0, scheduling_scale_level=1,
+                         capacity_scale_level=1, purchase_scale_level=1, availability_scale_level=1,
+                         demand={Location1: {Resource_deterministic_demand: 25, Resource_deterministic_revenue: 25}})
+
+    return Scenario1, formulate(scenario=Scenario1, constraints={Constraints.COST, Constraints.NETWORK, Constraints.INVENTORY,
+                                                                 Constraints.PRODUCTION, Constraints.RESOURCE_BALANCE, Constraints.DEMAND}, objective=Objective.COST)
+
+
+@pytest.fixture()
+def multi_location_milp_variability_cost():
+    capacity_factor = pandas.DataFrame(data=[0.5, 0.75, 1, 0.5])
+    price_factor = pandas.DataFrame(data=[0.75, 0.8, 0.25, 1.0])
+    demand_factor = pandas.DataFrame(data=[0.6, 0.8, 0.4, 1.0])
+
+    scales = TemporalScale(discretization_list=[1, 4])
+
+    resource_certain_availability = Resource(
+        name='resource_certain_availability', cons_max=100)
+
+    resource_implicit = Resource(name='resource_implicit')
+
+    resource_implicit2 = Resource(name='resource_implicit2')
+
+    resource_deterministic_demand = Resource(
+        name='resource_deterministic_demand', demand=True, revenue=2000)
+
+    resource_deterministic_price = Resource(name='resource_deterministic_price', cons_max=100, price=3.00, varying=[
+                                            VaryingResource.DETERMINISTIC_PRICE])
+
+    resource_sell = Resource(name='resource_sell', sell=True)
+
+    process_deterministic_capacity = Process(name='process_deterministic_capacity', conversion={resource_certain_availability: -1.25, resource_implicit: 1},
+                                             capex=100, fopex=10, vopex=1, cap_max=100, varying=[VaryingProcess.UNCERTAIN_CAPACITY])
+
+    process_certain_capacity = Process(name='process_certain_capacity', conversion={resource_implicit: -0.5, resource_deterministic_price: -0.75, resource_implicit2: 1},
+                                       capex=200, fopex=25, vopex=5, cap_max=100)
+
+    process_certain_capacity2 = Process(name='process_certain_capacity2', conversion={resource_implicit2: -1, resource_deterministic_demand: 1},
+                                        capex=10, fopex=1, vopex=0.1, cap_max=100)
+
+    location1 = Location(name='location1', processes={process_deterministic_capacity}, capacity_factor={process_deterministic_capacity: capacity_factor},
+                         scales=scales, demand_scale_level=1, capacity_scale_level=1, price_scale_level=1)
+
+    location2 = Location(name='location2', processes={process_certain_capacity}, price_factor={resource_deterministic_price: price_factor},
+                         scales=scales, demand_scale_level=1, capacity_scale_level=1, price_scale_level=1)
+
+    location3 = Location(name='location3', processes={process_certain_capacity2}, demand_factor={resource_deterministic_demand: demand_factor}, scales=scales,
+                         demand_scale_level=1, capacity_scale_level=1, price_scale_level=1)
+    transport = Transport(name='transport', resources={
+                          resource_implicit}, trans_max=100, trans_loss=0.1, capex=40, vopex=1)
+    transport2 = Transport(name='transport2', resources={
+                           resource_implicit2}, trans_max=100, trans_loss=0.05, capex=20, vopex=5)
+
+    distance_matrix = [
+        [10, 0],
+        [0, 50],
+    ]
+
+    transport_matrix = [
+        [[transport], []],
+        [[], [transport2]],
+    ]
+
+    network = Network(name='network', source_locations=[location1, location2], sink_locations=[location2, location3],
+                      distance_matrix=distance_matrix, transport_matrix=transport_matrix, scales=scales)
+
+    scenario = Scenario(name='scenario', network=network, scales=scales, scheduling_scale_level=1,
+                        network_scale_level=0, demand_scale_level=1, purchase_scale_level=1, capacity_scale_level=1, demand={l: {resource_deterministic_demand: 50} if l == location3 else {resource_deterministic_demand: 0} for l in network.locations})
+    casestudy = CaseStudy(name='casestudy', scenarios=[scenario])
+
+    casestudy.formulate(constraints={Constraints.COST, Constraints.INVENTORY, Constraints.PRODUCTION,
+                        Constraints.RESOURCE_BALANCE, Constraints.NETWORK, Constraints.DEMAND, Constraints.TRANSPORT}, objective=Objective.COST)
+    return casestudy