Repository: TAMUparametric/energiapy (language: python)

Issue:
Red tasks



Discussion / hints:

Fix patch:
diff --git a/debug.py b/debug.py
index 9fbdb9ef..39fdd4ef 100644
--- a/debug.py
+++ b/debug.py
@@ -6,7 +6,7 @@
 s = Scenario(default=True)
 
 # s.h2 = Horizon({'days': 2, 'hours': 12})
-s.hor = Horizon(discretizations=[2, 12])
+s.hor = Horizon(birth=[2, 12])
 s.net = Network(['madgaon', 'ponje', 'cacoda'])  # , link_all=True)
 s.alink = Linkage(source=s.madgaon, sink=s.ponje, bi=True, distance=50)
 s.blink = Linkage(source=s.ponje, sink=s.cacoda, bi=False, distance=80)
diff --git a/examples/scopes.ipynb b/examples/scopes.ipynb
new file mode 100644
index 00000000..0d38b1a3
--- /dev/null
+++ b/examples/scopes.ipynb
@@ -0,0 +1,365 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "\n",
+    "sys.path.append('../src')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from energiapy.components.temporal.horizon import Horizon\n",
+    "from energiapy.components.spatial.network import Network\n",
+    "from energiapy.components.temporal.scale import Scale\n",
+    "from energiapy.components.spatial.location import Location\n",
+    "from energiapy.environ.scenario import Scenario"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s_hrz_nest = Scenario()\n",
+    "s_hrz_nest.hrz = Horizon(birth={'day': 365, 'hour': 24}, nested=True)\n",
+    "s_hrz_flat = Scenario()\n",
+    "s_hrz_flat.hrz = Horizon(birth={'month': 12, 'day': 365, 'hour': 8760})\n",
+    "s_ntw_nest = Scenario()\n",
+    "s_ntw_nest.ntw = Network(birth={'state': 50, 'city': 3}, nested=True)\n",
+    "s_ntw_flat = Scenario()\n",
+    "s_ntw_flat.ntw = Network(birth={'state': 50, 'city': 150})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(hrz,) (hrz, day) (hrz, day, hour)\n",
+      "1 365 8760\n",
+      "[day] [hour] []\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(s_hrz_nest.hrz.index, s_hrz_nest.day.index, s_hrz_nest.hour.index)\n",
+    "print(s_hrz_nest.hrz.discrs, s_hrz_nest.day.discrs, s_hrz_nest.hour.discrs)\n",
+    "print(s_hrz_nest.hrz.children, s_hrz_nest.day.children, s_hrz_nest.hour.children)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(hrz,) (hrz, month) (hrz, day) (hrz, hour)\n",
+      "1 12 365 8760\n",
+      "[month, day, hour] [] [] []\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\n",
+    "    s_hrz_flat.hrz.index,\n",
+    "    s_hrz_flat.month.index,\n",
+    "    s_hrz_flat.day.index,\n",
+    "    s_hrz_flat.hour.index,\n",
+    ")\n",
+    "print(\n",
+    "    s_hrz_flat.hrz.discrs,\n",
+    "    s_hrz_flat.month.discrs,\n",
+    "    s_hrz_flat.day.discrs,\n",
+    "    s_hrz_flat.hour.discrs,\n",
+    ")\n",
+    "\n",
+    "print(\n",
+    "    s_hrz_flat.hrz.children,\n",
+    "    s_hrz_flat.month.children,\n",
+    "    s_hrz_flat.day.children,\n",
+    "    s_hrz_flat.hour.children,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(ntw,) (ntw, state) (ntw, state, city)\n",
+      "1 50 150\n",
+      "[state] [city] []\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(s_ntw_nest.ntw.index, s_ntw_nest.state.index, s_ntw_nest.city.index)\n",
+    "print(s_ntw_nest.ntw.discrs, s_ntw_nest.state.discrs, s_ntw_nest.city.discrs)\n",
+    "print(s_ntw_nest.ntw.children, s_ntw_nest.state.children, s_ntw_nest.city.children)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(ntw,) (ntw, state) (ntw, city)\n",
+      "1 50 150\n",
+      "[state, city] [] []\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(s_ntw_flat.ntw.index, s_ntw_flat.state.index, s_ntw_flat.city.index)\n",
+    "print(s_ntw_flat.ntw.discrs, s_ntw_flat.state.discrs, s_ntw_flat.city.discrs)\n",
+    "print(s_ntw_flat.ntw.children, s_ntw_flat.state.children, s_ntw_flat.city.children)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s_hrz_flat.week = Scale(parent=s_hrz_flat.hrz, discrs=365 / 7)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(hrz, week)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s_hrz_flat.week.index"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = Scenario()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.n = Network()\n",
+    "s.h = Horizon()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.day = Scale(parent=s.h, discrs=365)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[day]"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.h.children"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.india = Location(parent=s.n, discrs=1)\n",
+    "s.goa = Location(parent=s.india, discrs=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[india]"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.n.children"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[goa]"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.india.children"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(n, india)"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.india.index"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(n, india, goa)"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.goa.index"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# locations_list = [50]  # one country, 50 states\n",
+    "# locs_in_locs_list = [5, 3]  # 5 states, 3 cities in each state\n",
+    "# locs_dict = {'state': 50, 'county': 3143, 'Texas': 1}\n",
+    "# locs_in_locs_dict = {\n",
+    "#     'planet': 8,\n",
+    "#     'sites': 3,\n",
+    "# }  # three possible landing sites on each of the 8 planets\n",
+    "\n",
+    "\n",
+    "# locs_in_locs_dict = {\n",
+    "#     'middleearth': {\n",
+    "#         'hobbiton': {'shire': {'hobbiton': 'bagend'}, 'gamwich': {}},\n",
+    "#         'mordor': {'mountdoom'},\n",
+    "#     },\n",
+    "#     'india': {\n",
+    "#         'goa': {'magdaon', 'ponje'},\n",
+    "#     },\n",
+    "#     'greece': {'thessaloniki'},\n",
+    "# }\n",
+    "\n",
+    "# scales = [{'day': 365}, {'day': {'hour': 24}}, {'week': {'day': 7}}]\n",
+    "# locs = [\n",
+    "#     {'india': ['madgaon', 'cacoda']},\n",
+    "#     {'greece': {'macedonia': {'thessaloniki': 4}}},\n",
+    "# ]"
+   ]
+  }
+ ],
+ "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.12.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/scratchpad2.ipynb b/scratchpad2.ipynb
index 4fffe571..09d5138d 100644
--- a/scratchpad2.ipynb
+++ b/scratchpad2.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -39,7 +39,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -49,26 +49,6 @@
     "from dataclasses import fields, field, dataclass"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]], dict[energiapy.components.spatial.location.Location | energiapy.components.spatial.linkage.Linkage | energiapy.components.spatial.network.Network, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.spatial.location.Location | energiapy.components.spatial.linkage.Linkage | energiapy.components.spatial.network.Network, dict[energiapy.components.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]]]]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "IsBnd"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -82,875 +62,231 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# s.h2 = Horizon({'days': 2, 'hours': 12})\n",
-    "s.hor = Horizon(discretizations=[2, 12])\n",
-    "s.scales\n",
-    "s.net = Network(['madgaon', 'ponje', 'cacoda'])  # , link_all=True)\n",
-    "s.nodes\n",
-    "s.alink = Linkage(source=s.madgaon, sink=s.ponje, bi=True, distance=50)\n",
-    "s.blink = Linkage(source=s.ponje, sink=s.cacoda, bi=False, distance=80)\n",
-    "s.clink = Linkage(source=s.cacoda, sink=s.madgaon, bi=True, distance=100)\n",
-    "s.dlink = Linkage(source=s.madgaon, sink=s.ponje, bi=False, distance=200)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = DataFrame({'a': list(range(2))})\n",
-    "b = DataFrame({'b': list(range(24))})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\cacodcar\\energiapy\\src\\energiapy\\components\\_base\\_consistent.py:230: InconsistencyWarning: \n",
-      "csh.spend:Inconsistent temporal scale for ponje at t2.\n",
-      "Updating to t1\n",
-      "Set Scneario.ok_inconsistent=False, to enforce strictly\n",
-      "  warn(\n"
-     ]
-    }
-   ],
-   "source": [
-    "s.csh = Cash(\n",
-    "    spend={\n",
-    "        s.madgaon: True,\n",
-    "        s.ponje: {s.t2: (2, a)},\n",
-    "        s.cacoda: a,\n",
-    "        s.network: {s.t2: [5, 7]},\n",
-    "    },\n",
-    "    # label='cash',\n",
-    "    basis='USD',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,madgaon,t_{0}} \\geq 0$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,madgaon,t_{0}} \\leq M$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,ponje,t_{1}} = {θ}_{csh,ponje,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,cacoda,t_{1}} = {DtSt}_{csh,cacoda,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,net,t_{2}} \\geq 5$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,net,t_{2}} \\leq 7$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "s.cash.pprint()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\cacodcar\\energiapy\\src\\energiapy\\components\\_base\\_consistent.py:230: InconsistencyWarning: \n",
-      "H2.sell_price:Inconsistent temporal scale for ponje at t1.\n",
-      "Updating to t2\n",
-      "Set Scneario.ok_inconsistent=False, to enforce strictly\n",
-      "  warn(\n"
-     ]
-    }
-   ],
-   "source": [
-    "s.H2 = Resource(\n",
-    "    # sell={s.t0: [0, 4], s.t1: [a, 34], s.t2: (a, b)},\n",
-    "    sell_price={\n",
-    "        s.madgaon: {s.t1: (2, a)},\n",
-    "        s.ponje: {s.t1: (2, b)},\n",
-    "        s.cacoda: 300,\n",
-    "    },\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[Price^sell[csh, H2, cacoda, t0],\n",
-       " Price^sell[csh, H2, madgaon, t1],\n",
-       " Price^sell[csh, H2, ponje, t2]]"
+       "[madgaon, ponje, cacoda]"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "s.H2.parameters"
+    "# s.h2 = Horizon({'days': 2, 'hours': 12})\n",
+    "s.hor = Horizon(birth=[2, 12], nested=True)\n",
+    "s.scales\n",
+    "s.net = Network(birth={'madgaon': 1, 'ponje': 1, 'cacoda': 1})  # , link_all=True)\n",
+    "s.nodes"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},cacoda,t_{0}} = {sell}_{H_{2},cacoda,t_{0}} \\cdot 300$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},madgaon,t_{1}} = {sell}_{H_{2},madgaon,t_{1}} \\cdot {θ}_{csh,H_{2},madgaon,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},ponje,t_{2}} = {sell}_{H_{2},ponje,t_{2}} \\cdot {θ}_{csh,H_{2},ponje,t_{2}}$"
-      ],
       "text/plain": [
-       "<IPython.core.display.Math object>"
+       "net"
       ]
      },
+     "execution_count": 6,
      "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "s.H2.pprint()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\cacodcar\\energiapy\\src\\energiapy\\environ\\_scenario\\_ok.py:54: OverWriteWarning: \n",
-      "A Power was already defined.\n",
-      "Overwriting. Set Scenario.ok_overwrite=False, to enforce strictly\n",
-      "This should not cause any modeling issues.\n",
-      "Check Scenario defaults if unintended.\n",
-      "Only one instance of Horizon, Network, Cash, and Land are allowed\n",
-      "  warn(OverWriteWarning(cmp))\n"
-     ]
-    }
-   ],
-   "source": [
-    "s.Solar = Resource(buy=True, basis='MW', label='Solar Power')\n",
-    "\n",
-    "\n",
-    "s.Wind = Resource(buy=a, basis='MW', label='Wind Power')\n",
-    "\n",
-    "\n",
-    "s.Power = Resource(basis='MW', label='Power generated')\n",
-    "\n",
-    "\n",
-    "s.Uranium = Resource(\n",
-    "    buy=DataFrame({'a': [i for i in range(24)]}),\n",
-    "    buy_price=42.70 / (250 / 2),\n",
-    "    basis='kg',\n",
-    "    label='Uranium',\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# s.H2_L = Resource(sell=(0, 23), basis='tons', label='Hydrogen')\n",
-    "\n",
-    "\n",
-    "# s.CO2_AQoff = Resource(basis='tons', label='Carbon dioxide - sequestered')\n",
-    "\n",
-    "\n",
-    "s.H2O = Resource(buy=(20, 50), buy_price=b, basis='tons', label='Water')\n",
-    "\n",
-    "\n",
-    "s.CH4 = Resource(buy=[20, 40], buy_price=20, basis='tons', label='Natural gas')\n",
-    "\n",
-    "\n",
-    "s.CO2 = Resource(basis='tons', label='Carbon dioxide', block='Resource')\n",
-    "\n",
-    "\n",
-    "s.CO2_Vent = Resource(\n",
-    "    basis='tons',\n",
-    "    label='Carbon dioxide - Vented',\n",
-    "    sell_price=(2, 20),\n",
-    "    sell_emission={s.gwp: b},\n",
-    ")\n",
-    "\n",
-    "\n",
-    "s.O2 = Resource(sell=[20, True], basis='tons', label='Oxygen')\n",
-    "\n",
-    "\n",
-    "s.CO2_DAC = Resource(basis='tons', label='Carbon dioxide - captured')\n",
-    "s.Power = Resource(buy=[0, a], basis='MW', label='Power generated')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,madgaon,t_{0}} \\geq 0$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,madgaon,t_{0}} \\leq M$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,ponje,t_{1}} = {θ}_{csh,ponje,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,cacoda,t_{1}} = {DtSt}_{csh,cacoda,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,net,t_{2}} \\geq 5$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {spend}_{csh,net,t_{2}} \\leq 7$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},cacoda,t_{0}} = {sell}_{H_{2},cacoda,t_{0}} \\cdot 300$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},madgaon,t_{1}} = {sell}_{H_{2},madgaon,t_{1}} \\cdot {θ}_{csh,H_{2},madgaon,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},ponje,t_{2}} = {sell}_{H_{2},ponje,t_{2}} \\cdot {θ}_{csh,H_{2},ponje,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{Solar,net,t_{0}} \\geq 0$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{Solar,net,t_{0}} \\leq M$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{Wind,net,t_{1}} = {DtSt}_{Wind,net,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{Power,net,t_{1}} \\geq 0$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{Power,net,t_{1}} \\leq {DtSt^{max}}_{Power,net,t_{1}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{Uranium,net,t_{2}} = {DtSt}_{Uranium,net,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,Uranium,cacoda,t_{0}} = {buy}_{Uranium,cacoda,t_{0}} \\cdot 0.3416$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,Uranium,madgaon,t_{0}} = {buy}_{Uranium,madgaon,t_{0}} \\cdot 0.3416$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,Uranium,ponje,t_{0}} = {buy}_{Uranium,ponje,t_{0}} \\cdot 0.3416$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{H2O,net,t_{0}} = {θ}_{H2O,net,t_{0}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,cacoda,t_{2}} = {DtSt}_{csh,H2O,cacoda,t_{2}} \\cdot {buy}_{H2O,cacoda,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,madgaon,t_{2}} = {DtSt}_{csh,H2O,madgaon,t_{2}} \\cdot {buy}_{H2O,madgaon,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,ponje,t_{2}} = {DtSt}_{csh,H2O,ponje,t_{2}} \\cdot {buy}_{H2O,ponje,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{CH_{4},net,t_{0}} \\geq 20$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {buy}_{CH_{4},net,t_{0}} \\leq 40$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},cacoda,t_{0}} = {buy}_{CH_{4},cacoda,t_{0}} \\cdot 20$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},madgaon,t_{0}} = {buy}_{CH_{4},madgaon,t_{0}} \\cdot 20$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},ponje,t_{0}} = {buy}_{CH_{4},ponje,t_{0}} \\cdot 20$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},cacoda,t_{0}} = {sell}_{CO_{2 Vent},cacoda,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},cacoda,t_{0}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},madgaon,t_{0}} = {sell}_{CO_{2 Vent},madgaon,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},madgaon,t_{0}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},ponje,t_{0}} = {sell}_{CO_{2 Vent},ponje,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},ponje,t_{0}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},cacoda,t_{2}} = {DtSt}_{gwp,CO_{2 Vent},cacoda,t_{2}} \\cdot {sell}_{CO_{2 Vent},cacoda,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},madgaon,t_{2}} = {DtSt}_{gwp,CO_{2 Vent},madgaon,t_{2}} \\cdot {sell}_{CO_{2 Vent},madgaon,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},ponje,t_{2}} = {DtSt}_{gwp,CO_{2 Vent},ponje,t_{2}} \\cdot {sell}_{CO_{2 Vent},ponje,t_{2}}$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {sell}_{O_{2},net,t_{0}} \\geq 20$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {sell}_{O_{2},net,t_{0}} \\leq M$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "s.pprint()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.LiR = Material(\n",
-    "    use_emission={s.gwp: {s.t2: 1.484}},\n",
-    "    use={s.ponje: 1.5},\n",
-    "    basis='kg',\n",
-    "    label='Lithium Reserves',\n",
-    "    citation='Nelson Bunyui Manjong (2021)',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {use}_{LiR,ponje,t_{0}} = 1.5$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {emit^{use}}_{gwp,LiR,cacoda,t_{0}} = {use}_{LiR,cacoda,t_{0}} \\cdot 1.484$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {emit^{use}}_{gwp,LiR,madgaon,t_{0}} = {use}_{LiR,madgaon,t_{0}} \\cdot 1.484$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle {emit^{use}}_{gwp,LiR,ponje,t_{0}} = {use}_{LiR,ponje,t_{0}} \\cdot 1.484$"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Math object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "s.LiR.pprint()"
+    "s.madgaon.parent"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Power"
+       "24"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "s.Power"
+    "s.hor.scales[1].discrs"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.alink = Linkage(source=s.madgaon, sink=s.ponje, bi=True, distance=50)\n",
+    "s.blink = Linkage(source=s.ponje, sink=s.cacoda, bi=False, distance=80)\n",
+    "s.clink = Linkage(source=s.cacoda, sink=s.madgaon, bi=True, distance=100)\n",
+    "s.dlink = Linkage(source=s.madgaon, sink=s.ponje, bi=False, distance=200)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = DataFrame({'a': list(range(2))})\n",
+    "b = DataFrame({'b': list(range(24))})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "(Field(name='basis',type=<class 'str'>,default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='citation',type=<class 'dict'>,default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='block',type=<class 'str'>,default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='introduce',type=<class 'str'>,default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='retire',type=<class 'str'>,default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='label',type=<class 'str'>,default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='locations',type=list[energiapy.components.scope.spatial.location.Location],default=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,default_factory=<class 'list'>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='use_emission',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='use_cost',type=set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='buy',type=typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='sell',type=typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='buy_emission',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='sell_emission',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='loss_emission',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='buy_price',type=set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='sell_price',type=set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='credit',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='penalty',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='setup_time',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='setup_use',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='setup_emission',type=float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='capex',type=set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='opex',type=set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]] | dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage, dict[energiapy.components.scope.temporal.scale.Scale, dict[energiapy.components.scope.temporal.mode.X, set[float | int | pandas.core.frame.DataFrame | tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame] | energiapy.components.scope.temporal.incidental.I]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='produce',type=typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='capacity',type=typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]], dict[energiapy.components.scope.spatial.location.Location | energiapy.components.scope.spatial.linkage.Linkage | energiapy.components.scope.spatial.network.Network, dict[energiapy.components.scope.temporal.scale.Scale, typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True], list[typing.Union[float, int, pandas.core.frame.DataFrame, tuple[float | int | pandas.core.frame.DataFrame, float | int | pandas.core.frame.DataFrame], typing.Literal[True]]]]]]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD),\n",
-       " Field(name='conversion',type=dict[energiapy.components.commodity.resource.Resource, int | float] | dict[energiapy.components.scope.temporal.mode.X, dict[energiapy.components.commodity.resource.Resource, int | float]],default=None,default_factory=<dataclasses._MISSING_TYPE object at 0x0000018118FA2210>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD))"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\cacodcar\\energiapy\\src\\energiapy\\components\\_base\\_consistent.py:240: InconsistencyWarning: \n",
+      "csh.spend:Inconsistent temporal scale for ponje at t1.\n",
+      "Updating to t0\n",
+      "Set Scneario.ok_inconsistent=False, to enforce strictly\n",
+      "  warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "s.csh = Cash(\n",
+    "    spend={\n",
+    "        s.madgaon: True,\n",
+    "        s.ponje: {s.t1: (2, a)},\n",
+    "        s.cacoda: a,\n",
+    "        s.network: {s.t1: [5, 7]},\n",
+    "    },\n",
+    "    # label='cash',\n",
+    "    basis='USD',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\cacodcar\\energiapy\\src\\energiapy\\components\\_base\\_consistent.py:240: InconsistencyWarning: \n",
+      "H2.sell_price:Inconsistent temporal scale for madgaon at t1.\n",
+      "Updating to t0\n",
+      "Set Scneario.ok_inconsistent=False, to enforce strictly\n",
+      "  warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "s.H2 = Resource(\n",
+    "    # sell={s.t0: [0, 4], s.t1: [a, 34], s.t2: (a, b)},\n",
+    "    sell_price={\n",
+    "        s.madgaon: {s.t1: (2, a)},\n",
+    "        s.ponje: {s.t1: (2, b)},\n",
+    "        s.cacoda: 300,\n",
+    "    },\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\cacodcar\\energiapy\\src\\energiapy\\environ\\_scenario\\_ok.py:54: OverWriteWarning: \n",
+      "A Power was already defined.\n",
+      "Overwriting. Set Scenario.ok_overwrite=False, to enforce strictly\n",
+      "This should not cause any modeling issues.\n",
+      "Check Scenario defaults if unintended.\n",
+      "Only one instance of Horizon, Network, Cash, and Land are allowed\n",
+      "  warn(OverWriteWarning(cmp))\n"
+     ]
     }
    ],
    "source": [
-    "fields(Process)"
+    "s.Solar = Resource(buy=True, basis='MW', label='Solar Power')\n",
+    "\n",
+    "\n",
+    "s.Wind = Resource(buy=a, basis='MW', label='Wind Power')\n",
+    "\n",
+    "\n",
+    "s.Power = Resource(basis='MW', label='Power generated')\n",
+    "\n",
+    "\n",
+    "s.Uranium = Resource(\n",
+    "    buy=DataFrame({'a': [i for i in range(24)]}),\n",
+    "    buy_price=42.70 / (250 / 2),\n",
+    "    basis='kg',\n",
+    "    label='Uranium',\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# s.H2_L = Resource(sell=(0, 23), basis='tons', label='Hydrogen')\n",
+    "\n",
+    "\n",
+    "# s.CO2_AQoff = Resource(basis='tons', label='Carbon dioxide - sequestered')\n",
+    "\n",
+    "\n",
+    "s.H2O = Resource(buy=(20, 50), buy_price=b, basis='tons', label='Water')\n",
+    "\n",
+    "\n",
+    "s.CH4 = Resource(buy=[20, 40], buy_price=20, basis='tons', label='Natural gas')\n",
+    "\n",
+    "\n",
+    "s.CO2 = Resource(basis='tons', label='Carbon dioxide', block='Resource')\n",
+    "\n",
+    "\n",
+    "s.CO2_Vent = Resource(\n",
+    "    basis='tons',\n",
+    "    label='Carbon dioxide - Vented',\n",
+    "    sell_price=(2, 20),\n",
+    "    sell_emit={s.gwp: b},\n",
+    ")\n",
+    "\n",
+    "\n",
+    "s.O2 = Resource(sell=[20, True], basis='tons', label='Oxygen')\n",
+    "\n",
+    "\n",
+    "s.CO2_DAC = Resource(basis='tons', label='Carbon dioxide - captured')\n",
+    "s.Power = Resource(buy=[0, a], basis='MW', label='Power generated')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.LiR = Material(\n",
+    "    use_emit={s.gwp: {s.t1: 1.484}},\n",
+    "    use={s.ponje: 1.5},\n",
+    "    basis='kg',\n",
+    "    label='Lithium Reserves',\n",
+    "    citation='Nelson Bunyui Manjong (2021)',\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -959,8 +295,8 @@
     "    produce=[(0, 3), (3, 5)],\n",
     "    capex={s.madgaon: {s.t1: {1462000, I(202233)}}},\n",
     "    opex={4953, I(70)},\n",
-    "    capacity=1000,\n",
-    "    setup_emission={s.gwp: 50, s.odp: 2900},\n",
+    "    setup=1000,\n",
+    "    setup_emit={s.gwp: 50, s.odp: 2900},\n",
     "    setup_use={s.LiR: 1.5, s.land: 30},\n",
     "    locations=[s.madgaon, s.ponje],\n",
     "    label='Wind mill array',\n",
@@ -969,12 +305,10 @@
     "\n",
     "\n",
     "s.PV = Process(\n",
-    "    sell_price={s.Power: 30},\n",
-    "    credit={s.Power: DataFrame({'a': [2]})},\n",
     "    conversion={s.Power: {X(1): {s.Solar: -1.2}, X(2): {s.Solar: -1.5}}},\n",
     "    capex={X(0): 1333, X(1): 1444, X(2): 1555},\n",
     "    opex=22623,\n",
-    "    capacity={X(0): 3000, X(1): 4000, X(2): 5000},\n",
+    "    setup={X(0): 3000, X(1): 4000, X(2): 5000},\n",
     "    locations=s.cacoda,\n",
     "    label='Solar PV',\n",
     "    basis='MW',\n",
@@ -996,12 +330,11 @@
     "        2520000,\n",
     "    },\n",
     "    opex={51.5, I(945000)},\n",
-    "    capacity=[1000],\n",
+    "    setup=[1000],\n",
     "    label='Steam methane reforming + CCUS',\n",
     ")\n",
     "\n",
     "s.NGCC = Process(\n",
-    "    buy_price={s.CH4: 4, s.H2O: 20},\n",
     "    conversion={\n",
     "        s.Power: {\n",
     "            s.CH4: -0.108,\n",
@@ -1012,39 +345,36 @@
     "    },\n",
     "    capex=2158928,\n",
     "    opex={4090, I(53320)},\n",
-    "    capacity=[1, 100],\n",
+    "    setup=[1, 100],\n",
     "    label='NGCC + 95% CC',\n",
     ")\n",
     "s.SMR = Process(\n",
     "    capex=2400,\n",
     "    opex={0.03, I(800)},\n",
     "    conversion={s.H2: {s.Power: -1.11, s.CH4: -3.76, s.H2O: -23.7, s.CO2_Vent: 9.4979}},\n",
-    "    capacity=1000,\n",
+    "    setup=1000,\n",
     "    label='Steam methane reforming',\n",
     ")\n",
     "s.H2FC = Process(\n",
-    "    buy_price={s.H2: 2},\n",
-    "    sell={s.Power: 20},\n",
     "    conversion={s.Power: {s.H2: -0.050}},\n",
     "    capex=1.6 * 10**6,\n",
     "    opex=3.5,\n",
-    "    capacity=[1000, 2000],\n",
+    "    setup=[1000, 2000],\n",
     "    label='hydrogen fuel cell',\n",
     ")\n",
     "s.DAC = Process(\n",
     "    capex=0.02536,\n",
     "    opex=0.634,\n",
     "    conversion={s.CO2_DAC: {s.Power: -0.193, s.H2O: -4.048}},\n",
-    "    capacity=1000,\n",
+    "    setup=1000,\n",
     "    label='Direct air capture',\n",
     ")\n",
     "# s.PSH = Process(conversion = {s.Power: 0.6}, capex = 3924781, fopex= 17820, vopex = 512.5, store = 10000, capacity=1000, label='Pumped storage hydropower', basis = 'MW')\n",
     "s.ASMR = Process(\n",
-    "    buy={s.Uranium: 40},\n",
     "    conversion={s.Power: {s.Uranium: -4.17 * 10 ** (-5), s.H2O: -3.364}},\n",
     "    capex=7988951,\n",
     "    opex=I(0.04 * 0.730),\n",
-    "    capacity=1000,\n",
+    "    setup=1000,\n",
     "    label='Small modular reactors (SMRs)',\n",
     "    locations=s.madgaon,\n",
     ")\n",
@@ -1053,7 +383,7 @@
     "    conversion={s.H2: {s.Power: -1, s.O2: 0.7632, s.H2O: -0.1753}},\n",
     "    capex={1.1 * 10**6, I(20)},\n",
     "    opex=I(16918),\n",
-    "    capacity=True,\n",
+    "    setup=True,\n",
     "    label='Alkaline water electrolysis (AWE)',\n",
     "    citation='Demirhan et al. 2018 AIChE paper',\n",
     ")"
@@ -1061,190 +391,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'attr': 'capex',\n",
-       " 'root': [energiapy.components.operation.process.Process,\n",
-       "  energiapy.components.operation.storage.Storage,\n",
-       "  energiapy.components.operation.transit.Transit],\n",
-       " 'other': [],\n",
-       " 'var': energiapy.elements.variables.transact.TransactStp,\n",
-       " 'var_i': energiapy.elements.variables.transact.TransactStpI,\n",
-       " 'name': 'Task|capex|',\n",
-       " 'values': [{202233[csh, WF, madgaon, t1], 1462000[csh, WF, madgaon, t1]},\n",
-       "  1555[csh, PV, cacoda, t0],\n",
-       "  1555[csh, PV, madgaon, t0],\n",
-       "  1555[csh, PV, ponje, t0],\n",
-       "  {2520000[csh, SMRH, cacoda, t0]},\n",
-       "  {2520000[csh, SMRH, madgaon, t0]},\n",
-       "  {2520000[csh, SMRH, ponje, t0]},\n",
-       "  2158928[csh, NGCC, cacoda, t0],\n",
-       "  2158928[csh, NGCC, madgaon, t0],\n",
-       "  2158928[csh, NGCC, ponje, t0],\n",
-       "  2400[csh, SMR, cacoda, t0],\n",
-       "  2400[csh, SMR, madgaon, t0],\n",
-       "  2400[csh, SMR, ponje, t0],\n",
-       "  1600000.0[csh, H2FC, cacoda, t0],\n",
-       "  1600000.0[csh, H2FC, madgaon, t0],\n",
-       "  1600000.0[csh, H2FC, ponje, t0],\n",
-       "  0.02536[csh, DAC, cacoda, t0],\n",
-       "  0.02536[csh, DAC, madgaon, t0],\n",
-       "  0.02536[csh, DAC, ponje, t0],\n",
-       "  7988951[csh, ASMR, cacoda, t0],\n",
-       "  7988951[csh, ASMR, madgaon, t0],\n",
-       "  7988951[csh, ASMR, ponje, t0],\n",
-       "  {20[csh, AWE, cacoda, t0], 1100000.0[csh, AWE, cacoda, t0]},\n",
-       "  {20[csh, AWE, madgaon, t0], 1100000.0[csh, AWE, madgaon, t0]},\n",
-       "  {20[csh, AWE, ponje, t0], 1100000.0[csh, AWE, ponje, t0]}],\n",
-       " 'parameters': [Capex[csh, WF, madgaon, t1],\n",
-       "  Capex^i[csh, WF, madgaon, t1],\n",
-       "  Capex[csh, PV, cacoda, t0],\n",
-       "  Capex[csh, PV, madgaon, t0],\n",
-       "  Capex[csh, PV, ponje, t0],\n",
-       "  Capex[csh, SMRH, cacoda, t0],\n",
-       "  Capex[csh, SMRH, madgaon, t0],\n",
-       "  Capex[csh, SMRH, ponje, t0],\n",
-       "  Capex[csh, NGCC, cacoda, t0],\n",
-       "  Capex[csh, NGCC, madgaon, t0],\n",
-       "  Capex[csh, NGCC, ponje, t0],\n",
-       "  Capex[csh, SMR, cacoda, t0],\n",
-       "  Capex[csh, SMR, madgaon, t0],\n",
-       "  Capex[csh, SMR, ponje, t0],\n",
-       "  Capex[csh, H2FC, cacoda, t0],\n",
-       "  Capex[csh, H2FC, madgaon, t0],\n",
-       "  Capex[csh, H2FC, ponje, t0],\n",
-       "  Capex[csh, DAC, cacoda, t0],\n",
-       "  Capex[csh, DAC, madgaon, t0],\n",
-       "  Capex[csh, DAC, ponje, t0],\n",
-       "  Capex[csh, ASMR, cacoda, t0],\n",
-       "  Capex[csh, ASMR, madgaon, t0],\n",
-       "  Capex[csh, ASMR, ponje, t0],\n",
-       "  Capex^i[csh, AWE, cacoda, t0],\n",
-       "  Capex[csh, AWE, cacoda, t0],\n",
-       "  Capex^i[csh, AWE, madgaon, t0],\n",
-       "  Capex[csh, AWE, madgaon, t0],\n",
-       "  Capex[csh, AWE, ponje, t0],\n",
-       "  Capex^i[csh, AWE, ponje, t0]],\n",
-       " 'constraints': [Calculate[csh, WF, madgaon, t1],\n",
-       "  Calculate[csh, WF, madgaon, t1],\n",
-       "  Calculate[csh, PV, cacoda, t0],\n",
-       "  Calculate[csh, PV, madgaon, t0],\n",
-       "  Calculate[csh, PV, ponje, t0],\n",
-       "  Calculate[csh, SMRH, cacoda, t0],\n",
-       "  Calculate[csh, SMRH, madgaon, t0],\n",
-       "  Calculate[csh, SMRH, ponje, t0],\n",
-       "  Calculate[csh, NGCC, cacoda, t0],\n",
-       "  Calculate[csh, NGCC, madgaon, t0],\n",
-       "  Calculate[csh, NGCC, ponje, t0],\n",
-       "  Calculate[csh, SMR, cacoda, t0],\n",
-       "  Calculate[csh, SMR, madgaon, t0],\n",
-       "  Calculate[csh, SMR, ponje, t0],\n",
-       "  Calculate[csh, H2FC, cacoda, t0],\n",
-       "  Calculate[csh, H2FC, madgaon, t0],\n",
-       "  Calculate[csh, H2FC, ponje, t0],\n",
-       "  Calculate[csh, DAC, cacoda, t0],\n",
-       "  Calculate[csh, DAC, madgaon, t0],\n",
-       "  Calculate[csh, DAC, ponje, t0],\n",
-       "  Calculate[csh, ASMR, cacoda, t0],\n",
-       "  Calculate[csh, ASMR, madgaon, t0],\n",
-       "  Calculate[csh, ASMR, ponje, t0],\n",
-       "  Calculate[csh, AWE, cacoda, t0],\n",
-       "  Calculate[csh, AWE, cacoda, t0],\n",
-       "  Calculate[csh, AWE, madgaon, t0],\n",
-       "  Calculate[csh, AWE, madgaon, t0],\n",
-       "  Calculate[csh, AWE, ponje, t0],\n",
-       "  Calculate[csh, AWE, ponje, t0]],\n",
-       " 'variables': [capex[csh, WF, madgaon, t1],\n",
-       "  capacity[WF, madgaon, t1],\n",
-       "  capex^I[csh, WF, madgaon, t1],\n",
-       "  capex[csh, PV, cacoda, t0],\n",
-       "  capacity[PV, cacoda, t0],\n",
-       "  capex[csh, PV, madgaon, t0],\n",
-       "  capacity[PV, madgaon, t0],\n",
-       "  capex[csh, PV, ponje, t0],\n",
-       "  capacity[PV, ponje, t0],\n",
-       "  capex[csh, SMRH, cacoda, t0],\n",
-       "  capex[csh, SMRH, madgaon, t0],\n",
-       "  capex[csh, SMRH, ponje, t0],\n",
-       "  capex[csh, NGCC, cacoda, t0],\n",
-       "  capacity[NGCC, cacoda, t0],\n",
-       "  capex[csh, NGCC, madgaon, t0],\n",
-       "  capacity[NGCC, madgaon, t0],\n",
-       "  capex[csh, NGCC, ponje, t0],\n",
-       "  capacity[NGCC, ponje, t0],\n",
-       "  capex[csh, SMR, cacoda, t0],\n",
-       "  capacity[SMR, cacoda, t0],\n",
-       "  capex[csh, SMR, madgaon, t0],\n",
-       "  capacity[SMR, madgaon, t0],\n",
-       "  capex[csh, SMR, ponje, t0],\n",
-       "  capacity[SMR, ponje, t0],\n",
-       "  capex[csh, H2FC, cacoda, t0],\n",
-       "  capacity[H2FC, cacoda, t0],\n",
-       "  capex[csh, H2FC, madgaon, t0],\n",
-       "  capacity[H2FC, madgaon, t0],\n",
-       "  capex[csh, H2FC, ponje, t0],\n",
-       "  capacity[H2FC, ponje, t0],\n",
-       "  capex[csh, DAC, cacoda, t0],\n",
-       "  capacity[DAC, cacoda, t0],\n",
-       "  capex[csh, DAC, madgaon, t0],\n",
-       "  capacity[DAC, madgaon, t0],\n",
-       "  capex[csh, DAC, ponje, t0],\n",
-       "  capacity[DAC, ponje, t0],\n",
-       "  capex[csh, ASMR, cacoda, t0],\n",
-       "  capacity[ASMR, cacoda, t0],\n",
-       "  capex[csh, ASMR, madgaon, t0],\n",
-       "  capacity[ASMR, madgaon, t0],\n",
-       "  capex[csh, ASMR, ponje, t0],\n",
-       "  capacity[ASMR, ponje, t0],\n",
-       "  capex^I[csh, AWE, cacoda, t0],\n",
-       "  capex[csh, AWE, cacoda, t0],\n",
-       "  capex^I[csh, AWE, madgaon, t0],\n",
-       "  capex[csh, AWE, madgaon, t0],\n",
-       "  capex[csh, AWE, ponje, t0],\n",
-       "  capex^I[csh, AWE, ponje, t0]],\n",
-       " 'indices': [(WF, madgaon, t1),\n",
-       "  (PV, cacoda, t0),\n",
-       "  (PV, madgaon, t0),\n",
-       "  (PV, ponje, t0),\n",
-       "  (SMRH, cacoda, t0),\n",
-       "  (SMRH, madgaon, t0),\n",
-       "  (SMRH, ponje, t0),\n",
-       "  (NGCC, cacoda, t0),\n",
-       "  (NGCC, madgaon, t0),\n",
-       "  (NGCC, ponje, t0),\n",
-       "  (SMR, cacoda, t0),\n",
-       "  (SMR, madgaon, t0),\n",
-       "  (SMR, ponje, t0),\n",
-       "  (H2FC, cacoda, t0),\n",
-       "  (H2FC, madgaon, t0),\n",
-       "  (H2FC, ponje, t0),\n",
-       "  (DAC, cacoda, t0),\n",
-       "  (DAC, madgaon, t0),\n",
-       "  (DAC, ponje, t0),\n",
-       "  (ASMR, cacoda, t0),\n",
-       "  (ASMR, madgaon, t0),\n",
-       "  (ASMR, ponje, t0),\n",
-       "  (AWE, cacoda, t0),\n",
-       "  (AWE, madgaon, t0),\n",
-       "  (AWE, ponje, t0)]}"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "getattr(s.AWE.taskmaster, 'capex').__dict__"
+    "s.LiI = Storage(setup=[2000], inventory=s.Power, setup_in=[40], setup_out=[20])\n",
+    "s.LiI2 = Storage(setup=[2000], inventory={s.Power: 0.6})\n",
+    "s.H2Stg = Storage(\n",
+    "    setup=[2000], inventory={s.H2: {X(0): {s.Power: 0.8}, X(1): {s.Power: 0.9}}}\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -1274,7 +434,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {spend}_{csh,ponje,t_{1}} = {θ}_{csh,ponje,t_{1}}$"
+       "$\\displaystyle {spend}_{csh,ponje,t_{0}} = {θ}_{csh,ponje,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1286,7 +446,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {spend}_{csh,cacoda,t_{1}} = {DtSt}_{csh,cacoda,t_{1}}$"
+       "$\\displaystyle {spend}_{csh,cacoda,t_{0}} = {DtSt}_{csh,cacoda,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1298,7 +458,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {spend}_{csh,net,t_{2}} \\geq 5$"
+       "$\\displaystyle {spend}_{csh,net,t_{1}} \\geq 5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1310,7 +470,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {spend}_{csh,net,t_{2}} \\leq 7$"
+       "$\\displaystyle {spend}_{csh,net,t_{1}} \\leq 7$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1322,7 +482,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},cacoda,t_{0}} = {sell}_{H_{2},cacoda,t_{0}} \\cdot 300$"
+       "$\\displaystyle {exp^{sell}}_{csh,H_{2},madgaon,t_{0}} = {sell}_{H_{2},madgaon,t_{0}} \\cdot {θ}_{csh,H_{2},madgaon,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1334,7 +494,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},madgaon,t_{1}} = {sell}_{H_{2},madgaon,t_{1}} \\cdot {θ}_{csh,H_{2},madgaon,t_{1}}$"
+       "$\\displaystyle {exp^{sell}}_{csh,H_{2},cacoda,t_{0}} = {sell}_{H_{2},cacoda,t_{0}} \\cdot 300$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1346,7 +506,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,H_{2},ponje,t_{2}} = {sell}_{H_{2},ponje,t_{2}} \\cdot {θ}_{csh,H_{2},ponje,t_{2}}$"
+       "$\\displaystyle {exp^{sell}}_{csh,H_{2},ponje,t_{1}} = {sell}_{H_{2},ponje,t_{1}} \\cdot {θ}_{csh,H_{2},ponje,t_{1}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1382,7 +542,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {buy}_{Wind,net,t_{1}} = {DtSt}_{Wind,net,t_{1}}$"
+       "$\\displaystyle {buy}_{Wind,net,t_{0}} = {DtSt}_{Wind,net,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1394,7 +554,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {buy}_{Power,net,t_{1}} \\geq 0$"
+       "$\\displaystyle {buy}_{Power,net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1406,7 +566,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {buy}_{Power,net,t_{1}} \\leq {DtSt^{max}}_{Power,net,t_{1}}$"
+       "$\\displaystyle {buy}_{Power,net,t_{0}} \\leq {DtSt^{max}}_{Power,net,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1418,7 +578,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {buy}_{Uranium,net,t_{2}} = {DtSt}_{Uranium,net,t_{2}}$"
+       "$\\displaystyle {buy}_{Uranium,net,t_{1}} = {DtSt}_{Uranium,net,t_{1}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1430,7 +590,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,Uranium,cacoda,t_{0}} = {buy}_{Uranium,cacoda,t_{0}} \\cdot 0.3416$"
+       "$\\displaystyle {exp^{buy}}_{csh,Uranium,madgaon,t_{0}} = {buy}_{Uranium,madgaon,t_{0}} \\cdot 0.3416$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1442,7 +602,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,Uranium,madgaon,t_{0}} = {buy}_{Uranium,madgaon,t_{0}} \\cdot 0.3416$"
+       "$\\displaystyle {exp^{buy}}_{csh,Uranium,ponje,t_{0}} = {buy}_{Uranium,ponje,t_{0}} \\cdot 0.3416$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1454,7 +614,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,Uranium,ponje,t_{0}} = {buy}_{Uranium,ponje,t_{0}} \\cdot 0.3416$"
+       "$\\displaystyle {exp^{buy}}_{csh,Uranium,cacoda,t_{0}} = {buy}_{Uranium,cacoda,t_{0}} \\cdot 0.3416$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1478,7 +638,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,cacoda,t_{2}} = {DtSt}_{csh,H2O,cacoda,t_{2}} \\cdot {buy}_{H2O,cacoda,t_{2}}$"
+       "$\\displaystyle {exp^{buy}}_{csh,H2O,madgaon,t_{1}} = {DtSt}_{csh,H2O,madgaon,t_{1}} \\cdot {buy}_{H2O,madgaon,t_{1}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1490,7 +650,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,madgaon,t_{2}} = {DtSt}_{csh,H2O,madgaon,t_{2}} \\cdot {buy}_{H2O,madgaon,t_{2}}$"
+       "$\\displaystyle {exp^{buy}}_{csh,H2O,ponje,t_{1}} = {DtSt}_{csh,H2O,ponje,t_{1}} \\cdot {buy}_{H2O,ponje,t_{1}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1502,7 +662,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,ponje,t_{2}} = {DtSt}_{csh,H2O,ponje,t_{2}} \\cdot {buy}_{H2O,ponje,t_{2}}$"
+       "$\\displaystyle {exp^{buy}}_{csh,H2O,cacoda,t_{1}} = {DtSt}_{csh,H2O,cacoda,t_{1}} \\cdot {buy}_{H2O,cacoda,t_{1}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1535,6 +695,30 @@
      "metadata": {},
      "output_type": "display_data"
     },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},madgaon,t_{0}} = {buy}_{CH_{4},madgaon,t_{0}} \\cdot 20$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},ponje,t_{0}} = {buy}_{CH_{4},ponje,t_{0}} \\cdot 20$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
     {
      "data": {
       "text/latex": [
@@ -1550,7 +734,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},madgaon,t_{0}} = {buy}_{CH_{4},madgaon,t_{0}} \\cdot 20$"
+       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},madgaon,t_{0}} = {sell}_{CO_{2 Vent},madgaon,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},madgaon,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1562,7 +746,67 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},ponje,t_{0}} = {buy}_{CH_{4},ponje,t_{0}} \\cdot 20$"
+       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},ponje,t_{0}} = {sell}_{CO_{2 Vent},ponje,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},ponje,t_{0}}$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},cacoda,t_{0}} = {sell}_{CO_{2 Vent},cacoda,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},cacoda,t_{0}}$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},madgaon,t_{1}} = {DtSt}_{gwp,CO_{2 Vent},madgaon,t_{1}} \\cdot {sell}_{CO_{2 Vent},madgaon,t_{1}}$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},ponje,t_{1}} = {DtSt}_{gwp,CO_{2 Vent},ponje,t_{1}} \\cdot {sell}_{CO_{2 Vent},ponje,t_{1}}$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},cacoda,t_{1}} = {DtSt}_{gwp,CO_{2 Vent},cacoda,t_{1}} \\cdot {sell}_{CO_{2 Vent},cacoda,t_{1}}$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Math object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle {sell}_{O_{2},net,t_{0}} \\geq 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1574,7 +818,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},cacoda,t_{0}} = {sell}_{CO_{2 Vent},cacoda,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},cacoda,t_{0}}$"
+       "$\\displaystyle {sell}_{O_{2},net,t_{0}} \\leq M$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1586,7 +830,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},madgaon,t_{0}} = {sell}_{CO_{2 Vent},madgaon,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},madgaon,t_{0}}$"
+       "$\\displaystyle {use}_{LiR,ponje,t_{0}} = 1.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1598,7 +842,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,CO_{2 Vent},ponje,t_{0}} = {sell}_{CO_{2 Vent},ponje,t_{0}} \\cdot {θ}_{csh,CO_{2 Vent},ponje,t_{0}}$"
+       "$\\displaystyle {emit^{use}}_{gwp,LiR,madgaon,t_{0}} = {use}_{LiR,madgaon,t_{0}} \\cdot 1.484$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1610,7 +854,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},cacoda,t_{2}} = {DtSt}_{gwp,CO_{2 Vent},cacoda,t_{2}} \\cdot {sell}_{CO_{2 Vent},cacoda,t_{2}}$"
+       "$\\displaystyle {emit^{use}}_{gwp,LiR,ponje,t_{0}} = {use}_{LiR,ponje,t_{0}} \\cdot 1.484$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1622,7 +866,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},madgaon,t_{2}} = {DtSt}_{gwp,CO_{2 Vent},madgaon,t_{2}} \\cdot {sell}_{CO_{2 Vent},madgaon,t_{2}}$"
+       "$\\displaystyle {emit^{use}}_{gwp,LiR,cacoda,t_{0}} = {use}_{LiR,cacoda,t_{0}} \\cdot 1.484$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1634,7 +878,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{sell}}_{gwp,CO_{2 Vent},ponje,t_{2}} = {DtSt}_{gwp,CO_{2 Vent},ponje,t_{2}} \\cdot {sell}_{CO_{2 Vent},ponje,t_{2}}$"
+       "$\\displaystyle {capacity^{add}}_{WF,net,t_{0}} = 1000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1646,7 +890,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {sell}_{O_{2},net,t_{0}} \\geq 20$"
+       "$\\displaystyle {produce}_{WF,net,t_{0}} \\geq {capacity^{add}}_{net,t_{0}} \\cdot {θ^{min}}_{WF,net,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1658,7 +902,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {sell}_{O_{2},net,t_{0}} \\leq M$"
+       "$\\displaystyle {produce}_{WF,net,t_{0}} \\leq {capacity^{add}}_{net,t_{0}} \\cdot {θ^{max}}_{WF,net,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1670,7 +914,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use}_{LiR,ponje,t_{0}} = 1.5$"
+       "$\\displaystyle {use^{setup}}_{LiR,WF,madgaon,t_{0}} = {capacity^{add}}_{WF,madgaon,t_{0}} \\cdot 1.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1682,7 +926,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{use}}_{gwp,LiR,cacoda,t_{0}} = {use}_{LiR,cacoda,t_{0}} \\cdot 1.484$"
+       "$\\displaystyle {use^{setup}}_{LiR,WF,ponje,t_{0}} = {capacity^{add}}_{WF,ponje,t_{0}} \\cdot 1.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1694,7 +938,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{use}}_{gwp,LiR,madgaon,t_{0}} = {use}_{LiR,madgaon,t_{0}} \\cdot 1.484$"
+       "$\\displaystyle {use^{setup}}_{LiR,WF,cacoda,t_{0}} = {capacity^{add}}_{WF,cacoda,t_{0}} \\cdot 1.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1706,7 +950,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{use}}_{gwp,LiR,ponje,t_{0}} = {use}_{LiR,ponje,t_{0}} \\cdot 1.484$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},WF,madgaon,t_{0}} = {capacity^{add}}_{WF,madgaon,t_{0}} \\cdot 30$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1718,7 +962,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{LiR,WF,cacoda,t_{0}} = {capacity}_{WF,cacoda,t_{0}} \\cdot 1.5$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},WF,ponje,t_{0}} = {capacity^{add}}_{WF,ponje,t_{0}} \\cdot 30$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1730,7 +974,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{LiR,WF,madgaon,t_{0}} = {capacity}_{WF,madgaon,t_{0}} \\cdot 1.5$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},WF,cacoda,t_{0}} = {capacity^{add}}_{WF,cacoda,t_{0}} \\cdot 30$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1742,7 +986,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{LiR,WF,ponje,t_{0}} = {capacity}_{WF,ponje,t_{0}} \\cdot 1.5$"
+       "$\\displaystyle {emit^{setup}}_{gwp,WF,madgaon,t_{0}} = {capacity^{add}}_{WF,madgaon,t_{0}} \\cdot 50$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1754,7 +998,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},WF,cacoda,t_{0}} = {capacity}_{WF,cacoda,t_{0}} \\cdot 30$"
+       "$\\displaystyle {emit^{setup}}_{gwp,WF,ponje,t_{0}} = {capacity^{add}}_{WF,ponje,t_{0}} \\cdot 50$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1766,7 +1010,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},WF,madgaon,t_{0}} = {capacity}_{WF,madgaon,t_{0}} \\cdot 30$"
+       "$\\displaystyle {emit^{setup}}_{gwp,WF,cacoda,t_{0}} = {capacity^{add}}_{WF,cacoda,t_{0}} \\cdot 50$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1778,7 +1022,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},WF,ponje,t_{0}} = {capacity}_{WF,ponje,t_{0}} \\cdot 30$"
+       "$\\displaystyle {emit^{setup}}_{odp,WF,madgaon,t_{0}} = {capacity^{add}}_{WF,madgaon,t_{0}} \\cdot 2900$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1790,7 +1034,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{setup}}_{gwp,WF,cacoda,t_{0}} = {capacity}_{WF,cacoda,t_{0}} \\cdot 50$"
+       "$\\displaystyle {emit^{setup}}_{odp,WF,ponje,t_{0}} = {capacity^{add}}_{WF,ponje,t_{0}} \\cdot 2900$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1802,7 +1046,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{setup}}_{gwp,WF,madgaon,t_{0}} = {capacity}_{WF,madgaon,t_{0}} \\cdot 50$"
+       "$\\displaystyle {emit^{setup}}_{odp,WF,cacoda,t_{0}} = {capacity^{add}}_{WF,cacoda,t_{0}} \\cdot 2900$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1814,7 +1058,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{setup}}_{gwp,WF,ponje,t_{0}} = {capacity}_{WF,ponje,t_{0}} \\cdot 50$"
+       "$\\displaystyle {exp^{capex}}_{csh,WF,madgaon,t_{1}} = {capacity^{add}}_{WF,madgaon,t_{1}} \\cdot 1462000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1826,7 +1070,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{setup}}_{odp,WF,cacoda,t_{0}} = {capacity}_{WF,cacoda,t_{0}} \\cdot 2900$"
+       "$\\displaystyle {exp^{capex}}_{csh,WF,madgaon,t_{1}} = {capacity^{add}}_{WF,madgaon,t_{1}} \\cdot 202233$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1838,7 +1082,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{setup}}_{odp,WF,madgaon,t_{0}} = {capacity}_{WF,madgaon,t_{0}} \\cdot 2900$"
+       "$\\displaystyle {exp^{opex}}_{csh,WF,madgaon,t_{0}} = {produce}_{WF,madgaon,t_{0}} \\cdot 70$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1850,7 +1094,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {emit^{setup}}_{odp,WF,ponje,t_{0}} = {capacity}_{WF,ponje,t_{0}} \\cdot 2900$"
+       "$\\displaystyle {exp^{opex}}_{csh,WF,madgaon,t_{0}} = {produce}_{WF,madgaon,t_{0}} \\cdot 4953$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1862,7 +1106,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,WF,madgaon,t_{1}} = {capacity}_{WF,madgaon,t_{1}} \\cdot 1462000$"
+       "$\\displaystyle {exp^{opex}}_{csh,WF,ponje,t_{0}} = {produce}_{WF,ponje,t_{0}} \\cdot 70$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1874,7 +1118,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex^{I}}_{csh,WF,madgaon,t_{1}} = 202233$"
+       "$\\displaystyle {exp^{opex}}_{csh,WF,ponje,t_{0}} = {produce}_{WF,ponje,t_{0}} \\cdot 4953$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1886,7 +1130,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,WF,cacoda,t_{0}} = {operate}_{WF,cacoda,t_{0}} \\cdot 4953$"
+       "$\\displaystyle {exp^{opex}}_{csh,WF,cacoda,t_{0}} = {produce}_{WF,cacoda,t_{0}} \\cdot 4953$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1898,7 +1142,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,WF,cacoda,t_{0}} = 70$"
+       "$\\displaystyle {exp^{opex}}_{csh,WF,cacoda,t_{0}} = {produce}_{WF,cacoda,t_{0}} \\cdot 70$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1910,7 +1154,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,WF,madgaon,t_{0}} = {operate}_{WF,madgaon,t_{0}} \\cdot 4953$"
+       "$\\displaystyle {capacity^{add}}_{PV,net,t_{0}} = 5000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1922,7 +1166,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,WF,madgaon,t_{0}} = 70$"
+       "$\\displaystyle {exp^{capex}}_{csh,PV,madgaon,t_{0}} = {capacity^{add}}_{PV,madgaon,t_{0}} \\cdot 1555$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1934,7 +1178,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,WF,ponje,t_{0}} = 70$"
+       "$\\displaystyle {exp^{capex}}_{csh,PV,ponje,t_{0}} = {capacity^{add}}_{PV,ponje,t_{0}} \\cdot 1555$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1946,7 +1190,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,WF,ponje,t_{0}} = {operate}_{WF,ponje,t_{0}} \\cdot 4953$"
+       "$\\displaystyle {exp^{capex}}_{csh,PV,cacoda,t_{0}} = {capacity^{add}}_{PV,cacoda,t_{0}} \\cdot 1555$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1958,7 +1202,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {operate}_{WF,net,t_{0}} \\geq {capacity}_{WF,net,t_{0}} \\cdot {θ^{min}}_{WF,net,t_{0}}$"
+       "$\\displaystyle {exp^{capex}}_{csh,PV,madgaon,t_{0}} = {produce}_{PV,madgaon,t_{0}} \\cdot 22623$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1970,7 +1214,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {operate}_{WF,net,t_{0}} \\leq {capacity}_{WF,net,t_{0}} \\cdot {θ^{max}}_{WF,net,t_{0}}$"
+       "$\\displaystyle {exp^{capex}}_{csh,PV,ponje,t_{0}} = {produce}_{PV,ponje,t_{0}} \\cdot 22623$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1982,7 +1226,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{WF,net,t_{0}} = 1000$"
+       "$\\displaystyle {exp^{capex}}_{csh,PV,cacoda,t_{0}} = {produce}_{PV,cacoda,t_{0}} \\cdot 22623$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -1994,7 +1238,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,PV,cacoda,t_{0}} = {capacity}_{PV,cacoda,t_{0}} \\cdot 1555$"
+       "$\\displaystyle {capacity^{add}}_{SMRH,net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2006,7 +1250,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,PV,madgaon,t_{0}} = {capacity}_{PV,madgaon,t_{0}} \\cdot 1555$"
+       "$\\displaystyle {capacity^{add}}_{SMRH,net,t_{0}} \\leq 1000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2018,7 +1262,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,PV,ponje,t_{0}} = {capacity}_{PV,ponje,t_{0}} \\cdot 1555$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},SMRH,madgaon,t_{0}} = {capacity^{add}}_{SMRH,madgaon,t_{0}} \\cdot 50$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2030,7 +1274,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,PV,cacoda,t_{0}} = {operate}_{PV,cacoda,t_{0}} \\cdot 22623$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},SMRH,ponje,t_{0}} = {capacity^{add}}_{SMRH,ponje,t_{0}} \\cdot 50$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2042,7 +1286,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,PV,madgaon,t_{0}} = {operate}_{PV,madgaon,t_{0}} \\cdot 22623$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},SMRH,cacoda,t_{0}} = {capacity^{add}}_{SMRH,cacoda,t_{0}} \\cdot 50$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2054,7 +1298,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,PV,ponje,t_{0}} = {operate}_{PV,ponje,t_{0}} \\cdot 22623$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,madgaon,t_{0}} = {capacity^{add}}_{SMRH,madgaon,t_{0}} \\cdot 2520000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2066,7 +1310,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{PV,net,t_{0}} = 5000$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,ponje,t_{0}} = {capacity^{add}}_{SMRH,ponje,t_{0}} \\cdot 2520000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2078,7 +1322,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,Power,PV,cacoda,t_{0}} = {sell}_{Power,PV,cacoda,t_{0}} \\cdot 30$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,cacoda,t_{0}} = {capacity^{add}}_{SMRH,cacoda,t_{0}} \\cdot 2520000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2090,7 +1334,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,Power,PV,madgaon,t_{0}} = {sell}_{Power,PV,madgaon,t_{0}} \\cdot 30$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,madgaon,t_{0}} = {produce}_{SMRH,madgaon,t_{0}} \\cdot 945000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2102,7 +1346,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{sell}}_{csh,Power,PV,ponje,t_{0}} = {sell}_{Power,PV,ponje,t_{0}} \\cdot 30$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,madgaon,t_{0}} = {produce}_{SMRH,madgaon,t_{0}} \\cdot 51.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2114,7 +1358,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {credit}_{csh,Power,PV,cacoda,t_{0}} = {DtSt}_{csh,Power,PV,cacoda,t_{0}} \\cdot {sell}_{Power,PV,cacoda,t_{0}}$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,ponje,t_{0}} = {produce}_{SMRH,ponje,t_{0}} \\cdot 51.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2126,7 +1370,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {credit}_{csh,Power,PV,madgaon,t_{0}} = {DtSt}_{csh,Power,PV,madgaon,t_{0}} \\cdot {sell}_{Power,PV,madgaon,t_{0}}$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,ponje,t_{0}} = {produce}_{SMRH,ponje,t_{0}} \\cdot 945000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2138,7 +1382,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {credit}_{csh,Power,PV,ponje,t_{0}} = {DtSt}_{csh,Power,PV,ponje,t_{0}} \\cdot {sell}_{Power,PV,ponje,t_{0}}$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,cacoda,t_{0}} = {produce}_{SMRH,cacoda,t_{0}} \\cdot 51.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2150,7 +1394,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},SMRH,cacoda,t_{0}} = {capacity}_{SMRH,cacoda,t_{0}} \\cdot 50$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMRH,cacoda,t_{0}} = {produce}_{SMRH,cacoda,t_{0}} \\cdot 945000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2162,7 +1406,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},SMRH,madgaon,t_{0}} = {capacity}_{SMRH,madgaon,t_{0}} \\cdot 50$"
+       "$\\displaystyle {capacity^{add}}_{NGCC,net,t_{0}} \\geq 1$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2174,7 +1418,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},SMRH,ponje,t_{0}} = {capacity}_{SMRH,ponje,t_{0}} \\cdot 50$"
+       "$\\displaystyle {capacity^{add}}_{NGCC,net,t_{0}} \\leq 100$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2186,7 +1430,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,SMRH,cacoda,t_{0}} = {capacity}_{SMRH,cacoda,t_{0}} \\cdot 2520000$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,madgaon,t_{0}} = {capacity^{add}}_{NGCC,madgaon,t_{0}} \\cdot 2158928$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2198,7 +1442,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,SMRH,madgaon,t_{0}} = {capacity}_{SMRH,madgaon,t_{0}} \\cdot 2520000$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,ponje,t_{0}} = {capacity^{add}}_{NGCC,ponje,t_{0}} \\cdot 2158928$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2210,7 +1454,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,SMRH,ponje,t_{0}} = {capacity}_{SMRH,ponje,t_{0}} \\cdot 2520000$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,cacoda,t_{0}} = {capacity^{add}}_{NGCC,cacoda,t_{0}} \\cdot 2158928$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2222,7 +1466,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,SMRH,cacoda,t_{0}} = {operate}_{SMRH,cacoda,t_{0}} \\cdot 51.5$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,madgaon,t_{0}} = {produce}_{NGCC,madgaon,t_{0}} \\cdot 53320$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2234,7 +1478,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,SMRH,cacoda,t_{0}} = 945000$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,madgaon,t_{0}} = {produce}_{NGCC,madgaon,t_{0}} \\cdot 4090$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2246,7 +1490,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,SMRH,madgaon,t_{0}} = 945000$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,ponje,t_{0}} = {produce}_{NGCC,ponje,t_{0}} \\cdot 53320$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2258,7 +1502,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,SMRH,madgaon,t_{0}} = {operate}_{SMRH,madgaon,t_{0}} \\cdot 51.5$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,ponje,t_{0}} = {produce}_{NGCC,ponje,t_{0}} \\cdot 4090$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2270,7 +1514,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,SMRH,ponje,t_{0}} = 945000$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,cacoda,t_{0}} = {produce}_{NGCC,cacoda,t_{0}} \\cdot 4090$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2282,7 +1526,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,SMRH,ponje,t_{0}} = {operate}_{SMRH,ponje,t_{0}} \\cdot 51.5$"
+       "$\\displaystyle {exp^{capex}}_{csh,NGCC,cacoda,t_{0}} = {produce}_{NGCC,cacoda,t_{0}} \\cdot 53320$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2294,7 +1538,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{SMRH,net,t_{0}} \\geq 0$"
+       "$\\displaystyle {capacity^{add}}_{SMR,net,t_{0}} = 1000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2306,7 +1550,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{SMRH,net,t_{0}} \\leq 1000$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,madgaon,t_{0}} = {capacity^{add}}_{SMR,madgaon,t_{0}} \\cdot 2400$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2318,7 +1562,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,NGCC,cacoda,t_{0}} = {capacity}_{NGCC,cacoda,t_{0}} \\cdot 2158928$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,ponje,t_{0}} = {capacity^{add}}_{SMR,ponje,t_{0}} \\cdot 2400$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2330,7 +1574,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,NGCC,madgaon,t_{0}} = {capacity}_{NGCC,madgaon,t_{0}} \\cdot 2158928$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,cacoda,t_{0}} = {capacity^{add}}_{SMR,cacoda,t_{0}} \\cdot 2400$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2342,7 +1586,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,NGCC,ponje,t_{0}} = {capacity}_{NGCC,ponje,t_{0}} \\cdot 2158928$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,madgaon,t_{0}} = {produce}_{SMR,madgaon,t_{0}} \\cdot 0.03$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2354,7 +1598,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,NGCC,cacoda,t_{0}} = {operate}_{NGCC,cacoda,t_{0}} \\cdot 4090$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,madgaon,t_{0}} = {produce}_{SMR,madgaon,t_{0}} \\cdot 800$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2366,7 +1610,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,NGCC,cacoda,t_{0}} = 53320$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,ponje,t_{0}} = {produce}_{SMR,ponje,t_{0}} \\cdot 800$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2378,7 +1622,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,NGCC,madgaon,t_{0}} = {operate}_{NGCC,madgaon,t_{0}} \\cdot 4090$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,ponje,t_{0}} = {produce}_{SMR,ponje,t_{0}} \\cdot 0.03$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2390,7 +1634,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,NGCC,madgaon,t_{0}} = 53320$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,cacoda,t_{0}} = {produce}_{SMR,cacoda,t_{0}} \\cdot 0.03$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2402,7 +1646,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,NGCC,ponje,t_{0}} = {operate}_{NGCC,ponje,t_{0}} \\cdot 4090$"
+       "$\\displaystyle {exp^{capex}}_{csh,SMR,cacoda,t_{0}} = {produce}_{SMR,cacoda,t_{0}} \\cdot 800$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2414,7 +1658,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,NGCC,ponje,t_{0}} = 53320$"
+       "$\\displaystyle {capacity^{add}}_{H2FC,net,t_{0}} \\geq 1000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2426,7 +1670,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{NGCC,net,t_{0}} \\geq 1$"
+       "$\\displaystyle {capacity^{add}}_{H2FC,net,t_{0}} \\leq 2000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2438,7 +1682,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{NGCC,net,t_{0}} \\leq 100$"
+       "$\\displaystyle {exp^{capex}}_{csh,H2FC,madgaon,t_{0}} = {capacity^{add}}_{H2FC,madgaon,t_{0}} \\cdot 1600000.0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2450,7 +1694,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},NGCC,cacoda,t_{0}} = {buy}_{CH_{4},NGCC,cacoda,t_{0}} \\cdot 4$"
+       "$\\displaystyle {exp^{capex}}_{csh,H2FC,ponje,t_{0}} = {capacity^{add}}_{H2FC,ponje,t_{0}} \\cdot 1600000.0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2462,7 +1706,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},NGCC,madgaon,t_{0}} = {buy}_{CH_{4},NGCC,madgaon,t_{0}} \\cdot 4$"
+       "$\\displaystyle {exp^{capex}}_{csh,H2FC,cacoda,t_{0}} = {capacity^{add}}_{H2FC,cacoda,t_{0}} \\cdot 1600000.0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2474,7 +1718,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,CH_{4},NGCC,ponje,t_{0}} = {buy}_{CH_{4},NGCC,ponje,t_{0}} \\cdot 4$"
+       "$\\displaystyle {exp^{capex}}_{csh,H2FC,madgaon,t_{0}} = {produce}_{H2FC,madgaon,t_{0}} \\cdot 3.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2486,7 +1730,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,NGCC,cacoda,t_{0}} = {buy}_{H2O,NGCC,cacoda,t_{0}} \\cdot 20$"
+       "$\\displaystyle {exp^{capex}}_{csh,H2FC,ponje,t_{0}} = {produce}_{H2FC,ponje,t_{0}} \\cdot 3.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2498,7 +1742,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,NGCC,madgaon,t_{0}} = {buy}_{H2O,NGCC,madgaon,t_{0}} \\cdot 20$"
+       "$\\displaystyle {exp^{capex}}_{csh,H2FC,cacoda,t_{0}} = {produce}_{H2FC,cacoda,t_{0}} \\cdot 3.5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2510,7 +1754,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H2O,NGCC,ponje,t_{0}} = {buy}_{H2O,NGCC,ponje,t_{0}} \\cdot 20$"
+       "$\\displaystyle {capacity^{add}}_{DAC,net,t_{0}} = 1000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2522,7 +1766,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,SMR,cacoda,t_{0}} = {capacity}_{SMR,cacoda,t_{0}} \\cdot 2400$"
+       "$\\displaystyle {exp^{capex}}_{csh,DAC,madgaon,t_{0}} = {capacity^{add}}_{DAC,madgaon,t_{0}} \\cdot 0.02536$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2534,7 +1778,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,SMR,madgaon,t_{0}} = {capacity}_{SMR,madgaon,t_{0}} \\cdot 2400$"
+       "$\\displaystyle {exp^{capex}}_{csh,DAC,ponje,t_{0}} = {capacity^{add}}_{DAC,ponje,t_{0}} \\cdot 0.02536$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2546,7 +1790,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,SMR,ponje,t_{0}} = {capacity}_{SMR,ponje,t_{0}} \\cdot 2400$"
+       "$\\displaystyle {exp^{capex}}_{csh,DAC,cacoda,t_{0}} = {capacity^{add}}_{DAC,cacoda,t_{0}} \\cdot 0.02536$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2558,7 +1802,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,SMR,cacoda,t_{0}} = 800$"
+       "$\\displaystyle {exp^{capex}}_{csh,DAC,madgaon,t_{0}} = {produce}_{DAC,madgaon,t_{0}} \\cdot 0.634$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2570,7 +1814,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,SMR,cacoda,t_{0}} = {operate}_{SMR,cacoda,t_{0}} \\cdot 0.03$"
+       "$\\displaystyle {exp^{capex}}_{csh,DAC,ponje,t_{0}} = {produce}_{DAC,ponje,t_{0}} \\cdot 0.634$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2582,7 +1826,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,SMR,madgaon,t_{0}} = {operate}_{SMR,madgaon,t_{0}} \\cdot 0.03$"
+       "$\\displaystyle {exp^{capex}}_{csh,DAC,cacoda,t_{0}} = {produce}_{DAC,cacoda,t_{0}} \\cdot 0.634$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2594,7 +1838,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,SMR,madgaon,t_{0}} = 800$"
+       "$\\displaystyle {capacity^{add}}_{ASMR,net,t_{0}} = 1000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2606,7 +1850,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,SMR,ponje,t_{0}} = 800$"
+       "$\\displaystyle {exp^{capex}}_{csh,ASMR,madgaon,t_{0}} = {capacity^{add}}_{ASMR,madgaon,t_{0}} \\cdot 7988951$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2618,7 +1862,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,SMR,ponje,t_{0}} = {operate}_{SMR,ponje,t_{0}} \\cdot 0.03$"
+       "$\\displaystyle {exp^{capex}}_{csh,ASMR,ponje,t_{0}} = {capacity^{add}}_{ASMR,ponje,t_{0}} \\cdot 7988951$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2630,7 +1874,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{SMR,net,t_{0}} = 1000$"
+       "$\\displaystyle {exp^{capex}}_{csh,ASMR,cacoda,t_{0}} = {capacity^{add}}_{ASMR,cacoda,t_{0}} \\cdot 7988951$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2642,7 +1886,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,H2FC,cacoda,t_{0}} = {capacity}_{H2FC,cacoda,t_{0}} \\cdot 1600000.0$"
+       "$\\displaystyle {exp^{capex}}_{csh,ASMR,madgaon,t_{0}} = {produce}_{ASMR,madgaon,t_{0}} \\cdot 0.0292$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2654,7 +1898,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,H2FC,madgaon,t_{0}} = {capacity}_{H2FC,madgaon,t_{0}} \\cdot 1600000.0$"
+       "$\\displaystyle {exp^{capex}}_{csh,ASMR,ponje,t_{0}} = {produce}_{ASMR,ponje,t_{0}} \\cdot 0.0292$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2666,7 +1910,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,H2FC,ponje,t_{0}} = {capacity}_{H2FC,ponje,t_{0}} \\cdot 1600000.0$"
+       "$\\displaystyle {exp^{capex}}_{csh,ASMR,cacoda,t_{0}} = {produce}_{ASMR,cacoda,t_{0}} \\cdot 0.0292$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2678,7 +1922,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,H2FC,cacoda,t_{0}} = {operate}_{H2FC,cacoda,t_{0}} \\cdot 3.5$"
+       "$\\displaystyle {capacity^{add}}_{AWE,net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2690,7 +1934,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,H2FC,madgaon,t_{0}} = {operate}_{H2FC,madgaon,t_{0}} \\cdot 3.5$"
+       "$\\displaystyle {capacity^{add}}_{AWE,net,t_{0}} \\leq M$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2702,7 +1946,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,H2FC,ponje,t_{0}} = {operate}_{H2FC,ponje,t_{0}} \\cdot 3.5$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},AWE,madgaon,t_{0}} = {capacity^{add}}_{AWE,madgaon,t_{0}} \\cdot {θ}_{lnd_{def},AWE,madgaon,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2714,7 +1958,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{H2FC,net,t_{0}} \\geq 1000$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},AWE,ponje,t_{0}} = {capacity^{add}}_{AWE,ponje,t_{0}} \\cdot {θ}_{lnd_{def},AWE,ponje,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2726,7 +1970,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{H2FC,net,t_{0}} \\leq 2000$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},AWE,cacoda,t_{0}} = {capacity^{add}}_{AWE,cacoda,t_{0}} \\cdot {θ}_{lnd_{def},AWE,cacoda,t_{0}}$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2738,7 +1982,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {sell}_{Power,H2FC,net,t_{0}} = 20$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,madgaon,t_{0}} = {capacity^{add}}_{AWE,madgaon,t_{0}} \\cdot 1100000.0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2750,7 +1994,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H_{2},H2FC,cacoda,t_{0}} = {buy}_{H_{2},H2FC,cacoda,t_{0}} \\cdot 2$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,madgaon,t_{0}} = {capacity^{add}}_{AWE,madgaon,t_{0}} \\cdot 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2762,7 +2006,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H_{2},H2FC,madgaon,t_{0}} = {buy}_{H_{2},H2FC,madgaon,t_{0}} \\cdot 2$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,ponje,t_{0}} = {capacity^{add}}_{AWE,ponje,t_{0}} \\cdot 1100000.0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2774,7 +2018,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {exp^{buy}}_{csh,H_{2},H2FC,ponje,t_{0}} = {buy}_{H_{2},H2FC,ponje,t_{0}} \\cdot 2$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,ponje,t_{0}} = {capacity^{add}}_{AWE,ponje,t_{0}} \\cdot 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2786,7 +2030,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,DAC,cacoda,t_{0}} = {capacity}_{DAC,cacoda,t_{0}} \\cdot 0.02536$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,cacoda,t_{0}} = {capacity^{add}}_{AWE,cacoda,t_{0}} \\cdot 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2798,7 +2042,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,DAC,madgaon,t_{0}} = {capacity}_{DAC,madgaon,t_{0}} \\cdot 0.02536$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,cacoda,t_{0}} = {capacity^{add}}_{AWE,cacoda,t_{0}} \\cdot 1100000.0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2810,7 +2054,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,DAC,ponje,t_{0}} = {capacity}_{DAC,ponje,t_{0}} \\cdot 0.02536$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,madgaon,t_{0}} = {produce}_{AWE,madgaon,t_{0}} \\cdot 16918$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2822,7 +2066,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,DAC,cacoda,t_{0}} = {operate}_{DAC,cacoda,t_{0}} \\cdot 0.634$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,ponje,t_{0}} = {produce}_{AWE,ponje,t_{0}} \\cdot 16918$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2834,7 +2078,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,DAC,madgaon,t_{0}} = {operate}_{DAC,madgaon,t_{0}} \\cdot 0.634$"
+       "$\\displaystyle {exp^{capex}}_{csh,AWE,cacoda,t_{0}} = {produce}_{AWE,cacoda,t_{0}} \\cdot 16918$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2846,7 +2090,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex}_{csh,DAC,ponje,t_{0}} = {operate}_{DAC,ponje,t_{0}} \\cdot 0.634$"
+       "$\\displaystyle {capacity^{add}}_{LiI,net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2858,7 +2102,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{DAC,net,t_{0}} = 1000$"
+       "$\\displaystyle {capacity^{add}}_{LiI,net,t_{0}} \\leq 2000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2870,7 +2114,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,ASMR,cacoda,t_{0}} = {capacity}_{ASMR,cacoda,t_{0}} \\cdot 7988951$"
+       "$\\displaystyle {capacity^{add}}_{LiI_{in},net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2882,7 +2126,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,ASMR,madgaon,t_{0}} = {capacity}_{ASMR,madgaon,t_{0}} \\cdot 7988951$"
+       "$\\displaystyle {capacity^{add}}_{LiI_{in},net,t_{0}} \\leq 40$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2894,7 +2138,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,ASMR,ponje,t_{0}} = {capacity}_{ASMR,ponje,t_{0}} \\cdot 7988951$"
+       "$\\displaystyle {capacity^{add}}_{LiI_{out},net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2906,7 +2150,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,ASMR,cacoda,t_{0}} = 0.0292$"
+       "$\\displaystyle {capacity^{add}}_{LiI_{out},net,t_{0}} \\leq 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2918,7 +2162,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,ASMR,madgaon,t_{0}} = 0.0292$"
+       "$\\displaystyle {capacity^{add}}_{LiI_{2},net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2930,7 +2174,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,ASMR,ponje,t_{0}} = 0.0292$"
+       "$\\displaystyle {capacity^{add}}_{LiI_{2},net,t_{0}} \\leq 2000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2942,7 +2186,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{ASMR,net,t_{0}} = 1000$"
+       "$\\displaystyle {capacity^{add}}_{H2Stg,net,t_{0}} \\geq 0$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2954,7 +2198,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {buy}_{Uranium,ASMR,net,t_{0}} = 40$"
+       "$\\displaystyle {capacity^{add}}_{H2Stg,net,t_{0}} \\leq 2000$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2962,11 +2206,85 @@
      },
      "metadata": {},
      "output_type": "display_data"
-    },
+    }
+   ],
+   "source": [
+    "s.pprint()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "170\n",
+      "170\n",
+      "170\n",
+      "\n",
+      "150\n",
+      "134\n",
+      "134\n",
+      "\n",
+      "150\n",
+      "110\n",
+      "110\n",
+      "\n",
+      "109\n",
+      "50\n",
+      "50\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(s.variables))\n",
+    "print(len(set(s.variables)))\n",
+    "print(len(set([v.name for v in s.variables])))\n",
+    "print()\n",
+    "print(len(s.parameters))\n",
+    "print(len(set(s.parameters)))\n",
+    "print(len(set([v.name for v in s.parameters])))\n",
+    "print()\n",
+    "print(len(s.constraints))\n",
+    "print(len(set(s.constraints)))\n",
+    "print(len(set([v.name for v in s.constraints])))\n",
+    "print()\n",
+    "print(len(s.indices))\n",
+    "print(len(set(s.indices)))\n",
+    "print(len(set([v.name for v in s.indices])))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.train = Transit(\n",
+    "    freight=s.H2,\n",
+    "    setup=[5, 400],\n",
+    "    setup_use={s.land: 20},\n",
+    "    setup_emit={s.odp: 0.1},\n",
+    "    capex={s.alink: 200, s.blink: 300, s.clink: 400},\n",
+    "    opex=100,\n",
+    "    label='Train',\n",
+    "    basis='passengers',\n",
+    "    linkages=[s.alink],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},AWE,cacoda,t_{0}} = {capacity}_{AWE,cacoda,t_{0}} \\cdot {θ}_{lnd_{def},AWE,cacoda,t_{0}}$"
+       "$\\displaystyle {capacity^{add}}_{train,net,t_{0}} \\geq 5$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2978,7 +2296,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},AWE,madgaon,t_{0}} = {capacity}_{AWE,madgaon,t_{0}} \\cdot {θ}_{lnd_{def},AWE,madgaon,t_{0}}$"
+       "$\\displaystyle {capacity^{add}}_{train,net,t_{0}} \\leq 400$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -2990,7 +2308,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {use^{setup}}_{lnd_{def},AWE,ponje,t_{0}} = {capacity}_{AWE,ponje,t_{0}} \\cdot {θ}_{lnd_{def},AWE,ponje,t_{0}}$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},train,madgaon,t_{0}} = {capacity^{add}}_{train,madgaon,t_{0}} \\cdot 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3002,7 +2320,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,AWE,cacoda,t_{0}} = {capacity}_{AWE,cacoda,t_{0}} \\cdot 1100000.0$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},train,ponje,t_{0}} = {capacity^{add}}_{train,ponje,t_{0}} \\cdot 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3014,7 +2332,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex^{I}}_{csh,AWE,cacoda,t_{0}} = 20$"
+       "$\\displaystyle {use^{setup}}_{lnd_{def},train,cacoda,t_{0}} = {capacity^{add}}_{train,cacoda,t_{0}} \\cdot 20$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3026,7 +2344,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,AWE,madgaon,t_{0}} = {capacity}_{AWE,madgaon,t_{0}} \\cdot 1100000.0$"
+       "$\\displaystyle {emit^{setup}}_{odp,train,madgaon,t_{0}} = {capacity^{add}}_{train,madgaon,t_{0}} \\cdot 0.1$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3038,7 +2356,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex^{I}}_{csh,AWE,madgaon,t_{0}} = 20$"
+       "$\\displaystyle {emit^{setup}}_{odp,train,ponje,t_{0}} = {capacity^{add}}_{train,ponje,t_{0}} \\cdot 0.1$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3050,7 +2368,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex^{I}}_{csh,AWE,ponje,t_{0}} = 20$"
+       "$\\displaystyle {emit^{setup}}_{odp,train,cacoda,t_{0}} = {capacity^{add}}_{train,cacoda,t_{0}} \\cdot 0.1$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3062,7 +2380,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capex}_{csh,AWE,ponje,t_{0}} = {capacity}_{AWE,ponje,t_{0}} \\cdot 1100000.0$"
+       "$\\displaystyle {exp^{capex}}_{csh,train,alink,t_{0}} = {capacity^{add}}_{train,alink,t_{0}} \\cdot 200$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3074,7 +2392,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,AWE,cacoda,t_{0}} = 16918$"
+       "$\\displaystyle {exp^{capex}}_{csh,train,blink,t_{0}} = {capacity^{add}}_{train,blink,t_{0}} \\cdot 300$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3086,7 +2404,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,AWE,madgaon,t_{0}} = 16918$"
+       "$\\displaystyle {exp^{capex}}_{csh,train,clink,t_{0}} = {capacity^{add}}_{train,clink,t_{0}} \\cdot 400$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3098,7 +2416,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {opex^{I}}_{csh,AWE,ponje,t_{0}} = 16918$"
+       "$\\displaystyle {exp^{opex}}_{csh,train,madgaon,t_{0}} = {produce}_{train,madgaon,t_{0}} \\cdot 100$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3110,7 +2428,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{AWE,net,t_{0}} \\geq 0$"
+       "$\\displaystyle {exp^{opex}}_{csh,train,ponje,t_{0}} = {produce}_{train,ponje,t_{0}} \\cdot 100$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3122,7 +2440,7 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle {capacity}_{AWE,net,t_{0}} \\leq M$"
+       "$\\displaystyle {exp^{opex}}_{csh,train,cacoda,t_{0}} = {produce}_{train,cacoda,t_{0}} \\cdot 100$"
       ],
       "text/plain": [
        "<IPython.core.display.Math object>"
@@ -3133,211 +2451,9 @@
     }
    ],
    "source": [
-    "s.pprint()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.taskmaster.exacts()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Process().inputs()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.LiI = Storage(capacity=[2000], inventory=s.Power, capacity_in=[40], capacity_out=[20])\n",
-    "s.LiI2 = Storage(capacity=[2000], inventory={s.Power: 0.6})\n",
-    "s.H2Stg = Storage(\n",
-    "    capacity=[2000], inventory={s.H2: {X(0): {s.Power: 0.8}, X(1): {s.Power: 0.9}}}\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "help(Process)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.pprint()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(len(s.variables))\n",
-    "print(len(set(s.variables)))\n",
-    "print(len(set([v.name for v in s.variables])))\n",
-    "print()\n",
-    "print(len(s.parameters))\n",
-    "print(len(set(s.parameters)))\n",
-    "print(len(set([v.name for v in s.parameters])))\n",
-    "print()\n",
-    "print(len(s.constraints))\n",
-    "print(len(set(s.constraints)))\n",
-    "print(len(set([v.name for v in s.constraints])))\n",
-    "print()\n",
-    "print(len(s.indices))\n",
-    "print(len(set(s.indices)))\n",
-    "print(len(set([v.name for v in s.indices])))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Transit()._spatials()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for block in s.program.blocks:\n",
-    "    print(block.attr_dispositions)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "is_(s.program.variables[5], s.program.variables[6])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "len(set(s.program.variables))"
+    "s.train.pprint()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.program.variables[6]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.LiI.capacity"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "getattr(s.LiI, 'capacity')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.attr.bounds()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.components"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s.train = Transit(\n",
-    "    freight=s.H2,\n",
-    "    ship={s.H2: [300]},\n",
-    "    capacity=[5, 400],\n",
-    "    setup_use={s.land: 20},\n",
-    "    setup_emission={s.odp: 0.1},\n",
-    "    capex={s.alink: 200, s.blink: 300, s.clink: 400},\n",
-    "    opex=100,\n",
-    "    label='Train',\n",
-    "    basis='passengers',\n",
-    "    linkages=[s.alink],\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/src/energiapy/components/_attrs/_birthing.py b/src/energiapy/components/_attrs/_birthing.py
index 896d732d..99929963 100644
--- a/src/energiapy/components/_attrs/_birthing.py
+++ b/src/energiapy/components/_attrs/_birthing.py
@@ -16,5 +16,5 @@ class _StgBirthing:
 
     """
 
-    capacity_in: IsBnd = field(default=None)
-    capacity_out: IsBnd = field(default=None)
+    setup_in: IsBnd = field(default=None)
+    setup_out: IsBnd = field(default=None)
diff --git a/src/energiapy/components/_attrs/_bounds.py b/src/energiapy/components/_attrs/_bounds.py
index fa63448e..62b0d089 100644
--- a/src/energiapy/components/_attrs/_bounds.py
+++ b/src/energiapy/components/_attrs/_bounds.py
@@ -2,6 +2,7 @@
 """
 
 from dataclasses import dataclass, field
+
 from ...core.isalias.inps.isinp import IsBnd
 
 
@@ -24,8 +25,8 @@ class _CshBounds:
     """Bounds for Cash
 
     Attributes:
-        spend (IsBnd): bound on spending Cash
-        earn (IsBnd): bound on earning Cash
+        spend (IsBnd): bound on spending
+        earn (IsBnd): bound on earning
 
     """
 
@@ -38,12 +39,13 @@ class _EmnBounds:
     """Bounds for Emission
 
     Attributes:
-        emit (IsBnd): bound on Emission
+        emit (IsBnd): bound on how much is discharged
+        sequester (IsBnd): bound on how much is abated
 
     """
 
     emit: IsBnd = field(default=None)
-    # abate: IsBnd = field(default=None)
+    sequester: IsBnd = field(default=None)
 
 
 @dataclass
@@ -51,48 +53,47 @@ class _UsdBounds:
     """Bounds for Land and Material (Used)
 
     Attributes:
-        use (IsBnd): bound on Use Variable
-
+        use (IsBnd): bound on how much is used
+        dispose (IsBnd): bound on how much is disposed
     """
 
     use: IsBnd = field(default=None)
-    # dispose: IsBnd = field(default=None)
+    dispose: IsBnd = field(default=None)
 
 
 @dataclass
-class _ResLocBounds:
-    """Bounds for Resources at Locations"""
+class _ResBounds:
+    """Bounds for Resources
+
+    Attributes:
+        buy (IsBnd): bound on amount bought at Location
+        sell (IsBnd): bound on amount sold at Location
+        ship (IsBnd): bound on amount shipped from Linkage
+        recieve (IsBnd): bound on amount recieved from Linkage
+        lose (IsBnd): bound on amount lost at Location or Linkage
+        recover (IsBnd): bound on amount recovered at Location or between Linkage
+    """
 
+    # Trade at Locations
     buy: IsBnd = field(default=None)
     sell: IsBnd = field(default=None)
-
-
-@dataclass
-class _ResLnkBounds:
-    """Bounds for Resources at Linkages"""
-
+    # Trade between Linkages
     ship: IsBnd = field(default=None)
-    # only for bi directional linkages
-    # receive: IsBnd = field(default=None)
+    # Lose at Location or between Linkage
+    lose: IsBnd = field(default=None)
 
 
 @dataclass
-class _ResBounds(_ResLocBounds, _ResLnkBounds):
-    """Bounds for Resources
+class _OpnBounds:
+    """Bounds for Operational Components
 
     Attributes:
-        buy (IsBnd): bound on amount bought at Location or by Process
-        sell (IsBnd): bound on amount sold at Location or by Process
-        ship (IsBnd): bound on amount shipped through Linkage
-        recieve (IsBnd): bound on amount received through Linkage
+        setup (IsBnd): bound on how much capacity can be setup
+        dismantle (IsBnd): bound on how much capacity can be dismantled
     """
 
-
-@dataclass
-class _OpnBounds:
-    """Bounds for Operational Components"""
-
-    capacity: IsBnd = field(default=None)
+    setup: IsBnd = field(default=None)
+    dismantle: IsBnd = field(default=None)
 
 
 @dataclass
@@ -100,8 +101,8 @@ class _ProBounds:
     """Bounds for Process
 
     Attributes:
-        capacity (IsBnd): bound on Capacitate Variable
-        produce (IsBnd): bound on Operate Variable
+        setup (IsBnd): bound on how much capacity can be setup
+        produce (IsBnd): bound on how much capacity can be utilized (operated)
     """
 
     produce: IsBnd = field(default=None)
@@ -112,8 +113,8 @@ class _StgBounds:
     """Bounds for Storage
 
     Attributes:
-        capacity (IsBnd): bound on Capacitate Variable
-        store (IsBnd): bound on Store Variable
+        setup (IsBnd): bound on how much capacity can be setup
+        store (IsBnd): bound on how much capacity can be utilized (operated)
     """
 
     store: IsBnd = field(default=None)
@@ -124,8 +125,8 @@ class _TrnBounds:
     """Bounds for Transit
 
     Attributes:
-        capacity (IsBnd): bound on Capacitate Variable
-        transport (IsBnd): bound on Transport Variable
+        setup (IsBnd): bound on how much capacity can be setup
+        transport (IsBnd): bound on how much capacity can be utilized (operated)
     """
 
     transport: IsBnd = field(default=None)
diff --git a/src/energiapy/components/_attrs/_exacts.py b/src/energiapy/components/_attrs/_exacts.py
index 80be27be..3cc47227 100644
--- a/src/energiapy/components/_attrs/_exacts.py
+++ b/src/energiapy/components/_attrs/_exacts.py
@@ -36,6 +36,7 @@ class _UsdTscExacts:
     """
 
     use_cost: IsInc = field(default=None)
+    dispose_cost: IsInc = field(default=None)
 
 
 @dataclass
@@ -59,15 +60,19 @@ class _ResEmnExacts:
     """Exact Emission Inputs for Resources
 
     Attributes:
-        buy_emission (IsExt): emission associated with buying Resource
-        sell_emission (IsExt): emission associated with selling Resource
-        loss_emission (IsExt): emission associated with losing Resource
+        buy_emit (IsExt): Emission discharged when buying Resource
+        buy_sequester (IsExt): Emission abated when buying Resource
+        sell_emit (IsExt): Emission discharged when selling Resource
+        sell_sequester (IsExt): Emission abated when selling Resource
+        loss_emit (IsExt): Emission discharged when losing Resource
 
     """
 
-    buy_emission: IsExt = field(default=None)
-    sell_emission: IsExt = field(default=None)
-    loss_emission: IsExt = field(default=None)
+    buy_emit: IsExt = field(default=None)
+    buy_sequester: IsExt = field(default=None)
+    sell_emit: IsExt = field(default=None)
+    sell_sequester: IsExt = field(default=None)
+    lose_emit: IsExt = field(default=None)
 
 
 @dataclass
@@ -75,11 +80,13 @@ class _UsdEmnExacts:
     """Exact Emissions Inputs for Land and Material (Used)
 
     Attributes:
-        use_emission (IsExt): emission associated with using Land or Material (Used
-
+        use_emit (IsExt): emission associated with using Land or Material (Used
+        dispose_emit (IsExt): emission associated with disposing Land or Material (Used)
     """
 
-    use_emission: IsExt = field(default=None)
+    use_emit: IsExt = field(default=None)
+    use_sequester: IsExt = field(default=None)
+    dispose_emit: IsExt = field(default=None)
 
 
 @dataclass
@@ -87,11 +94,13 @@ class _OpnEmnExacts:
     """Exact Emission Inputs for Operational Components
 
     Attributes:
-        setup_emission (IsExt): emission associated with setting up Operational Component
+        setup_emit (IsExt): emission associated with set up (capacitating)
 
     """
 
-    setup_emission: IsExt = field(default=None)
+    setup_emit: IsExt = field(default=None)
+    setup_sequester: IsExt = field(default=None)
+    dismantle_emit: IsExt = field(default=None)
 
 
 # -------------UseStp Exacts-------------
@@ -102,7 +111,7 @@ class _OpnUseExacts:
     """Exact Use Inputs for Operational Components
 
     Attributes:
-        setup_use (IsExt): use (Material or Land) associated with setting up Operational Component
+        setup_use (IsExt): use (Material or Land) associated with setup
 
     """
 
@@ -163,7 +172,7 @@ class _TrnRteExacts:
     speed: IsExt = field(default=None)
 
 
-# -------------Exacts Component-wise -------------
+# -------------Component-wise Exacts-------------
 # These are inherited by the Components
 
 
@@ -197,7 +206,7 @@ class _TrnExacts(_OpnExacts, _TrnLseExacts, _TrnRteExacts):
     """Exact Inputs for Transit Components"""
 
 
-# -------------Exacts Task-wise -------------
+# -------------Task-wise Exacts-------------
 # These are used by the TaskMaster to generate Tasks
 
 
diff --git a/src/energiapy/components/_base/_component.py b/src/energiapy/components/_base/_component.py
index d9911637..814a86f1 100644
--- a/src/energiapy/components/_base/_component.py
+++ b/src/energiapy/components/_base/_component.py
@@ -3,7 +3,7 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 from ...core._handy._dunders import _Dunders
@@ -21,6 +21,8 @@ class _Component(_Dunders):
     Also adds Model and reports individual Blocks of the Model
     """
 
+    label: str = field(default=None)
+
     def __post_init__(self):
         self.name = None
         self._named = False
diff --git a/src/energiapy/components/_base/_consistent.py b/src/energiapy/components/_base/_consistent.py
index 6dfc71ab..827c6a10 100644
--- a/src/energiapy/components/_base/_consistent.py
+++ b/src/energiapy/components/_base/_consistent.py
@@ -9,10 +9,12 @@
 use is_not to compare dummy to existing Components (Scale, Location)
 """
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from operator import is_not
 from warnings import warn
-
+from typing import TYPE_CHECKING
 from pandas import DataFrame
 
 from ...core.isalias.inps.isinp import IsBndInp, IsExtInp, IsInp, IsSptTmp
@@ -24,6 +26,10 @@
 from ..temporal.scale import Scale
 from ._dummy import _Dummy
 
+if TYPE_CHECKING:
+    from ...environ.engines.taskmaster import Chanakya
+    from ...environ.blocks.system import System
+
 
 class _Consistent(ABC):
     """Functions to make user data input into Datum
@@ -40,12 +46,12 @@ class _Consistent(ABC):
 
     @property
     @abstractmethod
-    def system(self):
+    def system(self) -> System:
         """The System of the Component"""
 
     @property
     @abstractmethod
-    def taskmaster(self):
+    def taskmaster(self) -> Chanakya:
         """Chanakya of the Scenario"""
 
     @staticmethod
@@ -61,6 +67,10 @@ def bounds(self):
         """Bounds attributes"""
         return sorted(set(self.inputs()) & set(self.taskmaster.bounds()))
 
+    def boundbounds(self):
+        """BoundBounds attributes"""
+        return sorted(set(self.inputs()) & set(self.taskmaster.boundbounds()))
+
     @property
     def consistent(self):
         """Checks if the inputs have been made consistent"""
@@ -205,7 +215,7 @@ def match_scale(
             return tmp
 
     def fix_temporal(
-        self, spttmpmdeval: dict, attr: str, ok_inconsistent: bool
+        self, spttmpmdeval: dict[dict, dict], attr: str, ok_inconsistent: bool
     ) -> dict:
         """Fixes the temporal disposition of the input
 
@@ -260,7 +270,7 @@ def spatialize(self, spttmpmdeval: dict, attr: str) -> dict:
         value_upd = {}
         for spt in spttmpmdeval.keys():
             if spt == _Dummy.N:
-                if attr in self.taskmaster.bounds():
+                if attr in self.bounds() + self.boundbounds():
                     value_upd[self.system.network] = spttmpmdeval[spt]
                 else:
 
@@ -292,7 +302,7 @@ def temporalize(self, spttmpmdeval: dict) -> dict:
 
         return value_upd
 
-    def modize(self, spttmpmdeval: dict) -> dict:
+    def modize(self, spttmpmdeval: dict[dict, dict]) -> dict:
         """Replaces the dummy X in the input
 
         Args:
@@ -357,7 +367,6 @@ def cashify(self, attr: str, value: IsInp) -> dict:
         Returns:
             dict: {Cash: value}
         """
-
         if attr in self.taskmaster.transactions():
             value = {self.system.cash: value}
 
@@ -391,12 +400,10 @@ def make_any_consistent(value: dict, attr: str, ok_inconsistent: bool):
             """Make either exact or bound consistent"""
 
             if attr in self.exacts():
-                # for Cash and Land, these are added, Resources, Materials, Emissions need to be specified
                 value = self.cashify(attr, value)
-
                 return make_exact_consistent(value, attr, ok_inconsistent)
 
-            if attr in self.bounds():
+            if attr in self.bounds() + self.boundbounds():
                 return make_bound_consistent(value, attr, ok_inconsistent)
 
         for attr in self.inputs():
@@ -409,21 +416,22 @@ def make_any_consistent(value: dict, attr: str, ok_inconsistent: bool):
             if value is None:
                 continue
 
-            if any(
-                isinstance(self, cmp) for cmp in getattr(self.taskmaster, attr).other
-            ):
-                # if the root of attribute is another Component
-                # Then we need to iterate over the Components
-                setattr(
-                    self,
-                    attr,
-                    {
-                        cmd: make_any_consistent(val, attr, ok_inconsistent)
-                        for cmd, val in value.items()
-                    },
-                )
-            else:
-                # else just set i
-                setattr(self, attr, make_any_consistent(value, attr, ok_inconsistent))
+            setattr(self, attr, make_any_consistent(value, attr, ok_inconsistent))
+
+            # if any(
+            #     isinstance(self, cmp) for cmp in getattr(self.taskmaster, attr).other
+            # ):
+            #     # if the root of attribute is another Component
+            #     # Then we need to iterate over the Components
+            #     setattr(
+            #         self,
+            #         attr,
+            #         {
+            #             cmd: make_any_consistent(val, attr, ok_inconsistent)
+            #             for cmd, val in value.items()
+            #         },
+            #     )
+            # else:
+            #     # else just set i
 
         setattr(self, 'consistent', True)
diff --git a/src/energiapy/components/_base/_defined.py b/src/energiapy/components/_base/_defined.py
index 10c77fcc..7d8fbc98 100644
--- a/src/energiapy/components/_base/_defined.py
+++ b/src/energiapy/components/_base/_defined.py
@@ -1,6 +1,7 @@
 """There are user defined components
 """
 
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 
 from ...core._handy._printers import _EasyPrint
@@ -11,7 +12,7 @@
 
 
 @dataclass
-class _Defined(_Component, _Consistent, _Vlus, _Elms, _EasyPrint):
+class _Defined(_Component, _Consistent, _Vlus, _Elms, _EasyPrint, ABC):
     """If the component is defined by user, it should inherit from this class
 
     Attributes:
@@ -28,21 +29,14 @@ class _Defined(_Component, _Consistent, _Vlus, _Elms, _EasyPrint):
     block: str = field(default=None)
     introduce: str = field(default=None)
     retire: str = field(default=None)
-    label: str = field(default=None)
 
     def __post_init__(self):
         _Component.__post_init__(self)
-
-
-@dataclass
-class _Simple(_Defined):
-    """Simple Components inherit from this class
-    They only have bounds
-    These are Cash, Player, Emission, for now
-    Again, do not let me tell you how to live your life
-    Make more Simple Components if you feel the need
-    More power to you
-    """
-
-    def __post_init__(self):
-        _Defined.__post_init__(self)
+        # This flag is used to check if the Defined Component has been located
+        # i.e., assigned to a Location or Linkage
+        self._located = False
+
+    @staticmethod
+    @abstractmethod
+    def inputs():
+        """Input attributes"""
diff --git a/src/energiapy/components/_base/_discr.py b/src/energiapy/components/_base/_discr.py
new file mode 100644
index 00000000..004eb60d
--- /dev/null
+++ b/src/energiapy/components/_base/_discr.py
@@ -0,0 +1,35 @@
+"""A discretization of the scope 
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from ..temporal.scale import Scale
+    from ..spatial.location import Location
+    from ..temporal.horizon import Horizon
+    from ..spatial.network import Network
+
+
+@dataclass
+class _Discr:
+    """A discretization of the scope
+    - Scales for Horizon
+    - Locations for Network
+    """
+
+    parent: Scale | Location | Horizon | Network = field(default=None)
+    discrs: int = field(default=1)
+
+    def __post_init__(self):
+        self.children = []
+
+        self.parent.children.append(self)
+
+    @property
+    def index(self):
+        """Index of the Discretization"""
+        return self.parent.index + (self,)
diff --git a/src/energiapy/components/_base/_scope.py b/src/energiapy/components/_base/_scope.py
index eb8a3b52..83d2fe93 100644
--- a/src/energiapy/components/_base/_scope.py
+++ b/src/energiapy/components/_base/_scope.py
@@ -1,17 +1,132 @@
 """Scopes define the spatiotemporal boundaris of the System
 """
 
-from dataclasses import dataclass
-
+from abc import ABC, abstractmethod
+from itertools import product, accumulate
+from dataclasses import dataclass, field
+from operator import mul
 from ._component import _Component
 
 
 @dataclass
-class _Scope(_Component):
+class _Scope(_Component, ABC):
     """These define the spatiotemporal boundaries of the System
     Components which have only one instance in the model
     Horizon and Network are the only scope components
+
+    Attributes:
+        nested: bool, optional, default True
+        birth: int | list[int] | dict[str, int], optional, default 1
+        birth_labels: bool, optional, default False
+
     """
 
+    birth: int | list[int] | dict[str, int] = field(default=None)
+    birth_labels: list[str] = field(default=None)
+    nested: bool = field(default=False)
+
     def __post_init__(self):
         _Component.__post_init__(self)
+        self.children = []
+        self.discrs = 1
+        # Every Scope has a root birth
+        # This root birth, basiscally the horizon
+        if self.birth:
+            if isinstance(self.birth, int):
+                # if only a number is given, then just make
+                self.birth = [self.birth]
+
+            if isinstance(self.birth, dict):
+                self.birth_list = list(self.birth.values())
+                # self.birth_list.insert(0, 1)
+                self.birth_names = list(self.birth.keys())
+                # self.birth_names.insert(0, self._root())
+
+            elif isinstance(self.birth, list):
+                self.birth_list = self.birth
+                # self.birth_list.insert(0, 1)
+                self.birth_names = [
+                    f'{self._def_name()}{b}' for b in range(len(self.birth_list))
+                ]
+
+            else:
+                raise ValueError('Partitions must be int, list or dictionary')
+
+            if self.nested:
+                self.birth_list = list(accumulate(self.birth_list, mul))
+
+            if not self.birth_labels:
+                self.birth_labels = [None for _ in range(self.n_births)]
+
+        else:
+            self.birth_list, self.birth_names = [], []
+
+    @property
+    def index(self):
+        """Index of the Network"""
+        return (self,)
+
+    @property
+    @abstractmethod
+    def discretizations(self):
+        """Discretizations for the births"""
+
+    @property
+    @abstractmethod
+    def root(self):
+        """Root birth of the Scope"""
+
+    @staticmethod
+    @abstractmethod
+    def _root():
+        """Name for root birth of the Scope"""
+
+    @staticmethod
+    @abstractmethod
+    def _def_name():
+        """Default name for the Partitions"""
+
+    @property
+    def n_births(self) -> int:
+        """Returns number of births"""
+        return len(self.birth_list)
+
+    @property
+    def indices(self):
+        """Dictionary of indices"""
+        return {i: i.index for i in self.discretizations}
+
+    @property
+    def n_indices(self):
+        """list of number of indices"""
+        return [len(i) for i in self.discretizations]
+
+    @property
+    def is_multiscale(self):
+        """Returns True if problem has multiple scales"""
+        # Note that the first scale is always the planning horizon
+        if self.n_births > 2:
+            return True
+        else:
+            return False
+
+    @property
+    def is_nested(self):
+        """Returns True if problem has nested scales"""
+        if self.nested:
+            return True
+        else:
+            return False
+
+    def make_index(self, position: int, nested: bool = True):
+        """makes an index for Discretization of the Scope
+        Args:
+            position: int
+            nested: bool, optional, default True
+        """
+
+        lists = [list(range(i)) for i in self.birth_list]
+        if nested:
+            return list(product(*lists[: position + 1]))
+        else:
+            return [(0, i) for i in lists[position]]
diff --git a/src/energiapy/components/_base/_simple.py b/src/energiapy/components/_base/_simple.py
new file mode 100644
index 00000000..0e50470e
--- /dev/null
+++ b/src/energiapy/components/_base/_simple.py
@@ -0,0 +1,20 @@
+"""Defined Component that is simple
+"""
+
+from dataclasses import dataclass
+
+from ._defined import _Defined
+
+
+@dataclass
+class _Simple(_Defined):
+    """Simple Components inherit from this class
+    They only have bounds
+    These are Cash, Player, Emission, for now
+    Again, do not let me tell you how to live your life
+    Make more Simple Components if you feel the need
+    More power to you
+    """
+
+    def __post_init__(self):
+        _Defined.__post_init__(self)
diff --git a/src/energiapy/components/analytical/player.py b/src/energiapy/components/analytical/player.py
index 51818473..f6f4071a 100644
--- a/src/energiapy/components/analytical/player.py
+++ b/src/energiapy/components/analytical/player.py
@@ -9,11 +9,11 @@
 from dataclasses import dataclass, fields
 
 from .._attrs._bounds import _PlyBounds
-from .._base._defined import _Simple
+from .._base._defined import _Defined
 
 
 @dataclass
-class Player(_PlyBounds, _Simple):
+class Player(_PlyBounds, _Defined):
     """Player represents a decision maker in the Scenario
 
     A Player has ownership of some Commodities which they give
@@ -31,7 +31,7 @@ class Player(_PlyBounds, _Simple):
     """
 
     def __post_init__(self):
-        _Simple.__post_init__(self)
+        _Defined.__post_init__(self)
 
     @staticmethod
     def inputs():
diff --git a/src/energiapy/components/commodity/_commodity.py b/src/energiapy/components/commodity/_commodity.py
index f8b9ac9f..90969c84 100644
--- a/src/energiapy/components/commodity/_commodity.py
+++ b/src/energiapy/components/commodity/_commodity.py
@@ -5,13 +5,17 @@
 
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
+from dataclasses import dataclass
+
+from .._base._defined import _Defined
 
 if TYPE_CHECKING:
     from ..spatial.linkage import Linkage
     from ..spatial.location import Location
 
 
-class _Commodity(ABC):
+@dataclass
+class _Commodity(_Defined, ABC):
     """Commodities that are:
 
     Traded (Trade) - Resource
@@ -23,15 +27,7 @@ class _Commodity(ABC):
     """
 
     def __post_init__(self):
-
-        # This flag is used to check if the Commodity has been located
-        # (assigned) to a Location or Linkage
-        self._located = False
-
-    @property
-    @abstractmethod
-    def system(self):
-        """System Block"""
+        _Defined.__post_init__(self)
 
     @property
     def locations(self):
diff --git a/src/energiapy/components/commodity/_traded.py b/src/energiapy/components/commodity/_traded.py
deleted file mode 100644
index a94d19a9..00000000
--- a/src/energiapy/components/commodity/_traded.py
+++ /dev/null
@@ -1,22 +0,0 @@
-"""Base for any Traded Component
-"""
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-from .._base._defined import _Defined
-from ._commodity import _Commodity
-
-
-@dataclass
-class _Traded(_Defined, _Commodity, ABC):
-    """Applied for Land, Material and Resource"""
-
-    def __post_init__(self):
-        _Defined.__post_init__(self)
-        _Commodity.__post_init__(self)
-
-    @staticmethod
-    @abstractmethod
-    def inputs():
-        """Input Attributes"""
diff --git a/src/energiapy/components/commodity/_used.py b/src/energiapy/components/commodity/_used.py
index 2d060258..c6598edb 100644
--- a/src/energiapy/components/commodity/_used.py
+++ b/src/energiapy/components/commodity/_used.py
@@ -5,11 +5,11 @@
 
 from .._attrs._bounds import _UsdBounds
 from .._attrs._exacts import _UsdExacts
-from ._traded import _Traded
+from ._commodity import _Commodity
 
 
 @dataclass
-class _Used(_UsdBounds, _UsdExacts, _Traded):
+class _Used(_Commodity, _UsdBounds, _UsdExacts):
     """Applies only for Land and Material
     For now, do not subsume my limitations
     Do whatever you can or want to with energiapy
@@ -21,7 +21,7 @@ class _Used(_UsdBounds, _UsdExacts, _Traded):
     """
 
     def __post_init__(self):
-        _Traded.__post_init__(self)
+        _Commodity.__post_init__(self)
 
     @staticmethod
     def inputs():
diff --git a/src/energiapy/components/commodity/cash.py b/src/energiapy/components/commodity/cash.py
index 837c76f8..0f60f3f5 100644
--- a/src/energiapy/components/commodity/cash.py
+++ b/src/energiapy/components/commodity/cash.py
@@ -9,12 +9,11 @@
 from dataclasses import dataclass, fields
 
 from .._attrs._bounds import _CshBounds
-from .._base._defined import _Simple
 from ._commodity import _Commodity
 
 
 @dataclass
-class Cash(_CshBounds, _Simple, _Commodity):
+class Cash(_CshBounds, _Commodity):
     """Cash is an Asset
     The amount spent or earned at some spatiotemporal dispoqition can be bound
 
@@ -30,7 +29,6 @@ class Cash(_CshBounds, _Simple, _Commodity):
     """
 
     def __post_init__(self):
-        _Simple.__post_init__(self)
         _Commodity.__post_init__(self)
 
     @staticmethod
diff --git a/src/energiapy/components/commodity/emission.py b/src/energiapy/components/commodity/emission.py
index 01f4e631..bb894c1c 100644
--- a/src/energiapy/components/commodity/emission.py
+++ b/src/energiapy/components/commodity/emission.py
@@ -4,7 +4,6 @@
 from dataclasses import dataclass, fields
 
 from .._attrs._bounds import _EmnBounds
-from .._base._defined import _Simple
 from ._commodity import _Commodity
 
 # Associated Program Elements are:
@@ -13,7 +12,7 @@
 
 
 @dataclass
-class Emission(_EmnBounds, _Simple, _Commodity):
+class Emission(_EmnBounds, _Commodity):
     """Emission are generated through:
             Commodity Use, Trade, Loss
             Operational Setup
@@ -31,7 +30,6 @@ class Emission(_EmnBounds, _Simple, _Commodity):
     """
 
     def __post_init__(self):
-        _Simple.__post_init__(self)
         _Commodity.__post_init__(self)
 
     @staticmethod
@@ -42,4 +40,4 @@ def inputs():
     @property
     def emissions(self):
         """Emissions across the components"""
-        return self.taskmaster.report_emissions
+        return self.taskmaster.report_emits
diff --git a/src/energiapy/components/commodity/resource.py b/src/energiapy/components/commodity/resource.py
index 613188ec..e6bfa0e1 100644
--- a/src/energiapy/components/commodity/resource.py
+++ b/src/energiapy/components/commodity/resource.py
@@ -9,20 +9,11 @@
 
 from .._attrs._bounds import _ResBounds
 from .._attrs._exacts import _ResEmnExacts, _ResTscExacts
-from ._traded import _Traded
-
-# Associated Program Elements are:
-#    Bound Parameters - BuyBound, SellBound, ShipBound
-#    Exact Parameters - BuyPrice, SllPrice, SllCredit, SllPenalty, BuyEmission, SllEmission, LseEmission
-#    Operational Parameters - Loss
-#    Variables (Trades) - Buy, Sell, Ship
-#    Variables (Transactions) - TransactBuy, TransactSell, TransactPnt, TransactCrd
-#    Variables (Emissions) - BuyEmit, SellEmit, LseEmit
-#    Variables (Losses) - Lose
+from ._commodity import _Commodity
 
 
 @dataclass
-class Resource(_ResBounds, _ResTscExacts, _ResEmnExacts, _Traded):
+class Resource(_Commodity, _ResBounds, _ResTscExacts, _ResEmnExacts):
     """Resources are Produced by Processes, Stored by Storage, and Transported by Transits
     They can be bought, sold, shipped, and received by Locations or Processes
 
@@ -46,7 +37,7 @@ class Resource(_ResBounds, _ResTscExacts, _ResEmnExacts, _Traded):
     """
 
     def __post_init__(self):
-        _Traded.__post_init__(self)
+        _Commodity.__post_init__(self)
 
     @property
     def losses(self):
diff --git a/src/energiapy/components/operation/_birther.py b/src/energiapy/components/operation/_birther.py
index f64fa433..b90fdc54 100644
--- a/src/energiapy/components/operation/_birther.py
+++ b/src/energiapy/components/operation/_birther.py
@@ -1,11 +1,17 @@
 """Operational Components that give birth to Processes
 """
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-
+from typing import TYPE_CHECKING
 from ._operation import _Operation
 
+if TYPE_CHECKING:
+    from .process import Process
+    from ...elements.parameters.balances.conversion import Conversion
+
 
 @dataclass
 class _Birther(_Operation, ABC):
@@ -30,17 +36,7 @@ def balance(self):
         """Balance attribute"""
 
     @property
-    @abstractmethod
-    def capacity_in(self):
-        """Process Capacitate for Input Process"""
-
-    @property
-    @abstractmethod
-    def capacity_out(self):
-        """Process Capacitate for Output Process"""
-
-    @property
-    def processes(self):
+    def processes(self) -> list[Process]:
         """Birthed Processes"""
         return self._processes
 
@@ -50,22 +46,22 @@ def processes(self, processes):
         self._processes = processes
 
     @property
-    def process_in(self):
+    def process_in(self) -> Process:
         """Process from Resource to Birthed Resource"""
         return self.processes[0]
 
     @property
-    def process_out(self):
+    def process_out(self) -> Process:
         """Process from Birthed Resource to Resource"""
         return self.processes[1]
 
     @property
-    def conversion_in(self):
+    def conversion_in(self) -> Conversion:
         """Conversion from Resource to Birthed Resource"""
         return getattr(self.system, getattr(self, 'name')).process_in.conversion
 
     @property
-    def conversion_out(self):
+    def conversion_out(self) -> Conversion:
         """Conversion from Birthed Resource to Resource"""
         return self.process_out.conversion
 
diff --git a/src/energiapy/components/operation/_operation.py b/src/energiapy/components/operation/_operation.py
index 126a6e4f..d54cba27 100644
--- a/src/energiapy/components/operation/_operation.py
+++ b/src/energiapy/components/operation/_operation.py
@@ -40,6 +40,11 @@ def _operate(self):
     def _spatials():
         """Spatial Components where the Operation is located"""
 
+    @staticmethod
+    @abstractmethod
+    def at():
+        """At what Spatial can the Operation be located"""
+
     @property
     def spatials(self):
         """Spatial Components where the Operation is located"""
@@ -65,8 +70,8 @@ def materials(self):
     @property
     def emissions(self):
         """Emissions from the Operation"""
-        if getattr(self, 'setup_emission'):
-            return [i.index.emn for i in getattr(self, 'setup_emission').data.values()]
+        if getattr(self, 'setup_emit'):
+            return [i.index.emn for i in getattr(self, 'setup_emit').data.values()]
         else:
             return []
 
diff --git a/src/energiapy/components/operation/process.py b/src/energiapy/components/operation/process.py
index c31b642d..d2bf508b 100644
--- a/src/energiapy/components/operation/process.py
+++ b/src/energiapy/components/operation/process.py
@@ -5,47 +5,21 @@
 
 from ...elements.parameters.balances.conversion import Conversion
 from .._attrs._balances import _ProBalance
-from .._attrs._bounds import (
-    _OpnBounds,
-    _ProBounds,
-    _ResLocBounds,
-    _EmnBounds,
-    _UsdBounds,
-)
-from .._attrs._exacts import _ProExacts, _ResExacts, _UsdExacts, _EmnExacts
+from .._attrs._bounds import _OpnBounds, _ProBounds
+
+from .._attrs._exacts import _ProExacts
 from .._attrs._spatials import _LocCollection
 from ._operation import _Operation
-
-# Associated Program Elements:
-#   Bound Parameters - CapBound, OprBound
-#   Exact Parameters - StpEmission, StpExpense, OprExpense, Usage
-#   Balance Parameters - Conversion
-#   Resource Parameters - BuyBound, SellBound, BuyPrice, SellPrice, Credit, Penalty
-#   Variable (Transact) - TransactOpr, TransactStp
-#   Variable (Emissions) - EmitStp, EmitUse
-#   Variable (Operate) - Operate
-#   Variable (Use) - Use
-#   Variable (Rates) - Rate
-
-
-@dataclass
-class _Process(_OpnBounds, _ProBounds, _ProExacts):
-    """These are attributes which are original to Process"""
-
-
-@dataclass
-class _CmdProcess(
-    _ResExacts, _ResLocBounds, _UsdExacts, _UsdBounds, _EmnExacts, _EmnBounds
-):
-    """These are Commodity attributes which can be defined at Process"""
+from ..spatial.location import Location
 
 
 @dataclass
 class Process(
     _ProBalance,
-    _CmdProcess,
     _LocCollection,
-    _Process,
+    _OpnBounds,
+    _ProBounds,
+    _ProExacts,
     _Operation,
 ):
     """Process converts one Resource to another Resource
@@ -125,13 +99,20 @@ def is_balanced(self):
     @staticmethod
     def inputs():
         """Input attributes"""
-        return [f.name for f in fields(_Process) + fields(_CmdProcess)]
+        return [
+            f.name for f in fields(_OpnBounds) + fields(_ProBounds) + fields(_ProExacts)
+        ]
 
     @property
     def resources(self):
         """Resources in Conversion"""
         return self.conversion.involved
 
+    @staticmethod
+    def at():
+        """At what Spatial can the Operation be located"""
+        return Location
+
     def conversionize(self):
         """Makes the conversion"""
 
diff --git a/src/energiapy/components/operation/storage.py b/src/energiapy/components/operation/storage.py
index ef370cba..e91327ab 100644
--- a/src/energiapy/components/operation/storage.py
+++ b/src/energiapy/components/operation/storage.py
@@ -6,38 +6,19 @@
 from ...elements.parameters.balances.inventory import Inventory
 from .._attrs._balances import _StgBalance
 from .._attrs._birthing import _StgBirthing
-from .._attrs._bounds import _OpnBounds, _StgBounds, _EmnBounds, _UsdBounds
-from .._attrs._exacts import _StgExacts, _UsdExacts, _EmnExacts
+from .._attrs._bounds import _OpnBounds, _StgBounds
+from .._attrs._exacts import _StgExacts
 from .._attrs._spatials import _LocCollection
 from ._birther import _Birther
-
-# Associated Program Elements:
-#   Bound Parameters - CapBound, OprBound
-#   Exact Parameters - StpEmission, StpExpense, OprExpense, StpUse
-#   Balance Parameters - Inventory
-#   Variable (Transact) - TransactOpr, TransactStp
-#   Variable (Emissions) - EmitStp, EmitUse
-#   Variable (Losses) - Lose
-#   Variable (Operate) - Operate
-#   Variable (Use) - Use
-#   Variable (Rates) - Rate
-
-
-@dataclass
-class _Storage(_OpnBounds, _StgBounds, _StgExacts):
-    """These are attributes which are original to Storage"""
-
-
-@dataclass
-class _CmdStorage(_UsdExacts, _UsdBounds, _EmnExacts, _EmnBounds):
-    """These are Commodity attributes which can be defined at Storage"""
+from ..spatial.location import Location
 
 
 @dataclass
 class Storage(
     _StgBalance,
-    _Storage,
-    _CmdStorage,
+    _OpnBounds,
+    _StgBounds,
+    _StgExacts,
     _StgBirthing,
     _LocCollection,
     _Birther,
@@ -86,13 +67,20 @@ def _operate(self):
     @staticmethod
     def inputs():
         """Input attributes"""
-        return [f.name for f in fields(_Storage) + fields(_CmdStorage)]
+        return [
+            f.name for f in fields(_OpnBounds) + fields(_StgBounds) + fields(_StgExacts)
+        ]
 
     @property
     def balance(self):
         """Balance of the Storage"""
         return self.inventory
 
+    @staticmethod
+    def at():
+        """At what Spatial can the Operation be located"""
+        return Location
+
     def inventorize(self):
         """Makes the inventory"""
         if not isinstance(self.inventory, Inventory):
diff --git a/src/energiapy/components/operation/transit.py b/src/energiapy/components/operation/transit.py
index 224e3b7e..2e86ddb6 100644
--- a/src/energiapy/components/operation/transit.py
+++ b/src/energiapy/components/operation/transit.py
@@ -5,45 +5,19 @@
 
 from ...elements.parameters.balances.freight import Freight
 from .._attrs._balances import _TrnBalance
-from .._attrs._bounds import (
-    _OpnBounds,
-    _ResLnkBounds,
-    _TrnBounds,
-    _EmnBounds,
-    _UsdBounds,
-)
-from .._attrs._exacts import _TrnExacts, _UsdExacts, _EmnExacts
+from .._attrs._bounds import _OpnBounds, _TrnBounds
+from .._attrs._exacts import _TrnExacts
 from .._attrs._spatials import _LnkCollection
 from ._birther import _Birther
-
-# Associated Program Elements:
-#   Bound Parameters - CapBound, OprBound
-#   Exact Parameters - StpEmission, StpExpense, OprExpense, StpUse
-#   Balance Parameters - Freight
-#   Variable (Transact) - TransactOpr, TransactStp
-#   Variable (Emissions) - EmitStp, EmitUse
-#   Variable (Losses) - Lose
-#   Variable (Operate) - Operate
-#   Variable (Trade) - Ship
-#   Variable (Use) - Use
-#   Variable (Rates) - Rate
-
-
-@dataclass
-class _Transit(_OpnBounds, _TrnBounds, _TrnExacts):
-    """These are attributes which are original to Transit"""
-
-
-@dataclass
-class _CmdTransit(_ResLnkBounds, _EmnBounds, _EmnExacts, _UsdBounds, _UsdExacts):
-    """These are Commodity attributes which can be defined at Transit"""
+from ..spatial.linkage import Linkage
 
 
 @dataclass
 class Transit(
     _TrnBalance,
-    _Transit,
-    _CmdTransit,
+    _OpnBounds,
+    _TrnBounds,
+    _TrnExacts,
     _LnkCollection,
     _Birther,
 ):
@@ -79,21 +53,8 @@ class Transit(
     """
 
     def __post_init__(self):
-        # ship is a resourcebnd input
-        # so it needs to be a dictionary with Resource as key
-        # if not provided, use base Resource
-        if self.ship:
-            # if freight is a dictionary
-            # i.e. it has some Resource dependency
-            if isinstance(self.freight, dict):
-                # use the base Resource as key
-                self.ship = {list(self.freight)[0]: self.ship}
-            else:
-                # else, it is a Resource itself,
-                # so use it as key
-                self.ship = {self.freight: self.ship}
-
         _Birther.__post_init__(self)
+        self.setup_in = self.setup_out = self.setup
 
     @property
     def _operate(self):
@@ -108,32 +69,17 @@ def balance(self):
         """Balance attribute"""
         return self.freight
 
-    @property
-    def capacity_in(self):
-        """Capacitate of the Loading Process"""
-        # Returns og input if birthing is not done
-        # This is because the birthed Process capacity
-        # needs to be set
-        if self._birthed:
-            return self.capacity
-        else:
-            return self.capacity.og_input
-
-    @property
-    def capacity_out(self):
-        """Capacitate of the Unloading Process"""
-        # Returns og input if birthing is not done
-        # This is because the birthed Process capacity
-        # needs to be set
-        if self._birthed:
-            return self.capacity
-        else:
-            return self.capacity.og_input
-
     @staticmethod
     def inputs():
         """Input attributes"""
-        return [f.name for f in fields(_Transit) + fields(_CmdTransit)]
+        return [
+            f.name for f in fields(_OpnBounds) + fields(_TrnBounds) + fields(_TrnExacts)
+        ]
+
+    @staticmethod
+    def at():
+        """At what Spatial can the Operation be located"""
+        return Linkage
 
     def freightize(self):
         """Makes the freight"""
diff --git a/src/energiapy/components/spatial/linkage.py b/src/energiapy/components/spatial/linkage.py
index 087a55b7..f7ea980f 100644
--- a/src/energiapy/components/spatial/linkage.py
+++ b/src/energiapy/components/spatial/linkage.py
@@ -32,7 +32,6 @@ class Linkage(_Spatial):
     source: Location = field(default=None)
     bi: bool = field(default=True)
     distance: float = field(default=None)
-    label: str = field(default=None)
 
     def __post_init__(self):
         _Spatial.__post_init__(self)
diff --git a/src/energiapy/components/spatial/location.py b/src/energiapy/components/spatial/location.py
index ce14fa11..b366979a 100644
--- a/src/energiapy/components/spatial/location.py
+++ b/src/energiapy/components/spatial/location.py
@@ -1,14 +1,15 @@
 """Location where Processes and Storages can reside
 """
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from operator import is_
 
 from ._spatial import _Spatial
+from .._base._discr import _Discr
 
 
 @dataclass
-class Location(_Spatial):
+class Location(_Spatial, _Discr):
     """Location where Process and Storage can reside
     Generated by Network
 
@@ -16,10 +17,9 @@ class Location(_Spatial):
             label (str): label of the Location
     """
 
-    label: str = field(default=None)
-
     def __post_init__(self):
         _Spatial.__post_init__(self)
+        _Discr.__post_init__(self)
 
     @property
     def processes(self):
@@ -88,3 +88,6 @@ def is_connected(self, location, print_link: bool = False) -> bool:
             return True
         print(self.find_links(location, print_link=print_link))
         return False
+
+    def __len__(self):
+        return len(self.index)
diff --git a/src/energiapy/components/spatial/network.py b/src/energiapy/components/spatial/network.py
index 5d57e253..e3c6a7e8 100644
--- a/src/energiapy/components/spatial/network.py
+++ b/src/energiapy/components/spatial/network.py
@@ -22,14 +22,27 @@ class Network(_Scope, _NtwCols):
         label (str): label of the Network
     """
 
-    locs: list[str] | int = field(default_factory=list)
-    label_locs: list[str] = field(default=None)
     link_all: bool = field(default=False)
-    label: str = field(default=None)
 
     def __post_init__(self):
         _Scope.__post_init__(self)
 
-        # if integer number is giver, will make Locations with names node0, node1, ...
-        if isinstance(self.locs, int):
-            self.locs = [f'node{i}' for i in range(self.locs)]
+    @property
+    def root(self):
+        """Root partition of the Network"""
+        return self.locations[0]
+
+    @staticmethod
+    def _root():
+        """Root partition of the Network"""
+        return 'sys'
+
+    @staticmethod
+    def _def_name():
+        """Default name for the Partitions"""
+        return 'node'
+
+    @property
+    def discretizations(self):
+        """Discretizations for the partitions"""
+        return self.locations + self.linkages
diff --git a/src/energiapy/components/temporal/_calendar.py b/src/energiapy/components/temporal/_calendar.py
new file mode 100644
index 00000000..c4df715c
--- /dev/null
+++ b/src/energiapy/components/temporal/_calendar.py
@@ -0,0 +1,64 @@
+"""Default Temporal Horizon 
+"""
+
+# from dataclasses import dataclass, field
+# import calendar
+# from typing import TypeAlias
+
+# Rng: TypeAlias = tuple[tuple[int, int], tuple[int, int]] | tuple[tuple[int, int]]
+
+# @dataclass
+# class _Calendar:
+#     rng_year: tuple[int, int] = field(default=None)
+#     rng_month: Rng = field(
+#         default=None
+#     )
+#     rng_week: Rng = field(
+#         default=None
+#     )
+#     rng_day: Rng= field(
+#         default=None
+#     )
+#     rng_hour: Rng = field(
+#         default=None
+#     )
+#     rng_minute: Rng = field(
+#         default=None
+#     )
+#     def_year: bool = field(default=False)
+#     def_month: bool = field(default=False)
+#     def_week: bool = field(default=False)
+#     def_day: bool = field(default=False)
+#     def_hour: bool = field(default=False)
+#     def_minute: bool = field(default=False)
+
+#     def __post_init__(self):
+#         self._calendar = calendar.Calendar()        
+#         rng_attrs = [
+#             'rng_year',
+#             'rng_month',
+#             'rng_week',
+#             'rng_day',
+#             'rng_hour',
+#             'rng_minute',
+#         ]
+
+#         if sum(rng is not None for getattr(self, rng) in rng_attrs) > 1:
+#             raise ValueError('Only one range attribute can be set')
+    
+#         rng = [getattr(self, rng) for rng in rng_attrs if getattr(self, rng) is not None]
+
+#         for r in rng: 
+#             if self.range_year:
+#                 year = r
+#             else:
+#                 year = r[0]
+
+#             cal = self._calendar.yeardayscalendar(year, width=12)
+#             if self.range_month:
+#                 months = cal[r[1]]
+
+#             if self.range_week:
+
+
+            
\ No newline at end of file
diff --git a/src/energiapy/components/temporal/horizon.py b/src/energiapy/components/temporal/horizon.py
index 967a76e6..f610a3da 100644
--- a/src/energiapy/components/temporal/horizon.py
+++ b/src/energiapy/components/temporal/horizon.py
@@ -1,9 +1,7 @@
 """Planning Horizon of the problem
 """
 
-from dataclasses import dataclass, field
-from itertools import product
-from operator import imod, is_
+from dataclasses import dataclass
 
 from ...core._report._syst import _Scls
 from ...core.isalias.cmps.isdfn import IsDfn
@@ -38,7 +36,7 @@ class Horizon(_Scope, _Scls):
         >>> s = Scenario(name='pse')
 
         The planning horizon of the problem can be declared as follows:
-        >>> s.h = Horizon(discretizations=[4])
+        >>> s.h = Horizon(birth=[4])
 
         This creates two scales, t0 and t1, with 1 and 4 discretizations respectively.
         >>> s.h.scales
@@ -49,7 +47,7 @@ class Horizon(_Scope, _Scls):
         Consider the example where you want to consider 2 years, with 4 quarters each year.
 
         If nested is True, which is the default:
-        >>> s.h = Horizon(discretizations=[2, 4])
+        >>> s.h = Horizon(birth=[2, 4])
         >>> s.t0.index,
         [(0,)]
         >>> s.t1.index
@@ -60,7 +58,7 @@ class Horizon(_Scope, _Scls):
         If nested is False:
         The total number of discretizations for each scale must be provided in ascending order,
         and must be divisible by the most granular scals.
-        >>> s.h = Horizon(discretizations=[2, 8], nested=False)
+        >>> s.h = Horizon(birth=[2, 8], nested=False)
         >>> s.t0.index,
         [(0,0)]
         >>> s.t1.index
@@ -70,92 +68,34 @@ class Horizon(_Scope, _Scls):
 
         so for a 365 days and 24 hours, the following can be done:
         either
-        >>> s.h = Horizon(discretizations=[365, 24])
+        >>> s.h = Horizon(birth=[365, 24])
         or
-        >>> s.h = Horizon(discretizations=[365, 8760], nested=False)
+        >>> s.h = Horizon(birth=[365, 8760], nested=False)
 
     """
 
-    discretizations: list = field(default_factory=list)
-    # if nested the discretizes based on previous scale
-    nested: bool = field(default=True)
-    label_scales: list[str] = field(default=None)
-    label: str = field(default=None)
-
     def __post_init__(self):
         _Scope.__post_init__(self)
 
-        # insert 1 at the beginning, this is the horizon itself
-        if isinstance(self.discretizations, dict):
-            self._discretization_list = list(self.discretizations.values())
-            self._discretization_list.insert(0, 1)
-            self.name_scales = list(self.discretizations.keys())
-            self.name_scales.insert(0, 'ph')
-
-        elif isinstance(self.discretizations, list):
-            self._discretization_list = list(self.discretizations)
-            self._discretization_list.insert(0, 1)
-            self.name_scales = [f't{i}' for i in range(len(self._discretization_list))]
-
-        else:
-            raise ValueError('Discretizations must be a list or a dictionary')
-
-    @property
-    def n_scales(self) -> int:
-        """Returns number of scales"""
-        return len(self._discretization_list)
-
-    @property
-    def indices(self):
-        """Dictionary of indices"""
-        return {i: i.index for i in self.scales}
-
-    @property
-    def n_indices(self):
-        """list of number of indices"""
-        return [len(i) for i in self.scales]
-
-    @property
-    def is_multiscale(self):
-        """Returns True if problem has multiple scales"""
-        # Note that the first scale is always the planning horizon
-        if self.n_scales > 2:
-            return True
-        else:
-            return False
-
-    @property
-    def is_nested(self):
-        """Returns True if problem has nested scales"""
-        if self.nested:
-            return True
-        else:
-            return False
-
     @property
     def root(self):
         """Returns the root scale"""
         return self.scales[0]
 
-    def make_index(self, position: int, nested: bool = True):
-        """makes an index for Scale"""
-        if nested:
-            lists = [list(range(i)) for i in self._discretization_list]
-            return list(product(*lists[: position + 1]))
-        else:
-            if self._discretization_list != sorted(self._discretization_list):
-                raise ValueError('Discretizations need to be in ascending order')
-            if not all(
-                is_(imod(max(self._discretization_list), i), 0)
-                for i in self._discretization_list
-            ):
-                raise ValueError(
-                    'Discretizations need to be divisible by the most granular scale',
-                )
-            lists = [(0, i) for i in range(max(self._discretization_list))]
-            return lists[
-                :: max(self._discretization_list) // self._discretization_list[position]
-            ]
+    @staticmethod
+    def _root():
+        """Root partition of the Horizon"""
+        return 'ph'
+
+    @staticmethod
+    def _def_name():
+        """Default name for the Partitions"""
+        return 't'
+
+    @property
+    def discretizations(self):
+        """Discretizations for the partitions"""
+        return self.scales
 
     def match_scale(self, value, component: IsDfn = None, attr: str = None):
         """Returns the scale that matches the length
diff --git a/src/energiapy/components/temporal/incidental.py b/src/energiapy/components/temporal/incidental.py
index dd6a076f..4355ec8a 100644
--- a/src/energiapy/components/temporal/incidental.py
+++ b/src/energiapy/components/temporal/incidental.py
@@ -16,7 +16,7 @@ class I(_Dunders):
     Incidental Capital Expenditure or Fixed Operational Expenditure are examples
 
     Attributes:
-        value (IsIncidental): The incidental value
+        value (): The incidental value
     """
 
     value: int | float | DataFrame = field(default=None)
diff --git a/src/energiapy/components/temporal/mode.py b/src/energiapy/components/temporal/mode.py
index 28ee9dda..38c46aaa 100644
--- a/src/energiapy/components/temporal/mode.py
+++ b/src/energiapy/components/temporal/mode.py
@@ -18,7 +18,10 @@
 
 @dataclass
 class X(_Dunders):
-    """Mode of Operation, can be used for Conversion, Use, etc.
+    """Represents a discrete choice to be taken within a
+    spatiotemporal disposition. 
+    Modes can split you
+    Mode of Operation, can be used for Conversion, Use, etc.
 
     Attributes:
         name (str, float, int]): The name of the mode, usually a number.
diff --git a/src/energiapy/components/temporal/period.py b/src/energiapy/components/temporal/period.py
new file mode 100644
index 00000000..3d509e40
--- /dev/null
+++ b/src/energiapy/components/temporal/period.py
@@ -0,0 +1,22 @@
+"""Time Periods that constitute a scale 
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from dataclasses import dataclass, field
+from ...core._handy._dunders import _Dunders
+
+if TYPE_CHECKING:
+    from .scale import Scale
+
+
+@dataclass
+class Period(_Dunders):
+    """Time Period in a Scale"""
+
+    scale: Scale = field(default=None)
+    period: tuple = field(default=None)
+
+    def __post_init__(self):
+        self.name = f'{self.scale.name}{self.period}'
diff --git a/src/energiapy/components/temporal/scale.py b/src/energiapy/components/temporal/scale.py
index 411e7bb9..f42b4935 100644
--- a/src/energiapy/components/temporal/scale.py
+++ b/src/energiapy/components/temporal/scale.py
@@ -1,13 +1,15 @@
 """Scale is a bespoke discretization of the planning horizon (Horizon) of the problem.
 """
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
+from .._base._discr import _Discr
+from .period import Period
 from .._base._component import _Component
 
 
 @dataclass
-class Scale(_Component):
+class Scale(_Discr, _Component):
     """
     A single temporal scale of the planning horizon (Horizon).
 
@@ -18,11 +20,10 @@ class Scale(_Component):
         n_index(int): number of indices, generated post-initialization.
     """
 
-    index: list[tuple] = field(default_factory=list)
-    label: str = field(default=None)
-
     def __post_init__(self):
+        _Discr.__post_init__(self)
         _Component.__post_init__(self)
+        self.periods = None
 
     def pos(self, index: tuple) -> int:
         """Returns position of index"""
@@ -35,10 +36,14 @@ def idx(self, position: tuple):
     def rng(self, lb: int | tuple, ub: int | tuple):
         """Returns range from postion/index"""
         if isinstance(lb, int):
-            return [self.idx(i) for i in self.index[lb:ub]]
+            return self.index[lb:ub]
 
         if isinstance(lb, tuple):
             return self.index[self.pos(lb) : self.pos(ub)]
 
+    def periodize(self):
+        """Generates periods"""
+        self.periods = [Period(scale=self, period=i) for i in self.index]
+
     def __len__(self):
-        return len(self.index)
+        return self.discrs
diff --git a/src/energiapy/core/_handy/_words.py b/src/energiapy/core/_handy/_words.py
new file mode 100644
index 00000000..0e0ed1e8
--- /dev/null
+++ b/src/energiapy/core/_handy/_words.py
@@ -0,0 +1,47 @@
+"""Reserved words
+"""
+
+reserved_property = ['horizon', 'network', 'land', 'cash']
+
+reserved_component = [
+    'player',
+    'emission',
+    'resource',
+    'material',
+    'process',
+    'storage',
+    'transit',
+]
+
+reserved_collection = [
+    'components',
+    'component',
+    'analytical',
+    'players',
+    'spatial',
+    'locations',
+    'linkages',
+    'temporal',
+    'scales',
+    'modes',
+    'commodities',
+    'emissions',
+    'resources',
+    'materials',
+    'operations',
+    'processes',
+    'storages',
+    'transits',
+]
+
+
+reserved_block = ['program', 'data', 'matrix', 'system', 'model']
+reserved_engine = ['engines', 'registrar', 'taskmaster', 'tasks', 'rulebook', 'rules']
+
+reserved = (
+    reserved_component
+    + reserved_collection
+    + reserved_property
+    + reserved_block
+    + reserved_engine
+)
diff --git a/src/energiapy/core/isalias/elms/isprm.py b/src/energiapy/core/isalias/elms/isprm.py
index fb71293d..71ea818d 100644
--- a/src/energiapy/core/isalias/elms/isprm.py
+++ b/src/energiapy/core/isalias/elms/isprm.py
@@ -3,61 +3,14 @@
 
 from typing import TypeAlias
 
-from ....components.temporal.incidental import I
 from ....elements.parameters.balances.conversion import Conversion
 from ....elements.parameters.balances.freight import Freight
 from ....elements.parameters.balances.inventory import Inventory
-from ....elements.parameters.bounds.all import (BuyBound, CapBound, EmnBound,
-                                                ErnBound, OprBound, ShpBound,
-                                                SllBound, SpdBound, UseBound)
-from ....elements.parameters.exacts.emission import (BuyEmission, LseEmission,
-                                                     SllEmission, StpEmission,
-                                                     UseEmission)
-from ....elements.parameters.exacts.expense import (BuyPrice, OprExpense,
-                                                    SllCredit, SllPenalty,
-                                                    SllPrice, StpExpense,
-                                                    UseCost)
-from ....elements.parameters.exacts.loss import Loss
-from ....elements.parameters.exacts.usage import Usage
 
-# The naming convention is:
-# three character names are used in the start for the variable
-# this parameter models, data-driven modeling ftw
-#
+from ....elements.parameters.boundprm import BoundPrm
+from ....elements.parameters.exactprm import ExactPrm
 
-# Bound Parameters
-IsResBnd: TypeAlias = BuyBound | SllBound | ShpBound
-IsUsdBnd: TypeAlias = UseBound
-IsTscBnd: TypeAlias = SpdBound | ErnBound
-IsOpnBnd: TypeAlias = CapBound | OprBound
-IsEmnBnd: TypeAlias = EmnBound
-
-IsBndPar: TypeAlias = IsResBnd | IsUsdBnd | IsTscBnd | IsOpnBnd
-
-# Exact Parameters
-# Transacts
-IsResExp: TypeAlias = BuyPrice | SllPrice | SllCredit | SllPenalty
-IsUseExp: TypeAlias = UseCost
-IsOpnExp: TypeAlias = StpExpense | OprExpense
-# Emissions
-IsResEmn: TypeAlias = BuyEmission | SllEmission | LseEmission
-IsUsdEmn: TypeAlias = UseEmission
-IsOpnEmn: TypeAlias = StpEmission
-# Losses
-IsLss: TypeAlias = Loss
-# Usage
-IsUsg: TypeAlias = Usage
-
-IsExtPar: TypeAlias = (
-    IsResExp | IsResEmn | IsUsdEmn | IsLss | IsUsg | IsOpnEmn | IsUseExp | IsOpnExp
-)
-
-# Balances
-IsBal: TypeAlias = Conversion | Inventory | Freight
-
-# Designators
-# Incidental Parameter
-IsDgn: TypeAlias = I
+IsCnv: TypeAlias = Conversion | Freight | Inventory
 
 # All Parameters
-IsPrm: TypeAlias = IsBndPar | IsExtPar | IsBal | IsDgn
+IsPrm: TypeAlias = BoundPrm | ExactPrm
diff --git a/src/energiapy/core/isalias/elms/isvar.py b/src/energiapy/core/isalias/elms/isvar.py
index f36d6b8c..9d09745b 100644
--- a/src/energiapy/core/isalias/elms/isvar.py
+++ b/src/energiapy/core/isalias/elms/isvar.py
@@ -2,49 +2,9 @@
 """
 
 from typing import TypeAlias
+from ....elements.variables.boundboundvar import BoundBoundVar
+from ....elements.variables.boundvar import BoundVar
+from ....elements.variables.exactvar import ExactVar
 
-from ....elements.variables.act import Give, Take
-from ....elements.variables.emit import (Emit, EmitBuy, EmitLse, EmitSll,
-                                         EmitStp, EmitUse)
-from ....elements.variables.lose import Lose
-from ....elements.variables.operate import Operate
-from ....elements.variables.rate import Rate
-from ....elements.variables.setup import Capacitate
-from ....elements.variables.trade import Buy, Sell, Ship
-from ....elements.variables.transact import (Earn, Spend, TransactBuy,
-                                             TransactCrd, TransactOpr,
-                                             TransactPnt, TransactSll,
-                                             TransactStp, TransactUse)
-from ....elements.variables.use import Use
 
-# Bound Vars
-IsAct: TypeAlias = Give | Take
-IsStp: TypeAlias = Capacitate
-IsOpr: TypeAlias = Operate
-IsTrd: TypeAlias = Buy | Sell | Ship
-IsBndVar: TypeAlias = IsAct | IsStp | IsOpr | IsTrd
-
-# Exact Vars
-# The naming convention is:
-# three character names are used for Parent Variables in the end
-# so VariablePrn
-
-IsEmt: TypeAlias = Emit | EmitBuy | EmitLse | EmitSll | EmitStp | EmitUse
-IsTsc: TypeAlias = (
-    Earn
-    | Spend
-    | TransactBuy
-    | TransactOpr
-    | TransactSll
-    | TransactStp
-    | TransactUse
-    | TransactPnt
-    | TransactCrd
-)
-IsLse: TypeAlias = Lose
-IsRte: TypeAlias = Rate
-IsUse: TypeAlias = Use
-IsExtVar: TypeAlias = IsEmt | IsTsc | IsLse | IsRte | IsUse
-
-# All Variables
-IsVar: TypeAlias = IsBndVar | IsExtVar
+IsVar: TypeAlias = BoundBoundVar | BoundVar | ExactVar
diff --git a/src/energiapy/core/nirop/errors.py b/src/energiapy/core/nirop/errors.py
index 426c5125..4694a5da 100644
--- a/src/energiapy/core/nirop/errors.py
+++ b/src/energiapy/core/nirop/errors.py
@@ -125,3 +125,16 @@ def __init__(self, message: str, component: IsCmp, attr: str, value: Any):
         self.message = f'{value} [{type(value)}] is not a valid input for {component}.{attr}.\n{message}.{msg_bounds}{msg_exact}{msg_alias}'
 
         super().__init__(self.message)
+
+
+class ReservedWord(AttributeError):
+    """Error for reserved words
+
+    Attributes:
+        word (str): Reserved word
+    """
+
+    def __init__(self, word: str):
+        self.message = f'{word} is a reserved word'
+
+        super().__init__(self.message)
diff --git a/src/energiapy/elements/constraints/_constraint.py b/src/energiapy/elements/constraints/_constraint.py
index ee9984c8..62ddf7e7 100644
--- a/src/energiapy/elements/constraints/_constraint.py
+++ b/src/energiapy/elements/constraints/_constraint.py
@@ -4,6 +4,7 @@
 from dataclasses import dataclass, field
 
 from sympy import IndexedBase, Mul, Rel
+from ..disposition.bound import VarBnd
 
 from ...core._handy._dunders import _Dunders
 from ...core.isalias.elms.isprm import IsPrm
@@ -18,6 +19,9 @@ class _Constraint(_Dunders):
     """
 
     variable: IsVar = field(default=None)
+    varbnd: VarBnd = field(default=None)
+    parent: IsVar = field(default=None)
+    parameter: IsPrm = field(default=None)
 
     def __post_init__(self):
         # The index of the constraint is the same as the main Variable
diff --git a/src/energiapy/elements/constraints/bind.py b/src/energiapy/elements/constraints/bind.py
index b90baf9f..1f612a6e 100644
--- a/src/energiapy/elements/constraints/bind.py
+++ b/src/energiapy/elements/constraints/bind.py
@@ -1,10 +1,8 @@
 """Constraint to Bind variable to a lower or upper Parameter or Variable (or both) Bound
 """
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
-from ...core.isalias.elms.isprm import IsPrm
-from ...core.isalias.elms.isvar import IsVar
 from ..disposition.bound import VarBnd
 from ._constraint import _Constraint
 
@@ -13,10 +11,6 @@
 class Bind(_Constraint):
     """Bind variable to another variable or parameter"""
 
-    varbnd: VarBnd = field(default=None)
-    parent: IsVar = field(default=None)
-    parameter: IsPrm = field(default=None)
-
     def __post_init__(self):
         _Constraint.__post_init__(self)
         # Check the bound and add to name and make equality sign
diff --git a/src/energiapy/elements/constraints/calculate.py b/src/energiapy/elements/constraints/calculate.py
index d973d97b..02fe5854 100644
--- a/src/energiapy/elements/constraints/calculate.py
+++ b/src/energiapy/elements/constraints/calculate.py
@@ -1,10 +1,8 @@
 """Constraint to calculate Variable. There is usually a parent Variable associated"""
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
+
 
-from ...core.isalias.elms.isprm import IsPrm
-from ...core.isalias.elms.isvar import IsVar
-from ..disposition.bound import VarBnd
 from ._constraint import _Constraint
 
 
@@ -12,10 +10,6 @@
 class Calculate(_Constraint):
     """Calculates; transactions, emissions, etc."""
 
-    varbnd: VarBnd = field(default=None)
-    parent: IsVar = field(default=None)
-    parameter: IsPrm = field(default=None)
-
     def __post_init__(self):
         _Constraint.__post_init__(self)
 
diff --git a/src/energiapy/elements/parameters/_parameter.py b/src/energiapy/elements/parameters/_parameter.py
index 5e8d9928..2549318c 100644
--- a/src/energiapy/elements/parameters/_parameter.py
+++ b/src/energiapy/elements/parameters/_parameter.py
@@ -17,48 +17,19 @@ class _Parameter(_Dunders, ABC):
     """
 
     value: IsVal = field(default=None)
+    symbol: str = field(default=None)
 
     def __post_init__(self):
         self.index = self.value.index
         self.name = str(self.sym)
+        # unless specified otherwise, the a Variable is equal to this parameter
 
     @property
     @abstractmethod
-    def id(self) -> str:
+    def symib(self):
         """Symbolic representation of the Parameter"""
 
     @property
     def sym(self):
         """Symbol"""
-        return self.id[self.index.sym]
-
-
-# These parameters are exact values for ExactVars
-
-
-@dataclass
-class _ExactPar(_Parameter):
-    """Calculated Parameter"""
-
-    def __post_init__(self):
-        _Parameter.__post_init__(self)
-
-
-# These parameters serve as bounds for BoundVars
-
-
-class _BoundPar(_Parameter):
-    """Bounded Parameter"""
-
-    def __post_init__(self):
-        setattr(self, 'varbnd', self.value.varbnd)
-        _Parameter.__post_init__(self)
-
-    @property
-    def varbnd(self):
-        """Variable Bound"""
-        return self._varbnd
-
-    @varbnd.setter
-    def varbnd(self, varbnd):
-        self._varbnd = varbnd
+        return self.symib[self.index.sym]
diff --git a/src/energiapy/elements/parameters/boundprm.py b/src/energiapy/elements/parameters/boundprm.py
new file mode 100644
index 00000000..6c55cee1
--- /dev/null
+++ b/src/energiapy/elements/parameters/boundprm.py
@@ -0,0 +1,29 @@
+"""Parameter that serves as a bound for a BoundVar
+"""
+
+from dataclasses import dataclass
+from sympy import IndexedBase
+from ._parameter import _Parameter
+
+
+@dataclass
+class BoundPrm(_Parameter):
+    """Bounded Parameter"""
+
+    def __post_init__(self):
+        setattr(self, 'varbnd', self.value.varbnd)
+        _Parameter.__post_init__(self)
+
+    @property
+    def varbnd(self):
+        """Variable Bound"""
+        return self._varbnd
+
+    @varbnd.setter
+    def varbnd(self, varbnd):
+        self._varbnd = varbnd
+
+    @property
+    def symib(self):
+        """Symbolic representation of the Parameter"""
+        return IndexedBase(f'{self.symbol}{self.varbnd.value}')
diff --git a/src/energiapy/elements/parameters/bounds/all.py b/src/energiapy/elements/parameters/bounds/all.py
deleted file mode 100644
index 5b47c322..00000000
--- a/src/energiapy/elements/parameters/bounds/all.py
+++ /dev/null
@@ -1,153 +0,0 @@
-"""Defined Bound Parameters 
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from .._parameter import _BoundPar
-
-
-@dataclass
-class Has(_BoundPar):
-    """Bound on What Commodoties a Player Has"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Has')
-
-
-@dataclass
-class Needs(_BoundPar):
-    """Bound on what Commodities a Player Needs"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Needs')
-
-
-@dataclass
-class BuyBound(_BoundPar):
-    """Buy Bounds"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Buy{self.varbnd.value}')
-
-
-@dataclass
-class SllBound(_BoundPar):
-    """Sell Bounds"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Sell{self.varbnd.value}')
-
-
-@dataclass
-class ShpBound(_BoundPar):
-    """Ship Bounds"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Ship{self.varbnd.value}')
-
-
-@dataclass
-class SpdBound(_BoundPar):
-    """Transact Bound on Spending"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Spend{self.varbnd.value}')
-
-
-@dataclass
-class ErnBound(_BoundPar):
-    """Transact Bound on Earning"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Earn{self.varbnd.value}')
-
-
-@dataclass
-class CapBound(_BoundPar):
-    """Capacitate Bounds"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Capacitate{self.varbnd.value}')
-
-
-@dataclass
-class OprBound(_BoundPar):
-    """Operation Bounds
-    This one is multiplied by capacity
-    """
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Cap_F{self.varbnd.value}')
-
-
-@dataclass
-class UseBound(_BoundPar):
-    """Use Bounds"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """ID"""
-        return IndexedBase(f'Use{self.varbnd.value}')
-
-
-@dataclass
-class EmnBound(_BoundPar):
-    """Bound on Emission"""
-
-    def __post_init__(self):
-        _BoundPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Emit')
diff --git a/src/energiapy/elements/parameters/exactprm.py b/src/energiapy/elements/parameters/exactprm.py
new file mode 100644
index 00000000..9bc0452f
--- /dev/null
+++ b/src/energiapy/elements/parameters/exactprm.py
@@ -0,0 +1,21 @@
+"""Helps calculate ExactVar
+"""
+
+from dataclasses import dataclass
+from sympy import IndexedBase
+
+from ._parameter import _Parameter
+
+
+@dataclass
+class ExactPrm(_Parameter):
+    """Calculated Parameter"""
+
+    def __post_init__(self):
+        _Parameter.__post_init__(self)
+
+
+    @property
+    def symib(self):
+        """Symbolic representation of the Parameter"""
+        return IndexedBase(self.symbol)
diff --git a/src/energiapy/elements/parameters/exacts/emission.py b/src/energiapy/elements/parameters/exacts/emission.py
deleted file mode 100644
index fbae5670..00000000
--- a/src/energiapy/elements/parameters/exacts/emission.py
+++ /dev/null
@@ -1,73 +0,0 @@
-"""Defined Emission Parameters 
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from .._parameter import _ExactPar
-
-
-@dataclass
-class BuyEmission(_ExactPar):
-    """Resource Emission Buy"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Emit^buy')
-
-
-@dataclass
-class SllEmission(_ExactPar):
-    """Resource Emission Sell"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Emit^sell')
-
-
-@dataclass
-class LseEmission(_ExactPar):
-    """Resource Emission Loss"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Emit^lose')
-
-
-@dataclass
-class UseEmission(_ExactPar):
-    """Commodity Emission Use"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Emit^use')
-
-
-@dataclass
-class StpEmission(_ExactPar):
-    """Emission due to setting up operation"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Emit^setup')
diff --git a/src/energiapy/elements/parameters/exacts/expense.py b/src/energiapy/elements/parameters/exacts/expense.py
deleted file mode 100644
index c73fec95..00000000
--- a/src/energiapy/elements/parameters/exacts/expense.py
+++ /dev/null
@@ -1,125 +0,0 @@
-"""Defined Transact Parameters 
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from .._parameter import _ExactPar
-
-
-@dataclass
-class BuyPrice(_ExactPar):
-    """Resource Buy Price"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Price^buy')
-
-
-@dataclass
-class SllPrice(_ExactPar):
-    """Resource Sell Price"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Price^sell')
-
-
-@dataclass
-class SllPenalty(_ExactPar):
-    """Resource Transact Price"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Penalty')
-
-
-@dataclass
-class SllCredit(_ExactPar):
-    """Resource Buy Price"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Credit')
-
-
-@dataclass
-class UseCost(_ExactPar):
-    """Resource Use Transact"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Cost^use')
-
-
-@dataclass
-class StpExpense(_ExactPar):
-    """Operation Capital Transact"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Capex')
-
-
-@dataclass
-class OprExpense(_ExactPar):
-    """Operational Transact"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Opex')
-
-
-@dataclass
-class StpExpenseI(_ExactPar):
-    """Incidental Capital Transact"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Capex^i')
-
-
-@dataclass
-class OprExpenseI(_ExactPar):
-    """Incidental Operational Transact"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Opex^i')
diff --git a/src/energiapy/elements/parameters/exacts/loss.py b/src/energiapy/elements/parameters/exacts/loss.py
deleted file mode 100644
index 2afe88c8..00000000
--- a/src/energiapy/elements/parameters/exacts/loss.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""Defined Loss Parameter
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from .._parameter import _ExactPar
-
-
-@dataclass
-class Loss(_ExactPar):
-    """Resource Loss"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Loss')
diff --git a/src/energiapy/elements/parameters/exacts/usage.py b/src/energiapy/elements/parameters/exacts/usage.py
deleted file mode 100644
index abb91a6e..00000000
--- a/src/energiapy/elements/parameters/exacts/usage.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""Defined Use Parameters
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from .._parameter import _ExactPar
-
-
-@dataclass
-class Usage(_ExactPar):
-    """Material or Land Usage"""
-
-    def __post_init__(self):
-        _ExactPar.__post_init__(self)
-
-    @property
-    def id(self) -> str:
-        """Symbol"""
-        return IndexedBase('Usage')
diff --git a/src/energiapy/elements/values/constant.py b/src/energiapy/elements/values/constant.py
index f7b2c67c..4005b45b 100644
--- a/src/energiapy/elements/values/constant.py
+++ b/src/energiapy/elements/values/constant.py
@@ -10,6 +10,7 @@
 
 from ._value import _Value
 
+
 if TYPE_CHECKING:
     from ...core.isalias.inps.isinp import IsNum
 
@@ -26,6 +27,7 @@ class Constant(_Value):
 
     def __post_init__(self):
         _Value.__post_init__(self)
+        # unless specified otherwise, the a Variable is equal to this parameter
 
     @property
     def value(self) -> IsNum:
diff --git a/src/energiapy/elements/values/dataset.py b/src/energiapy/elements/values/dataset.py
index e97aa9f2..0a5b79e1 100644
--- a/src/energiapy/elements/values/dataset.py
+++ b/src/energiapy/elements/values/dataset.py
@@ -20,6 +20,7 @@ class DataSet(_Value):
 
     def __post_init__(self):
         _Value.__post_init__(self)
+
         # Data has to be provided as a DataFrame
         if not isinstance(self.data, DataFrame):
             raise ValueError(f'{self.name}: please provide DataFrame')
@@ -27,9 +28,7 @@ def __post_init__(self):
         # Data is made into a dictionary with the keys being the indices of the scale
         # will look something like {(0,0): 4, (0,1): 9, (1,0): 2}
         self.data = self.data[self.data.columns[0]].to_dict()
-        self.data = {
-            self.index.scl.index[i]: self.data[i] for i in range(len(self.data))
-        }
+        self.data = {i: self.data[i] for i in range(self.index.scl.discrs)}
 
     @property
     def value(self) -> dict:
diff --git a/src/energiapy/elements/values/theta.py b/src/energiapy/elements/values/theta.py
index b7200de0..d2bcb7c7 100644
--- a/src/energiapy/elements/values/theta.py
+++ b/src/energiapy/elements/values/theta.py
@@ -10,6 +10,7 @@
 
 from ...core._handy._dunders import _Magics
 from ._value import _Value
+from ..disposition.bound import VarBnd
 
 if TYPE_CHECKING:
     from ...core.isalias.inps.isinp import IsSpc
diff --git a/src/energiapy/elements/variables/_variable.py b/src/energiapy/elements/variables/_variable.py
index f99e04ed..45e6f755 100644
--- a/src/energiapy/elements/variables/_variable.py
+++ b/src/energiapy/elements/variables/_variable.py
@@ -1,84 +1,48 @@
-"""Aspect describes the behavior of a component using model elements
+"""General Variable Class
 """
 
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
 
 from sympy import IndexedBase
 
 from ...core._handy._dunders import _Dunders
 from ...core.isalias.cmps.isdfn import IsDfn
 from ...core.nirop.errors import CacodcarError
-
-if TYPE_CHECKING:
-    from ..disposition.index import Index
+from ..disposition.index import Index
 
 
 @dataclass
-class _Variable(_Dunders, ABC):
-    """Component Task"""
+class _Variable(_Dunders):
+    """This is a general Variable
+
+    Attributes:
+        index (Index): Index of the Variable
+        component (IsDfn): Component for which variable is being defined
+        symbol (IndexedBase): Symbolic representation of the Variable
+    """
 
     index: Index = field(default=None)
     component: IsDfn = field(default=None)
+    structures: tuple[str] = field(default=None)
+    symbol: str = field(default=None)
 
     def __post_init__(self):
         self.name = str(self.sym)
 
-        if not self.index.structure() in self.structures(self.component):
-            raise CacodcarError(
-                f'{self}:{self.index.structure()} not in {self.structures(self.component)}'
-            )
-
-    @staticmethod
-    @abstractmethod
-    def id() -> IndexedBase:
-        """Symbolic representation of the Variable"""
-
-    @classmethod
-    @abstractmethod
-    def structures(cls, component) -> list[tuple[str]]:
-        """The allowed structures of Indexs of the Variable"""
+        # if not self.index.structure() in self.structures(self.component):
+        #     raise CacodcarError(
+        #         f'{self}:{self.index.structure()} not in {self.structures(self.component)}'
+        #     )
 
-    @classmethod
-    @abstractmethod
-    def parent(cls) -> _Variable:
-        """The Parent Variable of the Variable"""
+        if not self.symbol:
+            raise ValueError(f'{self}: symbol must be provided')
 
-    @classmethod
-    @abstractmethod
-    def child(cls) -> IsDfn:
-        """The Parent Variable doesnot carry Child Component"""
+    @property
+    def symib(self) -> IndexedBase:
+        """Symbolic representation of the Variable"""
+        return IndexedBase(self.symbol)
 
     @property
     def sym(self):
         """The symbolic representation of the Variable"""
-        return self.id()[self.index.sym]
-
-
-# The ones below are made for the sake of clarity
-# They are the same otherwise
-# That being said, the parents of exacts are usually BoundVars
-# The parents of bounds are usually BoundVars or BinaryVars
-
-
-@dataclass
-class _BoundVar(_Variable):
-    """Bound is a general variable for how much is Bound
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _Variable.__post_init__(self)
-
-
-@dataclass
-class _ExactVar(_Variable):
-    """Exact is a general variable for how much is Exact
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _Variable.__post_init__(self)
+        return self.symib[self.index.sym]
diff --git a/src/energiapy/elements/variables/act.py b/src/energiapy/elements/variables/act.py
deleted file mode 100644
index fa184f25..00000000
--- a/src/energiapy/elements/variables/act.py
+++ /dev/null
@@ -1,66 +0,0 @@
-"""Variables for Actions taken by Players
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar
-
-# ---------------MixIns---------------
-
-
-@dataclass
-class _Act(_BoundVar):
-    """Act is a Player's action
-    This is a parent class
-    """
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(
-            cmd=['csh', 'res', 'mat', 'lnd'],
-            opn=['pro', 'stg', 'trn'],
-            spt=['loc', 'lnk', 'ntw'],
-            ply_strict=True,
-            cmd_strict=False,
-        )
-
-
-# -------------Variables---------------
-
-
-@dataclass
-class Give(_Act):
-    """Give is when a player gives from what they Need(s)"""
-
-    def __post_init__(self):
-        _Act.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """ID to add to name"""
-        return IndexedBase('gives')
-
-
-@dataclass
-class Take(_Act):
-    """Take is when Player takes from what they Has(ve)"""
-
-    def __post_init__(self):
-        _Act.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """ID to add to name"""
-        return IndexedBase('takes')
diff --git a/src/energiapy/elements/variables/boundboundvar.py b/src/energiapy/elements/variables/boundboundvar.py
new file mode 100644
index 00000000..d99de0ce
--- /dev/null
+++ b/src/energiapy/elements/variables/boundboundvar.py
@@ -0,0 +1,29 @@
+"""General Bounded Bound Variable Class
+"""
+
+from dataclasses import dataclass, field
+
+from .boundvar import BoundVar
+
+
+@dataclass
+class BoundBoundVar(BoundVar):
+    """BoundBoundVar is a general variable which is essentially a Bound Variable
+    Bounded by another Bound Variable
+
+    These are a mainstay in multiscale modeling and optimization
+
+    Attributes:
+        index (Index): Index of the Variable
+        component (IsDfn): Component for which variable is being defined
+        symbol (IndexedBase): Symbolic representation of the Variable
+        p (bool): Does it add to the Balance (plus sign)
+        m (bool): Does it subtract from the Balance (minus sign)
+        parent (BoundVar): The Parent Variable of the Variable
+    """
+
+    parent: BoundVar = field(default=None)
+
+    def __post_init__(self):
+        self.p = True
+        BoundVar.__post_init__(self)
diff --git a/src/energiapy/elements/variables/boundvar.py b/src/energiapy/elements/variables/boundvar.py
new file mode 100644
index 00000000..bc0ed8e4
--- /dev/null
+++ b/src/energiapy/elements/variables/boundvar.py
@@ -0,0 +1,33 @@
+"""General Bounded Variable Class
+"""
+
+from dataclasses import dataclass, field
+
+from ._variable import _Variable
+
+
+@dataclass
+class BoundVar(_Variable):
+    """BoundVar is a general variable for how much is Bound
+    This is a parent class
+
+    Attributes:
+        index (Index): Index of the Variable
+        component (IsDfn): Component for which variable is being defined
+        symbol (IndexedBase): Symbolic representation of the Variable
+        p (bool): Does it add to the Balance (plus sign)
+        m (bool): Does it subtract from the Balance (minus sign)
+    """
+
+    p: bool = field(default=False)
+    m: bool = field(default=False)
+
+    def __post_init__(self):
+        _Variable.__post_init__(self)
+        self.parent = None
+
+        if not self.p and not self.m:
+            raise ValueError(f'{self}: p or m must be True')
+
+        if self.p and self.m:
+            raise ValueError(f'{self}: p and m cannot be both True')
diff --git a/src/energiapy/elements/variables/emit.py b/src/energiapy/elements/variables/emit.py
deleted file mode 100644
index 38f3dd44..00000000
--- a/src/energiapy/elements/variables/emit.py
+++ /dev/null
@@ -1,217 +0,0 @@
-"""Emissions from various sources.
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ...components.commodity.emission import Emission
-from ...components.commodity.land import Land
-from ...components.commodity.material import Material
-from ...components.operation.process import Process
-from ...components.operation.storage import Storage
-from ...components.operation.transit import Transit
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar, _ExactVar
-from .lose import Lose
-from .setup import Capacitate
-from .trade import Buy, Sell
-from .use import Use
-
-# ---------------MixIns---------------
-
-
-@dataclass
-class _Emit(_ExactVar):
-    """Emit is a general variable for how much is Emitted
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _ExactVar.__post_init__(self)
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-        return Emission
-
-
-@dataclass
-class _EmitTrd(_Emit):
-    """Resource Emit
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _Emit.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(
-            emission_strict=True, cmd='res', opn='pro', spt=['loc', 'ntw']
-        )
-
-
-# -------------Variables---------------
-
-
-@dataclass
-class Emit(_BoundVar):
-    """Emission emit bound"""
-
-    def __post_init__(self):
-        _BoundVar.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(emission_strict=True, spt=['loc', 'lnk', 'ntw'])
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('emit^sys')
-
-
-@dataclass
-class EmitBuy(_EmitTrd):
-    """Buy Emit"""
-
-    def __post_init__(self):
-        _EmitTrd.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Buy
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('emit^buy')
-
-
-@dataclass
-class EmitSll(_EmitTrd):
-    """Sell Emit"""
-
-    def __post_init__(self):
-        _EmitTrd.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Sell
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('emit^sell')
-
-
-@dataclass
-class EmitLse(_Emit):
-    """Loss Emit"""
-
-    def __post_init__(self):
-        _Emit.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Lose
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        if isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-
-        return make_structures(
-            emission_strict=True, cmd='res', opn=[opn], spt=[spt, 'ntw']
-        )
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('emit^loss')
-
-
-@dataclass
-class EmitUse(_Emit):
-    """Use Emit"""
-
-    def __post_init__(self):
-        _Emit.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Use
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Land):
-            cmd = 'lnd'
-        elif isinstance(component, Material):
-            cmd = 'mat'
-        return make_structures(
-            mde=True,
-            emission_strict=True,
-            cmd=[cmd],
-            opn=['pro', 'stg', 'trn'],
-            spt=['loc', 'lnk', 'ntw'],
-        )
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('emit^use')
-
-
-@dataclass
-class EmitStp(_Emit):
-    """Operation Capacitate related Emit"""
-
-    def __post_init__(self):
-        _Emit.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Capacitate
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        if isinstance(component, Process):
-            opn, spt = 'pro', 'loc'
-        elif isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-
-        return make_structures(
-            mde=True,
-            emission_strict=True,
-            opn=[opn],
-            spt=[spt, 'ntw'],
-        )
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('emit^setup')
diff --git a/src/energiapy/elements/variables/exactvar.py b/src/energiapy/elements/variables/exactvar.py
new file mode 100644
index 00000000..afd64d0b
--- /dev/null
+++ b/src/energiapy/elements/variables/exactvar.py
@@ -0,0 +1,34 @@
+"""General Variable Class which are exact calculations
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from ...core.isalias.cmps.isdfn import IsDfn
+from ._variable import _Variable
+
+if TYPE_CHECKING:
+    from .boundvar import BoundVar
+
+
+@dataclass
+class ExactVar(_Variable):
+    """ExactVar is a general variable for how much is Exact
+    This is a parent class
+
+    Attributes:
+        index (Index): Index of the Variable
+        component (IsDfn): Component for which variable is being defined
+        symbol (IndexedBase): Symbolic representation of the Variable
+        parent (BoundVar): The Parent Variable of the Variable
+        child (IsDfn): The Parent Variable doesnot carry Child Component in Index
+
+    """
+
+    parent: BoundVar = field(default=None)
+    child: IsDfn = field(default=None)
+
+    def __post_init__(self):
+        _Variable.__post_init__(self)
diff --git a/src/energiapy/elements/variables/lose.py b/src/energiapy/elements/variables/lose.py
deleted file mode 100644
index 192389a5..00000000
--- a/src/energiapy/elements/variables/lose.py
+++ /dev/null
@@ -1,47 +0,0 @@
-""" Loss during operation 
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ...components.commodity.resource import Resource
-from ...components.operation.storage import Storage
-from ...components.operation.transit import Transit
-from ..disposition.structure import make_structures
-from ._variable import _ExactVar
-from .operate import Operate
-
-
-@dataclass
-class Lose(_ExactVar):
-    """Lose is when a Resource is lost during operation"""
-
-    def __post_init__(self):
-        _ExactVar.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Operate
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-        return Resource
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-
-        return make_structures(cmd='res', opn=[opn], spt=[spt, 'ntw'])
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('loss')
diff --git a/src/energiapy/elements/variables/operate.py b/src/energiapy/elements/variables/operate.py
deleted file mode 100644
index a42735f9..00000000
--- a/src/energiapy/elements/variables/operate.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""Operate is when you utilize the capacity of an Operation to make a Resource
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ...components.operation.process import Process
-from ...components.operation.storage import Storage
-from ...components.operation.transit import Transit
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar
-from .setup import Capacitate
-
-
-@dataclass
-class Operate(_BoundVar):
-    """Trade changes the ownership of Resource between Players"""
-
-    def __post_init__(self):
-        _BoundVar.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Capacitate
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Process):
-            opn, spt = 'pro', 'loc'
-        elif isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-        return make_structures(
-            opn=[opn],
-            spt=[spt, 'ntw'],
-        )
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('operate')
diff --git a/src/energiapy/elements/variables/rate.py b/src/energiapy/elements/variables/rate.py
deleted file mode 100644
index 42d29f88..00000000
--- a/src/energiapy/elements/variables/rate.py
+++ /dev/null
@@ -1,14 +0,0 @@
-"""Rate Task
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ..disposition.structure import make_structures
-from ._variable import _ExactVar
-
-
-@dataclass
-class Rate(_ExactVar):
-    """Rate"""
diff --git a/src/energiapy/elements/variables/setup.py b/src/energiapy/elements/variables/setup.py
deleted file mode 100644
index c76512ef..00000000
--- a/src/energiapy/elements/variables/setup.py
+++ /dev/null
@@ -1,45 +0,0 @@
-"""Capacitate Operations
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ...components.operation.process import Process
-from ...components.operation.storage import Storage
-from ...components.operation.transit import Transit
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar
-
-
-@dataclass
-class Capacitate(_BoundVar):
-    """Trade changes the ownership of Resource between Players"""
-
-    def __post_init__(self):
-        _BoundVar.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        if isinstance(component, Process):
-            opn, spt = 'pro', 'loc'
-        elif isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-
-        return make_structures(mde=True, opn=[opn], spt=[spt, 'ntw'])
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """ID to add to name"""
-        return IndexedBase('capacity')
diff --git a/src/energiapy/elements/variables/trade.py b/src/energiapy/elements/variables/trade.py
deleted file mode 100644
index b1ca9cfe..00000000
--- a/src/energiapy/elements/variables/trade.py
+++ /dev/null
@@ -1,91 +0,0 @@
-"""Trade Task
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar
-
-# ---------------MixIns---------------
-
-
-@dataclass
-class _Trade(_BoundVar):
-    """Trade changes the ownership of Resource between Players
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _BoundVar.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-
-@dataclass
-class _LocTrade(_Trade):
-    """LocTrade changes the ownership of Resource between Players at a Location
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _Trade.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(cmd='res', opn='pro', spt=['loc', 'ntw'])
-
-
-# -------------Variables---------------
-
-
-@dataclass
-class Buy(_LocTrade):
-    """Buy allows Players to purchase Resource"""
-
-    def __post_init__(self):
-        _LocTrade.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('buy')
-
-
-@dataclass
-class Sell(_LocTrade):
-    """Sell allows Players to Sell Resource"""
-
-    def __post_init__(self):
-        _LocTrade.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('sell')
-
-
-@dataclass
-class Ship(_Trade):
-    """Resource sent out of a Location"""
-
-    def __post_init__(self):
-        _Trade.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(cmd='res', opn='trn', spt=['lnk', 'ntw'])
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('ship')
diff --git a/src/energiapy/elements/variables/transact.py b/src/energiapy/elements/variables/transact.py
deleted file mode 100644
index 6dcf9a3e..00000000
--- a/src/energiapy/elements/variables/transact.py
+++ /dev/null
@@ -1,315 +0,0 @@
-"""Variables for Transact
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ...components.commodity.cash import Cash
-from ...components.commodity.land import Land
-from ...components.commodity.material import Material
-from ...components.operation.process import Process
-from ...components.operation.storage import Storage
-from ...components.operation.transit import Transit
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar, _ExactVar
-from .operate import Operate
-from .setup import Capacitate
-from .trade import Buy, Sell
-from .use import Use
-
-# ---------------MixIns---------------
-
-
-@dataclass
-class _Transact(_BoundVar):
-    """Transact is the cost of a Component
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _BoundVar.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(csh_strict=True, spt=['loc', 'lnk', 'ntw'])
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-
-@dataclass
-class _Exp(_ExactVar):
-    """Transact is the cost of a Component
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _ExactVar.__post_init__(self)
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-        return Cash
-
-
-@dataclass
-class _ExpTrade(_Exp):
-    """Resource Transact
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _Exp.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-        return make_structures(
-            csh_strict=True, cmd='res', opn='pro', spt=['loc', 'ntw']
-        )
-
-
-@dataclass
-class _ExpOpn(_Exp):
-    """Capacitate Transact
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _Exp.__post_init__(self)
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Process):
-            opn, spt = 'pro', 'loc'
-        elif isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-
-        return make_structures(
-            csh_strict=True,
-            mde=True,
-            opn=[opn],
-            spt=[spt, 'ntw'],
-        )
-
-
-@dataclass
-class _ExpOpnI(_ExpOpn):
-    """Incidental Transact for Operation
-    This is a parent class
-    """
-
-    def __post_init__(self):
-        _ExpOpn.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-
-# -------------Variables---------------
-
-
-@dataclass
-class Spend(_Transact):
-    """System Transact"""
-
-    def __post_init__(self):
-        _Transact.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('spend')
-
-
-@dataclass
-class Earn(_Transact):
-    """System Transact"""
-
-    def __post_init__(self):
-        _Transact.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('earn')
-
-
-@dataclass
-class TransactBuy(_ExpTrade):
-    """Buy Transact"""
-
-    def __post_init__(self):
-        _ExpTrade.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Buy
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('exp^buy')
-
-
-@dataclass
-class TransactSll(_ExpTrade):
-    """Sell Transact"""
-
-    def __post_init__(self):
-        _ExpTrade.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Sell
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('exp^sell')
-
-
-@dataclass
-class TransactPnt(_ExpTrade):
-    """Buy Transact"""
-
-    def __post_init__(self):
-        _ExpTrade.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Sell
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('penalty')
-
-
-@dataclass
-class TransactCrd(_ExpTrade):
-    """TransactCrd Earned"""
-
-    def __post_init__(self):
-        _ExpTrade.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Sell
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('credit')
-
-
-@dataclass
-class TransactUse(_Exp):
-    """Use Transact"""
-
-    def __post_init__(self):
-        _Exp.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Use
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Land):
-            cmd = 'lnd'
-        elif isinstance(component, Material):
-            cmd = 'mat'
-        return make_structures(
-            mde=True,
-            csh_strict=True,
-            cmd=[cmd],
-            opn=['pro', 'stg', 'trn'],
-            spt=['loc', 'lnk', 'ntw'],
-        )
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('exp^use')
-
-
-@dataclass
-class TransactStp(_ExpOpn):
-    """Capacitate Transact"""
-
-    def __post_init__(self):
-        _ExpOpn.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Capacitate
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('capex')
-
-
-@dataclass
-class TransactOpr(_ExpOpn):
-    """Operate Transact"""
-
-    def __post_init__(self):
-        _ExpOpn.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Operate
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('opex')
-
-
-@dataclass
-class TransactStpI(_ExpOpnI):
-    """Incidental Capital Transact"""
-
-    def __post_init__(self):
-        _ExpOpnI.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('capex^I')
-
-
-@dataclass
-class TransactOprI(_ExpOpnI):
-    """Incidental Operational Transact"""
-
-    def __post_init__(self):
-        _ExpOpnI.__post_init__(self)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('opex^I')
diff --git a/src/energiapy/elements/variables/use.py b/src/energiapy/elements/variables/use.py
deleted file mode 100644
index ca782e62..00000000
--- a/src/energiapy/elements/variables/use.py
+++ /dev/null
@@ -1,90 +0,0 @@
-""" Use Task 
-"""
-
-from dataclasses import dataclass
-
-from sympy import IndexedBase
-
-from ...components.commodity.land import Land
-from ...components.commodity.material import Material
-from ...components.operation.process import Process
-from ...components.operation.storage import Storage
-from ...components.operation.transit import Transit
-from ..disposition.structure import make_structures
-from ._variable import _BoundVar, _ExactVar
-from .setup import Capacitate
-
-
-@dataclass
-class Use(_BoundVar):
-    """Trade changes the ownership of Useable Commodity between Players"""
-
-    def __post_init__(self):
-        _BoundVar.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Land):
-            cmd = 'lnd'
-        elif isinstance(component, Material):
-            cmd = 'mat'
-        return make_structures(
-            cmd=[cmd],
-            opn=['pro', 'stg', 'trn'],
-            spt=['loc', 'lnk', 'ntw'],
-        )
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('use')
-
-
-@dataclass
-class UseStp(_ExactVar):
-    """Land or Material (Used) Use for Operation Setup"""
-
-    def __post_init__(self):
-        _ExactVar.__post_init__(self)
-
-    @classmethod
-    def parent(cls):
-        """The Parent Task of the Variable"""
-        return Capacitate
-
-    @classmethod
-    def structures(cls, component):
-        """The allowed structures of disposition of the Variable"""
-
-        if isinstance(component, Process):
-            opn, spt = 'pro', 'loc'
-        elif isinstance(component, Storage):
-            opn, spt = 'stg', 'loc'
-        elif isinstance(component, Transit):
-            opn, spt = 'trn', 'lnk'
-        return make_structures(
-            cmd=['lnd', 'mat'],
-            mde=True,
-            opn=[opn],
-            spt=[spt, 'ntw'],
-        )
-
-    @classmethod
-    def child(cls):
-        """The Parent Variable doesnot carry Child Component"""
-        return (Land, Material)
-
-    @staticmethod
-    def id() -> IndexedBase:
-        """Symbol"""
-        return IndexedBase('use^setup')
diff --git a/src/energiapy/environ/_scenario/_birth.py b/src/energiapy/environ/_scenario/_birth.py
index 834d77da..29ceb5d3 100644
--- a/src/energiapy/environ/_scenario/_birth.py
+++ b/src/energiapy/environ/_scenario/_birth.py
@@ -11,13 +11,13 @@
 from ...components.spatial.linkage import Linkage
 from ...components.spatial.location import Location
 from ...components.temporal.scale import Scale
+from ...components.spatial.network import Network
+from ...components.temporal.horizon import Horizon
 
 if TYPE_CHECKING:
     from ...components.commodity.resource import Resource
     from ...components.operation.storage import Storage
     from ...components.operation.transit import Transit
-    from ...components.spatial.network import Network
-    from ...components.temporal.horizon import Horizon
 
 
 class _Birth(ABC):
@@ -27,45 +27,33 @@ class _Birth(ABC):
     def system(self):
         """System Model Block of the Scenario"""
 
-    def birth_scales(self, horizon: Horizon):
+    def birth_partitions(self, scope: Horizon | Network, birth: Scale | Location):
         """Births temporal Scales based on discretizations provided in the Horizon
 
         Args:
-            horizon (IsHorizon): Horizon object
+            scope (Horizon | Network): Scope Component
         """
-        for i in range(horizon.n_scales):
+        for i in range(scope.n_births):
             # labels can be provided. or they are set to t0, t1, t2, ...
 
-            if horizon.label_scales:
-                label_scale = horizon.label_scales[i]
-            else:
-                label_scale = horizon.label_scales
-
             # set the scales as attributes of the Scenario
+
+            if not scope.nested or i == 0:
+                parent = scope
+
+            elif scope.nested and i > 0:
+                parent = getattr(self, scope.birth_names[i - 1])
+
             setattr(
                 self,
-                horizon.name_scales[i],
-                Scale(
-                    index=horizon.make_index(position=i, nested=horizon.nested),
-                    label=label_scale,
+                scope.birth_names[i],
+                birth(
+                    label=scope.birth_labels[i],
+                    parent=parent,
+                    discrs=scope.birth_list[i],
                 ),
             )
 
-    def birth_locations(self, network: Network):
-        """Births Locations based on the locs provided in the Network
-
-        Args:
-            network (IsNetwork): Network object
-        """
-
-        for i in network.locs:
-            if network.label_locs:
-                label_node = network.label_locs[i]
-            else:
-                label_node = network.label_locs
-            # set the locations as attributes of the Scenario
-            setattr(self, i, Location(label=label_node))
-
     def birth_sib_linkage(self, linkage: Linkage):
         """Births a Linkage going in the opposite direction of the provided Linkage
         if bi is set to True
@@ -145,8 +133,8 @@ def birth_bal_processes(self, operation: Storage | Transit, res: Resource):
         conv_out[res] = conv_out[base].pop('r')
 
         # Charging(_in) and Discharging(_out) Processes are birthed
-        process_in = Process(conversion=conv_in, capacity=operation.capacity_in)
-        process_out = Process(conversion=conv_out, capacity=operation.capacity_out)
+        process_in = Process(conversion=conv_in, setup=operation.setup_in)
+        process_out = Process(conversion=conv_out, setup=operation.setup_out)
         processes = [process_in, process_out]
 
         # update processes in Operation
diff --git a/src/energiapy/environ/_scenario/_update.py b/src/energiapy/environ/_scenario/_update.py
index 9281fa89..00d4bc9d 100644
--- a/src/energiapy/environ/_scenario/_update.py
+++ b/src/energiapy/environ/_scenario/_update.py
@@ -146,17 +146,18 @@ def update_model(self, name: str, component: IsDfn):
         setattr(programblock, name, datablock)
 
         # update all the elements related the attributes in the Task Modeling Block
-        for attr, cons in programblock.attr_constraints.items():
-            getattr(self.taskmaster, attr).constraints.extend(cons)
+        # for cons in programblock.constraints:
+        #     print(attr)
+        #     getattr(self.taskmaster, attr).constraints.extend(cons)
 
-        for attr, var in programblock.attr_variables.items():
-            getattr(self.taskmaster, attr).variables.extend(var)
+        # for var in programblock.variables:
+        #     getattr(self.taskmaster, attr).variables.extend(var)
 
-        for attr, par in programblock.attr_parameters.items():
-            getattr(self.taskmaster, attr).parameters.extend(par)
+        # for par in programblock.parameters:
+        #     getattr(self.taskmaster, attr).parameters.extend(par)
 
-        for attr, disp in programblock.attr_indices.items():
-            getattr(self.taskmaster, attr).indices.extend(disp)
+        # for disp in programblock.indices:
+        #     getattr(self.taskmaster, attr).indices.extend(disp)
 
         # The ProgramBlock is also added to the Program Model
         setattr(self.program, name, programblock)
diff --git a/src/energiapy/environ/blocks/program.py b/src/energiapy/environ/blocks/program.py
index bd6e4ec6..1052e919 100644
--- a/src/energiapy/environ/blocks/program.py
+++ b/src/energiapy/environ/blocks/program.py
@@ -3,9 +3,10 @@
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 
+from typing import TYPE_CHECKING
+
 from ...core._handy._dunders import _Dunders
 from ...core._handy._printers import _Print
 from ...core.isalias.cmps.iscmp import IsDsp
@@ -17,18 +18,12 @@
 from ._block import _Block
 from .data import DataBlock
 
+if TYPE_CHECKING:
+    from ...environ.tasks.bound import Bound, BoundBound
+    from ...environ.tasks.calculation import Calculation
 
-class _Fish(ABC):
-
-    @property
-    @abstractmethod
-    def variables(self):
-        """Variables"""
 
-    @property
-    @abstractmethod
-    def indices(self):
-        """Indexs"""
+class _Fish:
 
     def taste_catch(self, catch: list):
         """Tastes the catch, sees if there are multiple fishes (vars)
@@ -39,7 +34,6 @@ def taste_catch(self, catch: list):
         """
         # number of catches
         n_catch = len(catch)
-
         # There can only be one
         if n_catch > 1:
             raise CacodcarError(
@@ -72,7 +66,11 @@ def fish_var(self, var: IsVar, index: Index) -> IsVar:
 
         # seaches for the index in the ProgramBlock and check for multiple instances
         return self.taste_catch(
-            [e for e in self.variables if isinstance(e, var) and e.index == index]
+            [
+                e
+                for e in getattr(self, 'variables')
+                if isinstance(e, var) and e.index == index
+            ]
         )
 
     def fish_idx(self, disposition: IsDsp) -> Index:
@@ -93,7 +91,7 @@ def fish_idx(self, disposition: IsDsp) -> Index:
 
         # seaches for the index in the ProgramBlock and check for multiple instances
         return self.taste_catch(
-            [e for e in self.indices if e.disposition == disposition]
+            [e for e in getattr(self, 'indices') if e.disposition == disposition]
         )
 
 
@@ -110,14 +108,9 @@ class ProgramBlock(_Fish, _Dunders, _Print):
 
     def __post_init__(self):
         self.name = f'Program|{self.component}|'
-        # Declare empty dictionaries to hold the generated elements
-        # the keys are the attributes of the components
-        (
-            self.attr_variables,
-            self.attr_constraints,
-            self.attr_parameters,
-            self.attr_indices,
-        ) = ({inp: [] for inp in self.component.inputs()} for _ in range(4))
+        self.indices, self.parameters, self.variables, self.constraints = (
+            [] for _ in range(4)
+        )
 
     def __setattr__(self, name: str, datablock: DataBlock):
 
@@ -157,15 +150,11 @@ def birth_elements(self, value: IsVal, attr: str):
                 self.birth_elements(value=i, attr=attr)
 
         else:
-            if value.incdntl:
-                # if input value is incidental
-                var = getattr(self.component.taskmaster, attr).var_i
-            else:
-                var = getattr(self.component.taskmaster, attr).var
+            task = getattr(self.component.taskmaster, attr)
 
             # This fishes for an existing Variable
             # if not found births one
-            variable = self.birth_var(var=var, index=value.index, attr=attr)
+            variable = self.birth_var(index=value.index, task=task)
 
             # The Variable can have a:
             # 1. Parent Variable: needed to bound or determine this variable
@@ -175,52 +164,40 @@ def birth_elements(self, value: IsVal, attr: str):
             # In the CapEx example, ExpSetUp has Cash, but Capacitate does not
             # so remove Cash Component in Capacitate Dispositio
 
-            if var.parent():
-                if var.child():
-                    # Fish for an existing Dispostion
-                    # if not found, births one
-                    idx_parent = self.birth_index(
-                        disposition=variable.index.childless(var.child()),
-                        attr=attr,
-                    )
+            if task.parent:
 
-                else:
-                    # if no child then the Parent Index is the same as variable
-                    idx_parent = variable.index
+                # Fish for an existing Dispostion
+                # if not found, births one
+                idx_parent = self.birth_index(
+                    disposition=variable.index.childless(task.root),
+                )
 
                 # This fishes for an existing Parent Variable
                 # if not found births one
-                parent = self.birth_var(var=var.parent(), index=idx_parent, attr=attr)
+                parent = self.birth_var(
+                    index=idx_parent,
+                    task=task.parent,
+                )
 
             else:
                 # Bruce Wayne Variable
                 parent = None
 
-            # Get the rules to generate the constraint
-            # Variables can have multiple rules
-            rules = self.component.rulebook.find(var)
-
-            # So iter over them
-            for rule in rules:
-                if rule.parameter:
-                    # If the rule needs a parameter, then make it
-                    parameter = rule.parameter(value)
-                    self.attr_parameters[attr].append(parameter)
-
-                else:
-                    parameter = None
-
-                # Generate the constraint
-                constraint = rule.constraint(
-                    variable=variable,
-                    parent=parent,
-                    parameter=parameter,
-                    varbnd=value.varbnd,
-                )
-                # update collection
-                self.attr_constraints[attr].append(constraint)
+            parameter = task.prm()(value, symbol=task.prmsym)
+            self.parameters.append(parameter)
+            constraint = task.cns()(
+                variable=variable,
+                parent=parent,
+                parameter=parameter,
+                varbnd=value.varbnd,
+            )
+            self.constraints.append(constraint)
 
-    def birth_var(self, var: IsVar, index: Index, attr: str):
+    def birth_var(
+        self,
+        task: Bound | BoundBound | Calculation,
+        index: Index,
+    ):
         """Creates a variable in the ProgramBlock
         if not found in the ProgramBlock and full Program Model Block
 
@@ -228,7 +205,10 @@ def birth_var(self, var: IsVar, index: Index, attr: str):
             var (IsVar): Variable to be created
             index (Index): Index of the Variable
             attr (str): Attribute of the Component
+            sym (str): Symbol of the Variable
         """
+        varbirth_attrs = task.varbirth_attrs()
+        var = task.var()
 
         # Fish for an existing variable in the ProgramBlock
         catch = self.fish_var(var=var, index=index)
@@ -247,17 +227,16 @@ def birth_var(self, var: IsVar, index: Index, attr: str):
 
             else:
                 # if still nothing found, then create a new one
-                variable = var(index=index, component=self.component)
-                # Update the collections
-                self.attr_variables[attr].append(variable)
+                variable = var(index=index, component=self.component, **varbirth_attrs)
 
+                self.variables.append(variable)
                 # Update the Registrar with the new Index
-                # at which var is defined
-                self.component.registrar.register(var, index)
+                # at which task is defined
+                self.component.registrar.register(task, index)
 
                 return variable
 
-    def birth_index(self, disposition: IsDsp, attr: str):
+    def birth_index(self, disposition: IsDsp):
         """Searchs for an Index with the give dispostion in the ProgramBlock
         If not found, looks for one in the full Program Model Block
         if not found in the ProgramBlock and full Program Model Block
@@ -265,7 +244,6 @@ def birth_index(self, disposition: IsDsp, attr: str):
 
         Args:
             index (Index): Index of the Index
-            attr (str): Attribute of the Component
         """
 
         # Fish for an existing index in the ProgramBlock
@@ -286,10 +264,7 @@ def birth_index(self, disposition: IsDsp, attr: str):
             else:
                 # if still nothing found, then create a new index
                 idx = Index(**disposition)
-
-                # Update the collections
-                self.attr_indices[attr].append(idx)
-
+                self.indices.append(idx)
                 return idx
 
     @property
@@ -302,26 +277,6 @@ def var_types(self):
         """Returns all variables types already declared in the ProgramBlock"""
         return [type(i) for i in self.variables]
 
-    @property
-    def variables(self):
-        """Returns all variables in the ProgramBlock"""
-        return sum(list(self.attr_variables.values()), [])
-
-    @property
-    def constraints(self):
-        """Returns all constraints in the ProgramBlock"""
-        return sum(list(self.attr_constraints.values()), [])
-
-    @property
-    def parameters(self):
-        """Returns all parameters in the ProgramBlock"""
-        return sum(list(self.attr_parameters.values()), [])
-
-    @property
-    def indices(self):
-        """Returns all indices in the ProgramBlock"""
-        return sum(list(self.attr_indices.values()), [])
-
     def eqns(self, at_cmp: IsDfn = None, at_disp: IsDsp = None):
         """Yields all equations in the ProgramBlock
 
diff --git a/src/energiapy/environ/datum.py b/src/energiapy/environ/datum.py
index 4da1cbe6..4d7a565f 100644
--- a/src/energiapy/environ/datum.py
+++ b/src/energiapy/environ/datum.py
@@ -150,7 +150,6 @@ def update_data(self):
             # Check whether the input value type is appropriate
             # if not raises an InputTypeError
             self.check_type(val)
-
             dict_upd[disp] = val
 
         # update the input with a dictionary {Index: value}
@@ -170,7 +169,7 @@ def get(self, n: IsDsp | int | None = None) -> IsVal:
         Examples:
             Declare some Scenario, Horizon, and Network
             >>> s = Scenario()
-            >>> s.hrz = Horizon(discretizations=[2, 12])
+            >>> s.hrz = Horizon(birth=[2, 12])
             >>> s.ntw = Network(['madgaon', 'ponje'])
             Here we are setting the cash spend at madgaon for t2
             i.e. Do not spend more than 50 money in any time period in Scale t2 at Location madgaon
@@ -254,7 +253,11 @@ def check_type(self, value: IsBndInp | IsExtInp | IsIncInp):
                 value,
             )
 
-        if self.attr in self.component.bounds():
+        if (
+            self.attr
+            in self.component.taskmaster.bounds()
+            + self.component.taskmaster.boundbounds()
+        ):
             # Bound inputs cannot be:
             # sets - used only in the special case when there is an incidental parameter
             if not isinstance(value, (int, float, list, bool, DataFrame, tuple)):
@@ -265,7 +268,7 @@ def check_type(self, value: IsBndInp | IsExtInp | IsIncInp):
                     value,
                 )
 
-        if self.attr in self.component.exacts():
+        if self.attr in self.component.taskmaster.exacts():
             # Exact inputs cannot be:
             # lists - used for upper and lower bounds
             # bool (True) - used for BigM
diff --git a/src/energiapy/environ/engines/registrar.py b/src/energiapy/environ/engines/registrar.py
index e91762fd..b529040b 100644
--- a/src/energiapy/environ/engines/registrar.py
+++ b/src/energiapy/environ/engines/registrar.py
@@ -1,13 +1,14 @@
-"""Keeps a track of what elements are defined at what dispostions  
+"""Keeps a track of what tasks have been defined at what indices
 """
 
 from dataclasses import dataclass, field
 
+from .taskmaster import Chanakya
 from ...core._handy._dunders import _Dunders
-from ...core.isalias.elms.iselm import IsElm
 from ...core.nirop.errors import CacodcarError
 from ...elements.disposition.index import Index
-from .rulebook import Bhaskara
+from ...environ.tasks.bound import Bound, BoundBound
+from ...environ.tasks.calculation import Calculation
 
 
 @dataclass
@@ -16,33 +17,45 @@ class ChitraGupta(_Dunders):
 
     Attributes:
         name (str): name, takes from the name of the Scenario
-        rulebook: Bhaskara = field(default_factory=rulebook)
+        taskmaster: Chanakya
 
     """
 
     name: str = field(default=None)
-    rulebook: Bhaskara = field(default=None)
+    taskmaster: Chanakya = field(default=None)
 
     def __post_init__(self):
 
         self.name = f'Registrar|{self.name}|'
+        self.pbounds, self.mbounds, self.boundbounds, self.calculations = (
+            {} for _ in range(4)
+        )
 
-        for var in self.rulebook.vars():
-            setattr(self, var.cname(), [])
-
-        for prm in self.rulebook.prms():
-            setattr(self, prm.cname(), [])
-
-    def register(self, elm: IsElm, index: Index):
+    def register(self, task: Bound | BoundBound | Calculation, index: Index):
         """Register that a Variable or Parameter has been declared at a particular Index
 
         Args:
-            elm (IsElm): Element to update
-            index (Index): with this Index
+            task (Bound | BoundBound | Calculation): task
+            index (Index): index
         """
 
-        # Only unique instances of indices are allowed
-        if index in getattr(self, elm.cname()):
-            raise CacodcarError(f'{elm} already has {index} in {self.name}')
+        if isinstance(task, Bound):
+            collection = (
+                getattr(self, 'pbounds') if task.p else getattr(self, 'mbounds')
+            )
+
+        if isinstance(task, BoundBound):
+            collection = getattr(self, 'boundbounds')
+
+        if isinstance(task, Calculation):
+            collection = getattr(self, 'calculations')
+
+        if task.name in collection:
+
+            if index in collection[task.name]:
+                raise CacodcarError(f'{task} already has {index} in {self.name}')
+
+            collection[task.name].append(index)
 
-        getattr(self, elm.cname()).append(index)
+        else:
+            collection[task.name] = [index]
diff --git a/src/energiapy/environ/engines/rulebook.py b/src/energiapy/environ/engines/rulebook.py
index e28e5ef3..ebaf871c 100644
--- a/src/energiapy/environ/engines/rulebook.py
+++ b/src/energiapy/environ/engines/rulebook.py
@@ -7,61 +7,6 @@
 from ...core._handy._dunders import _Dunders
 from ...core.isalias.elms.isvar import IsVar
 from ...core.nirop.errors import CacodcarError
-from ...elements.constraints.bind import Bind
-from ...elements.constraints.calculate import Calculate
-from ...elements.parameters.bounds.all import (
-    BuyBound,
-    CapBound,
-    EmnBound,
-    ErnBound,
-    Has,
-    Needs,
-    OprBound,
-    ShpBound,
-    SllBound,
-    SpdBound,
-    UseBound,
-)
-from ...elements.parameters.exacts.emission import (
-    BuyEmission,
-    LseEmission,
-    SllEmission,
-    StpEmission,
-    UseEmission,
-)
-from ...elements.parameters.exacts.expense import (
-    BuyPrice,
-    OprExpense,
-    OprExpenseI,
-    SllCredit,
-    SllPenalty,
-    SllPrice,
-    StpExpense,
-    StpExpenseI,
-    UseCost,
-)
-from ...elements.parameters.exacts.loss import Loss
-from ...elements.parameters.exacts.usage import Usage
-from ...elements.variables.act import Give, Take
-from ...elements.variables.emit import Emit, EmitBuy, EmitLse, EmitSll, EmitStp, EmitUse
-from ...elements.variables.lose import Lose
-from ...elements.variables.operate import Operate
-from ...elements.variables.setup import Capacitate
-from ...elements.variables.trade import Buy, Sell, Ship
-from ...elements.variables.transact import (
-    Earn,
-    Spend,
-    TransactBuy,
-    TransactCrd,
-    TransactOpr,
-    TransactOprI,
-    TransactPnt,
-    TransactSll,
-    TransactStp,
-    TransactStpI,
-    TransactUse,
-)
-from ...elements.variables.use import Use, UseStp
 from ..rule import Rule
 
 
@@ -78,67 +23,6 @@ class Bhaskara(_Dunders):
     def __post_init__(self):
         self.rules = []
         self.name = f'RuleBook|{self.name}|'
-        # Bounded
-        trade_bnd = [(Buy, BuyBound), (Sell, SllBound), (Ship, ShpBound)]
-        cap_bnd = [(Capacitate, CapBound)]
-        op_bnd = [(Operate, OprBound)]
-        exp_bnd = [(Spend, SpdBound), (Earn, ErnBound)]
-        emission_bnd = [(Emit, EmnBound)]
-        ply_bnd = [(Give, Has), (Take, Needs)]
-        use_bnd = [(Use, UseBound)]
-
-        # Calculated
-        use_cmd = [(UseStp, Usage)]
-        loss = [(Lose, Loss)]
-
-        # Calculated Transacts
-        exp_res = [
-            (TransactBuy, BuyPrice),
-            (TransactSll, SllPrice),
-            (TransactCrd, SllCredit),
-            (TransactPnt, SllPenalty),
-        ]
-        exp_use = [(TransactUse, UseCost)]
-        exp_opn = [
-            (TransactOpr, OprExpense),
-            (TransactStp, StpExpense),
-            (TransactOprI, OprExpenseI),
-            (TransactStpI, StpExpenseI),
-        ]
-
-        # Calculated Emissions
-        emit = [
-            (EmitBuy, BuyEmission),
-            (EmitSll, SllEmission),
-            (EmitUse, UseEmission),
-            (EmitStp, StpEmission),
-            (EmitLse, LseEmission),
-        ]
-
-        # Bind Constraints
-
-        for var, param in (
-            trade_bnd + cap_bnd + op_bnd + exp_bnd + emission_bnd + ply_bnd + use_bnd
-        ):
-
-            self.make(
-                Rule(
-                    variable=var,
-                    parameter=param,
-                    constraint=Bind,
-                )
-            )
-
-        # Exact Constraints
-
-        for var, param in use_cmd + loss + exp_res + exp_use + exp_opn + emit:
-            self.make(
-                Rule(
-                    variable=var,
-                    parameter=param,
-                    constraint=Calculate,
-                )
-            )
 
     def make(self, rule: Rule):
         """Make and add Rule to RuleBook"""
diff --git a/src/energiapy/environ/engines/taskmaster.py b/src/energiapy/environ/engines/taskmaster.py
index 1cd2103f..516db61d 100644
--- a/src/energiapy/environ/engines/taskmaster.py
+++ b/src/energiapy/environ/engines/taskmaster.py
@@ -32,38 +32,26 @@
     _TscExacts,
     _UseExacts,
 )
+from ...core._handy._dunders import _Dunders
+from ..tasks.report import Report
+from ..tasks.bound import Bound, BoundBound
+from ..tasks.calculation import Calculation
+from ..tasks.balancing import Balancing
+
 from ...components.analytical.player import Player
 from ...components.commodity.cash import Cash
 from ...components.commodity.emission import Emission
-from ...components.commodity.land import Land
-from ...components.commodity.material import Material
 from ...components.commodity.resource import Resource
 from ...components.operation.process import Process
 from ...components.operation.storage import Storage
 from ...components.operation.transit import Transit
-from ...core._handy._dunders import _Dunders
-from ...elements.variables.act import Give, Take
-from ...elements.variables.emit import Emit, EmitBuy, EmitLse, EmitSll, EmitStp, EmitUse
-from ...elements.variables.lose import Lose
-from ...elements.variables.operate import Operate
-from ...elements.variables.setup import Capacitate
-from ...elements.variables.trade import Buy, Sell, Ship
-from ...elements.variables.transact import (
-    Earn,
-    Spend,
-    TransactBuy,
-    TransactCrd,
-    TransactOpr,
-    TransactOprI,
-    TransactPnt,
-    TransactSll,
-    TransactStp,
-    TransactStpI,
-    TransactUse,
-)
-from ...elements.variables.use import Use, UseStp
-from ..report import Report
-from ..task import Task
+from ...components.operation._operation import _Operation
+from ...components.commodity._used import _Used
+from ...components.temporal.horizon import Horizon
+
+from ...elements.parameters.balances.conversion import Conversion
+from ...elements.parameters.balances.freight import Freight
+from ...elements.parameters.balances.inventory import Inventory
 
 
 @dataclass
@@ -85,32 +73,81 @@ class _Bounds(
 
     def __post_init__(self):
         # Player
-        self.has = Task(attr='has', root=[Player], var=Give)
-        self.needs = Task(attr='needs', root=[Player], var=Take)
+        self.has = Bound(name='has', root=Player, p=True, varsym='give', prmsym='Has')
+        self.needs = Bound(
+            name='needs', root=Player, m=True, varsym='take', prmsym='Needs'
+        )
         # Cash
-        self.spend = Task(attr='spend', root=[Cash], var=Spend)
-        self.earn = Task(attr='earn', root=[Cash], var=Earn)
+        self.spend = Bound(
+            name='spend', root=Cash, p=True, varsym='spend', prmsym='Spend'
+        )
+        self.earn = Bound(name='earn', root=Cash, m=True, varsym='earn', prmsym='Earn')
         # Emission
-        self.emit = Task(attr='emit', root=[Emission], var=Emit)
-        # Land and Material (Used)
-        self.use = Task(attr='use', root=[Land, Material], var=Use)
+        self.emit = Bound(
+            name='emit', root=Emission, p=True, varsym='emit', prmsym='Emit'
+        )
+        self.sequester = Bound(
+            name='sequester',
+            root=Emission,
+            m=True,
+            varsym='sequester',
+            prmsym='Sequester',
+        )
+        # Material | Land
+        self.use = Bound(name='use', root=_Used, p=True, varsym='use', prmsym='Use')
+        self.dispose = Bound(
+            name='dispose', root=_Used, m=True, varsym='dispose', prmsym='Dispose'
+        )
         # Resource
-        self.buy = Task(attr='buy', root=[Resource], var=Buy, other=[Process])
-        self.sell = Task(attr='sell', root=[Resource], var=Sell, other=[Process])
-        self.ship = Task(attr='ship', root=[Resource], var=Ship, other=[Transit])
+        self.buy = Bound(name='buy', root=Resource, p=True, varsym='buy', prmsym='Buy')
+        self.sell = Bound(
+            name='sell', root=Resource, m=True, varsym='sell', prmsym='Sell'
+        )
+        self.ship = Bound(
+            name='ship', root=Resource, p=True, varsym='ship', prmsym='Ship'
+        )
+        self.lose = Bound(
+            name='lose', root=Resource, p=True, varsym='lose', prmsym='Lose'
+        )
         # Operational
-        self.capacity = Task(
-            attr='capacity', root=[Process, Storage, Transit], var=Capacitate
+        self.setup = Bound(
+            name='setup',
+            root=_Operation,
+            p=True,
+            varsym='capacity^add',
+            prmsym='Capacity^add',
+        )
+        self.dismantle = Bound(
+            name='dismantle',
+            root=_Operation,
+            m=True,
+            varsym='capacity^rmv',
+            prmsym='Capacity^rmv',
         )
-        # self.operate = Task(
-        #     attr='operate', root=[Process, Storage, Transit], var=Operate
-        # )
         # Process
-        self.produce = Task(attr='produce', root=[Process], var=Operate)
+        self.produce = BoundBound(
+            name='produce',
+            root=Process,
+            varsym='produce',
+            parent=self.setup,
+            prmsym='Cap^F',
+        )
         # Storage
-        self.store = Task(attr='store', root=[Storage], var=Operate)
+        self.store = BoundBound(
+            name='store',
+            root=Storage,
+            varsym='store',
+            parent=self.setup,
+            prmsym='Cap^F',
+        )
         # Transit
-        self.transport = Task(attr='transport', root=[Transit], var=Operate)
+        self.transport = BoundBound(
+            name='transport',
+            root=Transit,
+            varsym='transport',
+            parent=self.setup,
+            prmsym='Cap^F',
+        )
 
     @staticmethod
     def bounds():
@@ -118,14 +155,26 @@ def bounds():
 
         return sum(
             [
-                [f.name for f in fields(bln)]
-                for bln in [
+                [f.name for f in fields(bnds)]
+                for bnds in [
                     _PlyBounds,
                     _CshBounds,
                     _EmnBounds,
                     _UsdBounds,
                     _ResBounds,
                     _OpnBounds,
+                ]
+            ],
+            [],
+        )
+
+    @staticmethod
+    def boundbounds():
+        """Returns all BoundBounds"""
+        return sum(
+            [
+                [f.name for f in fields(bnds)]
+                for bnds in [
                     _ProBounds,
                     _StgBounds,
                     _TrnBounds,
@@ -136,7 +185,7 @@ def bounds():
 
 
 @dataclass
-class _Exacts(_TscExacts, _EmnExacts, _UseExacts, _LseExacts, _RteExacts):
+class _Exacts(_Bounds, _TscExacts, _EmnExacts, _UseExacts, _LseExacts, _RteExacts):
     """These are Exact Component Inputs
 
     These are inherited across all Spatial Components
@@ -147,80 +196,191 @@ class _Exacts(_TscExacts, _EmnExacts, _UseExacts, _LseExacts, _RteExacts):
     """
 
     def __post_init__(self):
+        _Bounds.__post_init__(self)
         # ---------Transacts---------
         # Resource
-        self.buy_price = Task(
-            attr='buy_price',
-            root=[Resource],
-            var=TransactBuy,
-            other=[Process],
+        self.buy_price = Calculation(
+            name='buy_price',
+            root=Cash,
+            varsym='exp^buy',
+            parent=self.buy,
+            prmsym='Price^buy',
         )
-        self.sell_price = Task(
-            attr='sell_price', root=[Resource], var=TransactSll, other=[Process]
+        self.sell_price = Calculation(
+            name='sell_price',
+            root=Cash,
+            varsym='exp^sell',
+            parent=self.sell,
+            prmsym='Price^sell',
         )
-        self.credit = Task(
-            attr='credit', root=[Resource], var=TransactCrd, other=[Process]
+        self.credit = Calculation(
+            name='credit',
+            root=Cash,
+            varsym='exp^credit',
+            parent=self.sell,
+            prmsym='Credit',
         )
-        self.penalty = Task(
-            attr='penalty', root=[Resource], var=TransactPnt, other=[Process]
+        self.penalty = Calculation(
+            name='penalty',
+            root=Cash,
+            varsym='exp^penalty',
+            parent=self.sell,
+            prmsym='Penalty',
         )
         # Land and Material (Used)
-        self.use_cost = Task(
-            attr='use_cost', root=[Land, Material], var=TransactUse, other=[Process]
+        self.use_cost = Calculation(
+            name='use_cost',
+            root=Cash,
+            varsym='exp^use',
+            parent=self.use,
+            prmsym='Cost^use',
+        )
+        self.dispose_cost = Calculation(
+            name='dispose_cost',
+            root=Cash,
+            varsym='exp^dsp',
+            parent=self.dispose,
+            prmsym='Cost^dsp',
         )
         # Operational
-        self.capex = Task(
-            attr='capex',
-            root=[Process, Storage, Transit],
-            var=TransactStp,
-            var_i=TransactStpI,
+        self.capex = Calculation(
+            name='capex',
+            root=Cash,
+            varsym='exp^capex',
+            parent=self.setup,
+            prmsym='Capex',
         )
-        self.opex = Task(
-            attr='opex',
-            root=[Process, Storage, Transit],
-            var=TransactOpr,
-            var_i=TransactOprI,
+        self.opex = Calculation(
+            name='opex',
+            root=Cash,
+            varsym='exp^opex',
+            parent=self.produce,
+            prmsym='Opex',
         )
-
         # ---------Emissions---------
         # Resource
-        self.buy_emission = Task(
-            attr='buy_emission', root=[Resource], var=EmitBuy, other=[Process]
+        self.buy_emit = Calculation(
+            name='buy_emit',
+            root=Emission,
+            varsym='emit^buy',
+            parent=self.buy,
+            prmsym='Emit^buy',
+        )
+        self.buy_sequester = Calculation(
+            name='buy_sequester',
+            root=Emission,
+            varsym='sequester^buy',
+            parent=self.buy,
+            prmsym='Sequester^buy',
         )
-        self.sell_emission = Task(
-            attr='sell_emission', root=[Resource], var=EmitSll, other=[Process]
+        self.sell_emit = Calculation(
+            name='sell_emit',
+            root=Emission,
+            varsym='emit^sell',
+            parent=self.sell,
+            prmsym='Emit^sell',
         )
-        self.loss_emission = Task(
-            attr='loss_emission',
-            root=[Resource],
-            var=EmitLse,
-            other=[Storage, Transit],
+        self.sell_sequester = Calculation(
+            name='sell_sequester',
+            root=Emission,
+            varsym='sequester^sell',
+            parent=self.sell,
+            prmsym='Sequester^sell',
+        )
+        self.lose_emit = Calculation(
+            name='lose_emit',
+            root=Emission,
+            varsym='emit^lose',
+            parent=self.lose,
+            prmsym='Emit^lose',
         )
         # Land and Material (Used)
-        self.use_emission = Task(
-            attr='use_emission', root=[Land, Material], var=EmitUse
+        self.use_emit = Calculation(
+            name='use_emit',
+            root=Emission,
+            varsym='emit^use',
+            parent=self.use,
+            prmsym='Emit^use',
+        )
+        self.use_sequester = Calculation(
+            name='use_sequester',
+            root=Emission,
+            varsym='sequester^use',
+            parent=self.use,
+            prmsym='Sequester^use',
+        )
+        self.dispose_emit = Calculation(
+            name='dispose_emit',
+            root=Emission,
+            varsym='emit^dispose',
+            parent=self.dispose,
+            prmsym='Emit^dispose',
         )
         # Operational
-        self.setup_emission = Task(
-            attr='setup_emission', root=[Process, Storage, Transit], var=EmitStp
+        self.setup_emit = Calculation(
+            name='setup_emit',
+            root=Emission,
+            varsym='emit^setup',
+            parent=self.setup,
+            prmsym='Emit^setup',
+        )
+        self.setup_sequester = Calculation(
+            name='setup_sequester',
+            root=Emission,
+            varsym='sequester^setup',
+            parent=self.setup,
+            prmsym='Sequester^setup',
+        )
+        self.dismantle_emit = Calculation(
+            name='dismantle_emit',
+            root=Emission,
+            varsym='emit^dismantle',
+            parent=self.dismantle,
+            prmsym='Emit^dismantle',
         )
-
         # ---------Uses---------
         # Operational
-        self.setup_use = Task(
-            attr='setup_use', root=[Process, Storage, Transit], var=UseStp
+        self.setup_use = Calculation(
+            name='setup_use',
+            root=_Used,
+            varsym='use^setup',
+            parent=self.setup,
+            prmsym='Use^setup',
         )
-
         # ---------Losses---------
         # Storage Operation
-        self.inventory_loss = Task(attr='inventory_loss', root=[Storage], var=Lose)
+        self.inventory_loss = Calculation(
+            name='inventory_loss',
+            root=Resource,
+            varsym='lose^stg',
+            parent=self.store,
+            prmsym='Loss^stg',
+        )
         # Transit Operation
-        self.freight_loss = Task(attr='freight_loss', root=[Transit], var=Lose)
+        self.freight_loss = Calculation(
+            name='freight_loss',
+            root=Resource,
+            varsym='lose^trn',
+            parent=self.transport,
+            prmsym='Loss^trn',
+        )
         # ---------Rates---------
         # Operational
-        self.setup_time = Task(attr='setup_time', root=[Process, Storage, Transit])
+        self.setup_time = Calculation(
+            name='setup_time',
+            root=Horizon,
+            varsym='time^setup',
+            parent=self.setup,
+            prmsym='τ',
+        )
         # Transit Operation
-        self.speed = Task(attr='speed', root=[Transit])
+        self.speed = Calculation(
+            name='speed',
+            root=Horizon,
+            varsym='speed',
+            parent=self.transport,
+            prmsym='Speed',
+        )
 
     @staticmethod
     def transactions():
@@ -265,18 +425,37 @@ def exacts():
 
 
 @dataclass
-class _Balances(_ProBalance, _StgBalance, _TrnBalance):
+class _Balances(_Exacts, _ProBalance, _StgBalance, _TrnBalance):
     """These are Balances for Resources
     defined at Operational Components
     """
 
     def __post_init__(self):
+        _Exacts.__post_init__(self)
         # Process
-        self.conversion = Task(attr='conversion', root=[Process])
+        self.conversion = Balancing(
+            name='conversion',
+            opn=Process,
+            balance=Conversion,
+            prmsym='η',
+            parent=self.produce,
+        )
         # Storage
-        self.inventory = Task(attr='inventory', root=[Storage])
+        self.inventory = Balancing(
+            name='inventory',
+            opn=Storage,
+            balance=Inventory,
+            prmsym='φ',
+            parent=self.store,
+        )
         # Transit
-        self.freight = Task(attr='freight', root=[Transit])
+        self.freight = Balancing(
+            name='freight',
+            opn=Transit,
+            balance=Freight,
+            prmsym='ψ',
+            parent=self.transport,
+        )
 
     @staticmethod
     def balances():
@@ -291,7 +470,7 @@ def balances():
 
 
 @dataclass
-class Chanakya(_Balances, _Bounds, _Exacts, _Dunders):
+class Chanakya(_Balances, _Dunders):
     """This object collects all the attributes defined
     and makes a list of Indexs they are defined at
 
@@ -302,8 +481,6 @@ class Chanakya(_Balances, _Bounds, _Exacts, _Dunders):
     def __post_init__(self):
         self.name = f'TaskMaster|{self.name}|'
         _Balances.__post_init__(self)
-        _Bounds.__post_init__(self)
-        _Exacts.__post_init__(self)
 
     @property
     def report_transactions(self):
@@ -322,10 +499,10 @@ def report_uses(self):
         )
 
     @property
-    def report_emissions(self):
+    def report_emits(self):
         """Collection of Emissions"""
         return Report(
-            name='emissions',
+            name='emits',
             tasks=[getattr(self, attr) for attr in self.emissions()],
         )
 
@@ -351,3 +528,7 @@ def vars(self):
             },
             key=lambda x: x.cname(),
         )
+
+    def birth_attrs(self, task: str):
+        """Returns all Attributes need to birth Variables"""
+        return getattr(self, task).birth_attrs()
diff --git a/src/energiapy/environ/engines/taskmaster2.py b/src/energiapy/environ/engines/taskmaster2.py
deleted file mode 100644
index 07f2aa21..00000000
--- a/src/energiapy/environ/engines/taskmaster2.py
+++ /dev/null
@@ -1,373 +0,0 @@
-""" This has three objects
-Task: 
-    individual attributes of Components
-Reports:
-    collections of Component attributes 
-    this is helpful when Commodity attributes are declared at Operations
-Task: 
-    Consists of: Bounds, Exacts, TaskBalances
-    All TaskBlocks, there is only one instance of this in the Scenario
-    Handles the attributes of components
-    Defines strict behaviour
-"""
-
-from dataclasses import asdict, dataclass, field, fields
-
-from ...components._attrs._balances import _ProBalance, _StgBalance, _TrnBalance
-from ...components._attrs._bounds import (
-    _CshBounds,
-    _EmnBounds,
-    _OpnBounds,
-    _PlyBounds,
-    _ProBounds,
-    _ResBounds,
-    _StgBounds,
-    _TrnBounds,
-    _UsdBounds,
-)
-from ...components._attrs._exacts import (
-    _EmnExacts,
-    _LseExacts,
-    _RteExacts,
-    _TscExacts,
-    _UseExacts,
-)
-from ...core._handy._dunders import _Dunders
-from ...elements.variables.act import Give, Take
-from ...elements.variables.emit import Emit, EmitBuy, EmitLse, EmitSll, EmitStp, EmitUse
-from ...elements.variables.lose import Lose
-from ...elements.variables.operate import Operate
-from ...elements.variables.setup import Capacitate
-from ...elements.variables.trade import Buy, Sell, Ship
-from ...elements.variables.transact import (
-    Earn,
-    Spend,
-    TransactBuy,
-    TransactCrd,
-    TransactOpr,
-    TransactOprI,
-    TransactPnt,
-    TransactSll,
-    TransactStp,
-    TransactStpI,
-    TransactUse,
-)
-from ...elements.variables.use import Use, UseStp
-from ..report import Report
-from ..task import Task2
-
-act = {
-    'ply': True,
-    'csh': True,
-    'res': True,
-    'mat': True,
-    'lnd': True,
-    'pro': True,
-    'stg': True,
-    'trn': True,
-    'loc': True,
-    'lnk': True,
-    'ntw': True,
-}
-
-emit = {
-    'emn': True,
-    'pro': True,
-    'stg': True,
-    'trn': True,
-    'loc': True,
-    'lnk': True,
-    'ntw': True,
-}
-
-transact = {
-    'csh': True,
-}
-
-
-@dataclass
-class _Bounds(
-    _PlyBounds,
-    _CshBounds,
-    _EmnBounds,
-    _UsdBounds,
-    _ResBounds,
-    _OpnBounds,
-    _ProBounds,
-    _StgBounds,
-    _TrnBounds,
-):
-    """These are Bounds for the Components
-
-    Bounds can be different for Network and individual Spatial Components
-    """
-
-    def __post_init__(self):
-        # Player
-        self.has = Task2(attr='has', var=Give, **act)
-        self.needs = Task2(attr='needs', var=Take, **act)
-        # Emission
-        self.emit = Task2(attr='emit', var=Emit, **emit)
-        self.emit = Task2(attr='abate', var=Emit, **emit)
-        # Cash
-        self.spend = Task2(
-            attr='spend',
-            csh=True,
-            var=Spend,
-        )
-        self.earn = Task2(attr='earn', csh=True, var=Earn)
-        # Land and Material (Used)
-        self.use = Task2(attr='use', mat=True, lnd=True, var=Use)
-        self.dispose = Task2(attr='dispose', mat=True, lnd=True, var=Use)
-        # Resource
-        self.buy = Task2(attr='buy', res=True, var=Buy, pro=True)
-        self.sell = Task2(attr='sell', res=True, var=Sell, pro=True)
-        self.ship = Task2(attr='ship', res=True, var=Ship, trn=True)
-        # Operational
-        self.capacity = Task2(
-            attr='capacity', pro=True, stg=True, trn=True, var=Capacitate
-        )
-        # self.operate = Task2(
-        #     attr='operate', pro= True, stg=True, trn = True, var=Operate
-        # )
-        # Process
-        self.produce = Task2(attr='produce', pro=True, var=Operate)
-        # Storage
-        self.store = Task2(attr='store', stg=True, var=Operate)
-        # Transit
-        self.transport = Task2(attr='transport', trn=True, var=Operate)
-
-    @staticmethod
-    def bounds():
-        """Returns all Bounds"""
-
-        return sum(
-            [
-                [f.name for f in fields(bln)]
-                for bln in [
-                    _PlyBounds,
-                    _CshBounds,
-                    _EmnBounds,
-                    _UsdBounds,
-                    _ResBounds,
-                    _OpnBounds,
-                    _ProBounds,
-                    _StgBounds,
-                    _TrnBounds,
-                ]
-            ],
-            [],
-        )
-
-
-@dataclass
-class _Exacts(_TscExacts, _EmnExacts, _UseExacts, _LseExacts, _RteExacts):
-    """These are Exact Component Inputs
-
-    These are inherited across all Spatial Components
-    if defined at Network
-
-    There is no Network value for these
-
-    """
-
-    def __post_init__(self):
-        # ---------Transacts---------
-        # Resource
-        self.buy_price = Task2(
-            attr='buy_price',
-            res=True,
-            var=TransactBuy,
-            pro=True,
-        )
-        self.sell_price = Task2(attr='sell_price', res=True, var=TransactSll, pro=True)
-        self.credit = Task2(attr='credit', res=True, var=TransactCrd, pro=True)
-        self.penalty = Task2(attr='penalty', res=True, var=TransactPnt, pro=True)
-        # Land and Material (Used)
-        self.use_cost = Task2(
-            attr='use_cost', mat=True, lnd=True, var=TransactUse, pro=True
-        )
-        # Operational
-        self.capex = Task2(
-            attr='capex',
-            pro=True,
-            stg=True,
-            trn=True,
-            var=TransactStp,
-            var_i=TransactStpI,
-        )
-        self.opex = Task2(
-            attr='opex',
-            pro=True,
-            stg=True,
-            trn=True,
-            var=TransactOpr,
-            var_i=TransactOprI,
-        )
-
-        # ---------Emissions---------
-        # Resource
-        self.buy_emission = Task2(attr='buy_emission', res=True, var=EmitBuy, pro=True)
-        self.sell_emission = Task2(
-            attr='sell_emission', res=True, var=EmitSll, pro=True
-        )
-        self.loss_emission = Task2(
-            attr='loss_emission',
-            res=True,
-            var=EmitLse,
-            stg=True,
-            trn=True,
-        )
-        # Land and Material (Used)
-        self.use_emission = Task2(attr='use_emission', mat=True, lnd=True, var=EmitUse)
-        # Operational
-        self.setup_emission = Task2(
-            attr='setup_emission', pro=True, stg=True, trn=True, var=EmitStp
-        )
-
-        # ---------Uses---------
-        # Operational
-        self.setup_use = Task2(
-            attr='setup_use', pro=True, stg=True, trn=True, var=UseStp
-        )
-
-        # ---------Losses---------
-        # Storage Operation
-        self.inventory_loss = Task2(attr='inventory_loss', stg=True, var=Lose)
-        # Transit Operation
-        self.freight_loss = Task2(attr='freight_loss', trn=True, var=Lose)
-        # ---------Rates---------
-        # Operational
-        self.setup_time = Task2(attr='setup_time', pro=True, stg=True, trn=True)
-        # Transit Operation
-        self.speed = Task2(attr='speed', trn=True)
-
-    @staticmethod
-    def transactions():
-        """Transacts"""
-        return [f.name for f in fields(_TscExacts)]
-
-    @staticmethod
-    def emissions():
-        """Emissions"""
-        return [f.name for f in fields(_EmnExacts)]
-
-    @staticmethod
-    def uses():
-        """Uses"""
-        return [f.name for f in fields(_UseExacts)]
-
-    @staticmethod
-    def losses():
-        """Losses"""
-        return [f.name for f in fields(_LseExacts)]
-
-    @staticmethod
-    def rates():
-        """Rates"""
-        return [f.name for f in fields(_RteExacts)]
-
-    @staticmethod
-    def exacts():
-        """Returns all Exact Inputs"""
-        return sum(
-            [
-                [f.name for f in fields(ext)]
-                for ext in [
-                    _TscExacts,
-                    _EmnExacts,
-                    _UseExacts,
-                    _LseExacts,
-                ]
-            ],
-            [],
-        )
-
-
-@dataclass
-class _Balances(_ProBalance, _StgBalance, _TrnBalance):
-    """These are Balances for Resources
-    defined at Operational Components
-    """
-
-    def __post_init__(self):
-        # Process
-        self.conversion = Task2(attr='conversion', pro=True)
-        # Storage
-        self.inventory = Task2(attr='inventory', stg=True)
-        # Transit
-        self.freight = Task2(attr='freight', trn=True)
-
-    @staticmethod
-    def balances():
-        """Returns all Balances"""
-        return sum(
-            [
-                [f.name for f in fields(bln)]
-                for bln in [_ProBalance, _StgBalance, _TrnBalance]
-            ],
-            [],
-        )
-
-
-@dataclass
-class Chanakya(_Balances, _Bounds, _Exacts, _Dunders):
-    """This object collects all the attributes defined
-    and makes a list of Indexs they are defined at
-
-    """
-
-    name: str = field(default=None)
-
-    def __post_init__(self):
-        self.name = f'TaskMaster|{self.name}|'
-        _Balances.__post_init__(self)
-        _Bounds.__post_init__(self)
-        _Exacts.__post_init__(self)
-
-    @property
-    def report_transactions(self):
-        """Collection of Transacts"""
-        return Report(
-            name='transactions',
-            tasks=[getattr(self, attr) for attr in self.transactions()],
-        )
-
-    @property
-    def report_uses(self):
-        """Collection of Uses"""
-        return Report(
-            name='uses',
-            tasks=[getattr(self, attr) for attr in self.uses()],
-        )
-
-    @property
-    def report_emissions(self):
-        """Collection of Emissions"""
-        return Report(
-            name='emissions',
-            tasks=[getattr(self, attr) for attr in self.emissions()],
-        )
-
-    @property
-    def report_losses(self):
-        """Collection of Losses"""
-        return Report(
-            name='losses', tasks=[getattr(self, attr) for attr in self.losses()]
-        )
-
-    def vars(self):
-        """Returns all Variables"""
-        return sorted(
-            {
-                i['var']
-                for i in list(asdict(self).values())
-                if isinstance(i, dict) and i['var']
-            }
-            | {
-                i['var_i']
-                for i in list(asdict(self).values())
-                if isinstance(i, dict) and i['var_i']
-            },
-            key=lambda x: x.cname(),
-        )
diff --git a/src/energiapy/environ/model.py b/src/energiapy/environ/model.py
index 7f106f36..f90a4063 100644
--- a/src/energiapy/environ/model.py
+++ b/src/energiapy/environ/model.py
@@ -52,7 +52,7 @@ class Engines(_Dunders):
     def __post_init__(self):
         self.taskmaster = Chanakya(name=self.name)
         self.rulebook = Bhaskara(name=self.name)
-        self.registrar = ChitraGupta(name=self.name, rulebook=self.rulebook)
+        self.registrar = ChitraGupta(name=self.name)
         # Update name after setting the rest
         # The name of the scenario is taken as is
         self.name = f'{self.cname()}|{self.name}|'
diff --git a/src/energiapy/environ/scenario.py b/src/energiapy/environ/scenario.py
index d634f2b5..ce0d3f50 100644
--- a/src/energiapy/environ/scenario.py
+++ b/src/energiapy/environ/scenario.py
@@ -46,11 +46,15 @@
 from ..components.spatial.linkage import Linkage
 from ..components.spatial.network import Network
 from ..components.temporal.horizon import Horizon
+from ..components.temporal.scale import Scale
+from ..components.spatial.location import Location
 from ..core._handy._dunders import _Dunders
 from ..core._handy._printers import _Print
 from ..core._report._data import _Vlus
 from ..core._report._prog import _Elms
 from ..core._report._syst import _Cmps
+from ..core._handy._words import reserved
+from ..core.nirop.errors import ReservedWord
 from ._scenario._birth import _Birth
 from ._scenario._default import _Default
 from ._scenario._ok import _Ok
@@ -121,8 +125,11 @@ def __setattr__(self, name, value):
         # The Model [System, Program, Data, Matrix] is also added
         # This is a cursory step to check what is being added, also excludes name
         if isinstance(value, _Component):
-            # Personalize the component
 
+            if name in reserved:
+                raise ReservedWord(name)
+
+            # Personalize the component
             value.personalize(name=name, model=self.model)
 
             # Check if ok to overwrite
@@ -156,11 +163,16 @@ def __setattr__(self, name, value):
             # Horizon, Network, Linkages and Storage give birth to new components
             if isinstance(value, Horizon):
                 self.handle_unique_cmp('horizon', value)
-                self.birth_scales(horizon=value)
+                self.birth_partitions(scope=value, birth=Scale)
+                # value.periodize()
+                # once scales are birthed, they are periodized
+                # which creates time periods for each scale
+                for s in self.scales:
+                    s.periodize()
 
             if isinstance(value, Network):
                 self.handle_unique_cmp('network', value)
-                self.birth_locations(network=value)
+                self.birth_partitions(scope=value, birth=Location)
                 if value.link_all:
                     self.birth_all_linkages(network=value)
 
diff --git a/src/energiapy/environ/task.py b/src/energiapy/environ/task.py
deleted file mode 100644
index d08c0fae..00000000
--- a/src/energiapy/environ/task.py
+++ /dev/null
@@ -1,108 +0,0 @@
-"""Task, for Component attributes
-"""
-
-from dataclasses import dataclass, field
-
-from ..core._handy._dunders import _Dunders
-from ..core._handy._printers import _EasyPrint
-from ..core.isalias.cmps.isdfn import IsDfn
-from ..core.isalias.elms.isvar import IsVar
-
-
-@dataclass
-class Task(_Dunders, _EasyPrint):
-    """Task
-    Handles the attributes of components
-    Defines strict behaviour
-
-    Attributes:
-        attr (str): attr associated with Task
-        root (list[IsDfn]): list of Components where the attribute can be declared
-        other (list[IsDfn]): list of Incongruent Components where the Component attribute can be declared
-        var (IsVar): Task Variable
-        var_i (IsVar): Incidental Task Variable
-    """
-
-    attr: str = field(default=None)
-    root: list[IsDfn] = field(default_factory=list)
-    other: list[IsDfn] = field(default_factory=list)
-    var: IsVar = field(default=None)
-    var_i: IsVar = field(default=None)
-
-    def __post_init__(self):
-        self.name = f'Task|{self.attr}|'
-        # Elements associated with the attribute
-        self.values = []
-        self.parameters = []
-        self.constraints = []
-        self.variables = []
-        self.indices = []
-
-
-@dataclass
-class Task2(_Dunders, _EasyPrint):
-    """Task
-    Handles the attributes of components
-    Defines strict behaviour
-
-    Attributes:
-        attr (str): attr associated with Task
-        var (IsVar): Task Variable
-        var_i (IsVar): Incidental Task Variable
-        ply (bool): Does this apply to Player?
-        emn (bool): Does this apply to Emission?
-        csh (bool): Does this apply to Cash?
-        res (bool): Does this apply to Resource?
-        mat (bool): Does this apply to Material?
-        lnd (bool): Does this apply to Land?
-        pro (bool): Does this apply to Process?
-        stg (bool): Does this apply to Storage?
-        trn (bool): Does this apply to Transit?
-        loc (bool): Does this apply to Location?
-        lnk (bool): Does this apply to Linkage?
-        ntw (bool): Does this apply to Network?
-        scl (bool): Does this apply to Scale?
-        mde (bool): Does this apply to Mode?
-        p (bool): Does it add to the Balance (plus sign)
-        m (bool): Does it subtract from the Balance (minus sign)
-    """
-
-    attr: str = field(default=None)
-    var: IsVar = field(default=None)
-    var_i: IsVar = field(default=None)
-    root: str = field(default=None)
-    # Do not reorder these fields
-    # I like to look at them in this order
-    # Not sure why, but I do
-    ply: bool = field(default=False)
-    emn: bool = field(default=False)
-    csh: bool = field(default=False)
-    res: bool = field(default=False)
-    mat: bool = field(default=False)
-    lnd: bool = field(default=False)
-    pro: bool = field(default=False)
-    stg: bool = field(default=False)
-    trn: bool = field(default=False)
-    loc: bool = field(default=False)
-    lnk: bool = field(default=False)
-    ntw: bool = field(default=False)
-    scl: bool = field(default=False)
-    mde: bool = field(default=False)
-    p: bool = field(default=False)
-    m: bool = field(default=False)
-
-    def __post_init__(self):
-        self.name = f'Task|{self.attr}|'
-
-        if self.p and self.m:
-            raise ValueError('Task cannot be both plus and minus')
-
-        if not (self.p or self.m):
-            raise ValueError('Task must be either plus or minus')
-
-        # Elements associated with the attribute
-        self.values = []
-        self.parameters = []
-        self.constraints = []
-        self.variables = []
-        self.indices = []
diff --git a/src/energiapy/elements/parameters/bounds/__init__.py b/src/energiapy/environ/tasks/__init__.py
similarity index 100%
rename from src/energiapy/elements/parameters/bounds/__init__.py
rename to src/energiapy/environ/tasks/__init__.py
diff --git a/src/energiapy/environ/tasks/_task.py b/src/energiapy/environ/tasks/_task.py
new file mode 100644
index 00000000..35d49ece
--- /dev/null
+++ b/src/energiapy/environ/tasks/_task.py
@@ -0,0 +1,33 @@
+"""Task, for Component attributes
+"""
+
+from dataclasses import dataclass, field
+
+from ...core._handy._dunders import _Dunders
+from ...core._handy._printers import _EasyPrint
+from ...core.isalias.cmps.iscmp import IsCmp
+
+
+@dataclass
+class _Task(_Dunders, _EasyPrint):
+    """Task
+    Handles the attributes of components
+    Defines strict behaviour
+
+    Attributes:
+        var (IsVar): Task Variable
+    """
+
+    name: str = field(default=None)
+    root: IsCmp = field(default=None)
+    varsym: str = field(default=None)
+    prmsym: str = field(default=None)
+
+    def __post_init__(self):
+        # Elements associated with the attribute
+        self.values = []
+        self.parameters = []
+        self.constraints = []
+        self.variables = []
+        self.indices = []
+
diff --git a/src/energiapy/environ/tasks/balancing.py b/src/energiapy/environ/tasks/balancing.py
new file mode 100644
index 00000000..eec273a1
--- /dev/null
+++ b/src/energiapy/environ/tasks/balancing.py
@@ -0,0 +1,29 @@
+"""Balances Resource flow in Operations
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+from ._task import _Task
+
+from ...core.isalias.inps.isblc import IsBlc
+from ...core.isalias.cmps.isdfn import IsOpn
+from ...components.commodity.resource import Resource
+
+if TYPE_CHECKING:
+    from .bound import BoundBound
+
+
+@dataclass
+class Balancing(_Task):
+    """Balances the flow of Resource in Operations"""
+
+    balance: IsBlc = field(default=None)
+    opn: IsOpn = field(default=None)
+    parent: BoundBound = field(default=None)
+
+    def __post_init__(self):
+        _Task.__post_init__(self)
+        self.root = Resource
+        self.name = f'Balancing|{self.name}|'
diff --git a/src/energiapy/environ/tasks/bound.py b/src/energiapy/environ/tasks/bound.py
new file mode 100644
index 00000000..1b449538
--- /dev/null
+++ b/src/energiapy/environ/tasks/bound.py
@@ -0,0 +1,77 @@
+"""Binds a variable based on the Datum provided 
+"""
+
+from dataclasses import dataclass, field
+from ._task import _Task
+from ...elements.variables.boundvar import BoundVar
+from ...elements.variables.boundboundvar import BoundBoundVar
+from ...elements.constraints.bind import Bind
+from ...elements.parameters.boundprm import BoundPrm
+
+
+@dataclass
+class Bound(_Task):
+    """Bound Task"""
+
+    p: bool = field(default=False)
+    m: bool = field(default=False)
+
+    def __post_init__(self):
+        _Task.__post_init__(self)
+        self.name = f'Bound|{self.name}|'
+        self.parent = None
+
+        if self.p and self.m:
+            raise ValueError('Task cannot be both plus and minus')
+
+        if not (self.p or self.m):
+            raise ValueError('Task must be either plus or minus')
+
+    @staticmethod
+    def var():
+        """Variable"""
+        return BoundVar
+
+    @staticmethod
+    def prm():
+        """Parameter"""
+        return BoundPrm
+
+    @staticmethod
+    def cns():
+        """Constraint"""
+        return Bind
+
+    def varbirth_attrs(self):
+        """Attributes of the Variable"""
+        return {'p': self.p, 'm': self.m, 'symbol': self.varsym}
+
+
+@dataclass
+class BoundBound(_Task):
+    """Bound Task"""
+
+    parent: Bound = field(default=None)
+
+    def __post_init__(self):
+        _Task.__post_init__(self)
+        self.name = f'BoundBound|{self.name}|'
+
+    @staticmethod
+    def var():
+        """Variable attributes"""
+        return BoundBoundVar
+
+    @staticmethod
+    def prm():
+        """Parameter"""
+        return BoundPrm
+
+    @staticmethod
+    def cns():
+        """Constraint"""
+        return Bind
+
+    def varbirth_attrs(self):
+        """Attributes of the Variable"""
+        return {'symbol': self.varsym}
diff --git a/src/energiapy/environ/tasks/calculation.py b/src/energiapy/environ/tasks/calculation.py
new file mode 100644
index 00000000..a77ed0d2
--- /dev/null
+++ b/src/energiapy/environ/tasks/calculation.py
@@ -0,0 +1,51 @@
+"""Calculates the value of a Variable based on the Parent Task
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from dataclasses import dataclass, field
+from ._task import _Task
+from ...elements.variables.exactvar import ExactVar
+from ...elements.constraints.calculate import Calculate
+from ...elements.parameters.exactprm import ExactPrm
+
+if TYPE_CHECKING:
+    from .bound import Bound
+
+
+@dataclass
+class Calculation(_Task):
+    """Calculation Task
+    Handles the attributes of components
+    Defines strict behaviour
+
+    Attributes:
+        var (IsVar): Task Variable
+    """
+
+    parent: Bound = field(default=None)
+
+    def __post_init__(self):
+        _Task.__post_init__(self)
+        self.name = f'Calculation|{self.name}|'
+
+    @staticmethod
+    def var():
+        """Variable"""
+        return ExactVar
+
+    @staticmethod
+    def prm():
+        """Parameter"""
+        return ExactPrm
+
+    @staticmethod
+    def cns():
+        """Constraint"""
+        return Calculate
+
+    def varbirth_attrs(self):
+        """Attributes of the Variable"""
+        return {'symbol': self.varsym}
diff --git a/src/energiapy/environ/report.py b/src/energiapy/environ/tasks/report.py
similarity index 83%
rename from src/energiapy/environ/report.py
rename to src/energiapy/environ/tasks/report.py
index 83270ebd..9e2a16cc 100644
--- a/src/energiapy/environ/report.py
+++ b/src/energiapy/environ/tasks/report.py
@@ -3,9 +3,9 @@
 
 from dataclasses import dataclass, field
 
-from ..core._handy._dunders import _Dunders
-from ..core._handy._printers import _EasyPrint
-from .task import Task
+from ...core._handy._dunders import _Dunders
+from ...core._handy._printers import _EasyPrint
+from ._task import _Task
 
 
 @dataclass
@@ -18,7 +18,7 @@ class Report(_Dunders, _EasyPrint):
     """
 
     name: str = field(default=None)
-    tasks: list[Task] = field(default_factory=list)
+    tasks: list[_Task] = field(default_factory=list)
 
     def __post_init__(self):
         self.name = f'Report|{self.name}|'
diff --git a/src/energiapy/elements/parameters/exacts/__init__.py b/src/energiapy/environ/tasks/summation.py
similarity index 100%
rename from src/energiapy/elements/parameters/exacts/__init__.py
rename to src/energiapy/environ/tasks/summation.py
diff --git a/src/energiapy/utils/dictionary.py b/src/energiapy/utils/dictionary.py
index e64e98b2..95454edf 100644
--- a/src/energiapy/utils/dictionary.py
+++ b/src/energiapy/utils/dictionary.py
@@ -36,3 +36,29 @@ def flatten(dict_: dict, key_: tuple = ()) -> dict:
         else:
             items.append((key_upd, val))
     return dict(items)
+
+
+def tupler(d: dict, path: tuple = ()) -> list[tuple[str]]:
+    """makes a list of tuples of keys in a nested dictionary
+
+    Args:
+        d (dict): dictionary
+        current_path (tuple, optional): path taken to get to value. Defaults to ().
+
+    Returns:
+        list[tuple[str]]: list of tuples of keys
+    """
+    result = []
+
+    for k, v in d.items():
+        path_ = path + (k,)
+        result.append(path_)
+
+        if isinstance(v, dict):
+            result.extend(tupler(v, path_))
+
+        if isinstance(v, set):
+            for v_ in v:
+                result.append(path_ + (v_,))
+
+    return result
diff --git a/src/energiapy/utils/scale.py b/src/energiapy/utils/pyomo.py
similarity index 95%
rename from src/energiapy/utils/scale.py
rename to src/energiapy/utils/pyomo.py
index 4abdefc6..92836b43 100644
--- a/src/energiapy/utils/scale.py
+++ b/src/energiapy/utils/pyomo.py
@@ -7,10 +7,7 @@
 from ..components import Scale
 
 
-def scale_pyomo_set(
-        instance: ConcreteModel,
-        scale_level: int = 0,
-        doc: str = None):
+def scale_pyomo_set(instance: ConcreteModel, scale_level: int = 0, doc: str = None):
     """returns a set with appropropriate scale(s)
 
     Args:


Test patch:
diff --git a/tests/error_test.py b/tests/error_test.py
index 628b71dd..bf0a98db 100644
--- a/tests/error_test.py
+++ b/tests/error_test.py
@@ -21,7 +21,7 @@ def test_notok_errors(scenario_notok):
     if another Horizon is defined, it should raise a warning
     """
     with pytest.raises(OverWriteError):
-        scenario_notok.h = Horizon(discretizations=[4])
+        scenario_notok.h = Horizon(birth=[4])
     with pytest.raises(NoLabelError):
         scenario_notok.r0 = Cash(basis='basis')
     with pytest.raises(NoBasisError):
diff --git a/tests/init_test.py b/tests/init_test.py
index 46422fcc..bf4aea93 100644
--- a/tests/init_test.py
+++ b/tests/init_test.py
@@ -53,8 +53,8 @@
 # def scenario():
 #     """Scenario"""
 #     scn = Scenario()
-#     scn.hrz = Horizon(discretizations=[1])
-#     scn.ntw = Network(locs=['loca', 'locb'])
+#     scn.hrz = Horizon(birth=[1])
+#     scn.ntw = Network(birth=['loca', 'locb'])
 #     scn.lnk = Linkage(source=scn.loca, sink=scn.locb, bi=True)
 #     scn.ply = Player()
 #     scn.csh = Cash()
diff --git a/tests/input_tests.py b/tests/input_tests.py
index 14bdbe5f..2e350ef3 100644
--- a/tests/input_tests.py
+++ b/tests/input_tests.py
@@ -15,8 +15,8 @@
 def scenario():
     """Scenario"""
     scn = Scenario()
-    scn.hrz = Horizon(discretizations=[1])
-    scn.ntw = Network(locs=['loca', 'locb'])
+    scn.hrz = Horizon(birth=[1])
+    scn.ntw = Network(birth=['loca', 'locb'])
     scn.res = Resource()
     return scn
 
diff --git a/tests/test_fixtures.py b/tests/test_fixtures.py
index d2a44300..72380007 100644
--- a/tests/test_fixtures.py
+++ b/tests/test_fixtures.py
@@ -24,7 +24,7 @@ def scenario_def():
 def scenario_ok():
     """Chill Scenario"""
     s = Scenario()
-    s.h = Horizon(discretizations=[4])
+    s.h = Horizon(birth=[4])
     s.n = Network()
     return s
 
@@ -33,7 +33,7 @@ def scenario_ok():
 def scenario_notok():
     """Unchill Scenario"""
     s = Scenario(chill=False)
-    s.h = Horizon(discretizations=[4])
+    s.h = Horizon(birth=[4])
     s.n = Network()
     return s
 
@@ -42,7 +42,7 @@ def scenario_notok():
 def horizon_singlescale(scenario_bare):
     """Single scale with 4 discertizations"""
 
-    scenario_bare.h = Horizon(discretizations=[4])
+    scenario_bare.h = Horizon(birth=[4])
     return scenario_bare.horizon
 
 
@@ -52,16 +52,11 @@ def horizon_singlescale_scale_0(horizon_singlescale):
     return horizon_singlescale.scales[0]
 
 
-@pytest.fixture
-def horizon_singlescale_scale_1(horizon_singlescale):
-    """t1 single scale"""
-    return horizon_singlescale.scales[1]
-
 
 @pytest.fixture
 def horizon_multiscale(scenario_bare):
     """Multiscale Horizon with 2 and 4 discertizations"""
-    scenario_bare.h = Horizon(discretizations=[2, 4])
+    scenario_bare.h = Horizon(birth=[2, 4])
     return scenario_bare.horizon
 
 
@@ -77,16 +72,11 @@ def horizon_multiscale_scale_1(horizon_multiscale):
     return horizon_multiscale.scales[1]
 
 
-@pytest.fixture
-def horizon_multiscale_scale_2(horizon_multiscale):
-    """t2 multiscale"""
-    return horizon_multiscale.scales[2]
-
 
 @pytest.fixture
 def horizon_multiscale_un(scenario_bare):
     """Not nested Multiscale Horizon with 2 and 8 discertizations"""
-    scenario_bare.h = Horizon(discretizations=[2, 8], nested=False)
+    scenario_bare.h = Horizon(birth=[2, 8], nested=False)
     return scenario_bare.horizon
 
 
@@ -111,7 +101,7 @@ def horizon_multiscale_un_scale_2(horizon_multiscale_un):
 @pytest.fixture
 def horizon_multiscale_nmd(scenario_bare):
     """Named Multiscale Horizon with 2 and 4 discertizations"""
-    scenario_bare.h = Horizon(discretizations={'a': 2, 'b': 4})
+    scenario_bare.h = Horizon(birth={'a': 2, 'b': 4})
     return scenario_bare.horizon
 
 
diff --git a/tests/warning_test.py b/tests/warning_test.py
index 8780bf6f..2b204d69 100644
--- a/tests/warning_test.py
+++ b/tests/warning_test.py
@@ -14,4 +14,4 @@ def test_overwrite_warning(scenario_ok):
     if another Horizon is defined, it should raise a warning
     """
     with pytest.warns(OverWriteWarning):
-        scenario_ok.h = Horizon(discretizations=[4])
+        scenario_ok.h = Horizon(birth=[4])