Repository: NREL/HOPP (language: python)

Issue:
Update ProFAST workflow
Update the ProFAST workflow to use ProFAST version hosted on NREL's Github.

- Add ProFAST to requirements.txt
- Update hybrid example using ProFAST for financial analysis


Discussion / hints:

Fix patch:
diff --git a/LICENSE b/LICENSE
index 3af65244b..4a765036b 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,3 +1,5 @@
+**Note: The ProFAST model is distributed with HOPP but operates under a separate license agreement. Users must agree to the license terms of ProFAST located at `ProFAST/InternalUseTermsForDownloadableSoftware-ProFAST.docx`.**
+
 BSD 3-Clause License
 
 Copyright (c) 2020, Alliance for Sustainable Energy, LLC
diff --git a/examples/08-wind-solar-battery-profast.ipynb b/examples/08-wind-solar-battery-profast.ipynb
new file mode 100644
index 000000000..d675608d9
--- /dev/null
+++ b/examples/08-wind-solar-battery-profast.ipynb
@@ -0,0 +1,737 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hybrid Plant with Battery Storage and ProFAST Financials Example\n",
+    "---\n",
+    "In this example, we will explore how to simulate a hybrid renewable energy system that includes both wind and solar power sources, along with battery energy storage. The battery uses the default dispatch model, simple dispatch, which uses a profit maximization objective function.\n",
+    "\n",
+    "We will then detail how to use ProFAST for the financial analysis. The financial analysis will detail how to set general financial parameters, add captial costs, fixed costs, and incentives based on  policy incentives in the IRA."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Import Required Modules\n",
+    "Begin by importing the necessary modules for the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/kbrunik/github/forked/HOPP/examples/log/hybrid_systems_2024-02-06T13.46.43.869327.log\n"
+     ]
+    }
+   ],
+   "source": [
+    "from hopp.simulation import HoppInterface\n",
+    "from ProFAST import ProFAST"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create the Simulation Model\n",
+    "Instantiate the `HoppInterface` class by providing a YAML configuration.\n",
+    "\n",
+    "In order to configure the battery dispatch model, ensure that you include a `grid_resource_file` within the `site` section, and incorporate the `battery` size and capacity into the `technologies` section of the YAML configuration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hi = HoppInterface(\"./inputs/08-wind-solar-battery-profast.yaml\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run the Energy Simulation\n",
+    "Simulate the hybrid renewable energy system for a specified number of years (in this case, 20 years)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hi.simulate(project_life=20)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Print Energy Simulation Results\n",
+    "Access and display various simulation results, including annual energies, net present values (NPVs), and total revenues."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Output after losses over gross output: 0.7997475965518004\n",
+      "Annual Energies:\n",
+      "{\"pv\": 104289820.4575963, \"wind\": 156936144.35254738, \"battery\": -846823.8925884475, \"hybrid\": 252296517.80627298}\n"
+     ]
+    }
+   ],
+   "source": [
+    "hybrid_plant = hi.system\n",
+    "\n",
+    "print(\"Output after losses over gross output:\",\n",
+    "      hybrid_plant.wind.value(\"annual_energy\") / hybrid_plant.wind.value(\"annual_gross_energy\"))\n",
+    "\n",
+    "# Save the outputs\n",
+    "annual_energies = hybrid_plant.annual_energies\n",
+    "\n",
+    "print(\"Annual Energies:\")\n",
+    "print(annual_energies)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Set up Financial Analysis\n",
+    "\n",
+    "We will be using [ProFAST](https://github.com/NREL/ProFAST) which is based on [H2FAST](https://www.nrel.gov/hydrogen/h2fast.html) for the financial analysis. It uses Generally Accepted Accounting Principles to calculate detailed financial analyses.\n",
+    "\n",
+    "Start the financial analysis by instantiating a blank ProFAST instance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pf = ProFAST()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Set the general financial parameter values for the model (you can leave put of them as 0 if not relevant)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gen_inflation = 0.025\n",
+    "\n",
+    "#  Sales specification\n",
+    "pf.set_params('commodity',{\"name\":'Electricity',\"unit\":\"kWh\",\"initial price\":0.4,\"escalation\":gen_inflation})\n",
+    "pf.set_params('analysis start year',2027)\n",
+    "pf.set_params('operating life',20)\n",
+    "pf.set_params('installation months',36)\n",
+    "pf.set_params('demand rampup',0)\n",
+    "pf.set_params('long term utilization',1) # Set to 1 since produced energy is used as capacity\n",
+    "\n",
+    "#  Installation information:\n",
+    "pf.set_params('capacity',annual_energies['hybrid'] / 365.0) #kWh/day\n",
+    "pf.set_params('installation cost',{\"value\":0,\"depr type\":\"Straight line\",\"depr period\":4,\"depreciable\":False})\n",
+    "pf.set_params('non depr assets',304056)\n",
+    "pf.set_params('end of proj sale non depr assets',940330)\n",
+    "pf.set_params('maintenance',{\"value\":300000,\"escalation\":gen_inflation})\n",
+    "\n",
+    "#  Other operating expenses\n",
+    "pf.set_params('credit card fees',0.025)\n",
+    "pf.set_params('sales tax',0.023) \n",
+    "pf.set_params('labor',{\"value\":2956.583883,\"rate\":17.71964046,\"escalation\":0.0387})\n",
+    "pf.set_params('license and permit',{'value':2000,'escalation':gen_inflation})\n",
+    "pf.set_params('rent',{'value':50000,'escalation':gen_inflation})\n",
+    "pf.set_params('property tax and insurance',0.009)\n",
+    "pf.set_params('admin expense',0.005)\n",
+    "\n",
+    "#   Financing information\n",
+    "pf.set_params('total income tax rate',0.3850)\n",
+    "pf.set_params('capital gains tax rate',0.15)\n",
+    "pf.set_params('sell undepreciated cap',True)\n",
+    "pf.set_params('tax losses monetized',True)\n",
+    "pf.set_params('tax loss carry forward years',0)\n",
+    "pf.set_params('general inflation rate',gen_inflation)\n",
+    "pf.set_params('leverage after tax nominal discount rate',0.1)\n",
+    "pf.set_params('debt equity ratio of initial financing',0.5)\n",
+    "pf.set_params('debt type','Revolving debt')\n",
+    "pf.set_params('loan period if used',0)\n",
+    "pf.set_params('debt interest rate',0.07)\n",
+    "pf.set_params('cash onhand',1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add capital expenses. Cost is in dollars at analysis start. You can chose an accelerated depreciation of MACRS or Straight line."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pf.add_capital_item(name=\"Wind Installed capital\",\n",
+    "        cost=hybrid_plant.wind.total_installed_cost,\n",
+    "        depr_type=\"MACRS\",\n",
+    "        depr_period=10,refurb=[0])\n",
+    "        \n",
+    "pf.add_capital_item(name=\"PV Installed capital\",\n",
+    "    cost=hybrid_plant.pv.total_installed_cost,\n",
+    "    depr_type=\"MACRS\",\n",
+    "    depr_period=10,refurb=[0])\n",
+    "\n",
+    "pf.add_capital_item(name=\"Battery Installed capital\",\n",
+    "    cost=hybrid_plant.battery.total_installed_cost,\n",
+    "    depr_type=\"MACRS\",\n",
+    "    depr_period=10,refurb=[0])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add fixed costs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_fixed_costs = {\n",
+    "    'wind':30, #$/kw-yr\n",
+    "    'pv': 22, #$/kw-yr\n",
+    "    'battery': 45, #$/kw-yr\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pf.add_fixed_cost(name=\"Wind Fixed O&M Costs\",\n",
+    "    usage=1,\n",
+    "    unit='$/yr',\n",
+    "    cost=system_fixed_costs['wind']*hybrid_plant.wind.system_capacity_kw,\n",
+    "    escalation=gen_inflation)\n",
+    "\n",
+    "pf.add_fixed_cost(name=\"Wind Fixed O&M Costs\",\n",
+    "    usage=1,unit='$/yr',\n",
+    "    cost=system_fixed_costs['pv']*hybrid_plant.pv.system_capacity_kw,\n",
+    "    escalation=gen_inflation)\n",
+    "    \n",
+    "pf.add_fixed_cost(name=\"Wind Fixed O&M Costs\",\n",
+    "    usage=1,unit='$/yr',\n",
+    "    cost=system_fixed_costs['battery']*hybrid_plant.battery.system_capacity_kw,\n",
+    "    escalation=gen_inflation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "(OPTIONAL) Add incentives.\n",
+    "\n",
+    "The first example of an incentive you can add is the **wind investment tax credit** (ITC). The ITC credit can be added as an \"one time cap inct\" in `set_params`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wind_itc_value_percent_wind_capex = 0.30 # 30%\n",
+    "\n",
+    "wind_itc_value_dollars = wind_itc_value_percent_wind_capex * (\n",
+    "        hybrid_plant.wind.total_installed_cost\n",
+    "    )\n",
+    "pf.set_params('one time cap inct',\n",
+    "    {\"value\":wind_itc_value_dollars,\n",
+    "    \"depr type\":\"MACRS\",\n",
+    "    \"depr period\":10,\n",
+    "    \"depreciable\":True})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "(OPTIONAL) Add incentives.\n",
+    "\n",
+    "The second example of an incentive you can add is the **wind production tax credit** (PTC). The PTC credit can be added using `add_incentive()`.\n",
+    "\n",
+    "**Note**: The PTC is in 1992 USD and has to be adjusted to the correct analysis year.\n",
+    "\n",
+    "**Note**: The PTC and ITC cannot be stacked."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_year = 2025\n",
+    "wind_ptc = 0.003 # $1992/kWh\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy_financial as npf\n",
+    "# adjust from 1992 dollars to start year\n",
+    "wind_ptc_in_dollars_per_kw = -npf.fv(\n",
+    "        gen_inflation,\n",
+    "        start_year\n",
+    "        + round((36 / (365 * 24)))\n",
+    "        - 1992,\n",
+    "        0,\n",
+    "        wind_ptc,\n",
+    "    )  # given in 1992 dollars but adjust for inflation\n",
+    "\n",
+    "pf.add_incentive(\n",
+    "        name=\"Electricity PTC\",\n",
+    "        value=wind_ptc_in_dollars_per_kw,\n",
+    "        decay=-gen_inflation,\n",
+    "        sunset_years=10,\n",
+    "        tax_credit=True,\n",
+    "    ) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LCOE:  0.08 $/kWh\n",
+      "\n",
+      "{'NPV': 5.662441253662109e-07, 'price': 0.08343299112977365, 'irr': array([-0.35193263,  0.1       ]), 'profit index': 2.096083551501914, 'investor payback period': 9, 'first year positive EBITD': 4, 'timing': 0.06952095031738281, 'lco': 0.08343299112977362}\n"
+     ]
+    }
+   ],
+   "source": [
+    "sol=pf.solve_price()\n",
+    "lcoe = sol['price']\n",
+    "\n",
+    "print(\"LCOE: \", \"%.2f\" % (lcoe), \"$/kWh\\n\")\n",
+    "print(sol)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### (OPTIONAL) Visualize Financial Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x900 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Name</th>\n",
+       "      <th>Amount</th>\n",
+       "      <th>NPV</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Licensing and Permitting</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 2153.781249999999, 2207.6...</td>\n",
+       "      <td>0.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Capital gains taxes payable</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...</td>\n",
+       "      <td>0.000011</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Non-depreciable assets</td>\n",
+       "      <td>[-304056, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
+       "      <td>0.000062</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Rent of land</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 53844.531249999985, 55190...</td>\n",
+       "      <td>0.000198</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Labor</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 58710.46303927179, 60982....</td>\n",
+       "      <td>0.000246</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Cash on hand reserve</td>\n",
+       "      <td>[0.0, 154470.6419666667, 0.0, 0.0, 130772.5676...</td>\n",
+       "      <td>0.000255</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Administrative expenses</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 113341.94747848444, 11617...</td>\n",
+       "      <td>0.000417</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Property insurance</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 1121535.504, 897775.70399...</td>\n",
+       "      <td>0.000824</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Total annual maintenance</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 323067.1874999999, 331143...</td>\n",
+       "      <td>0.001189</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Sales tax</td>\n",
+       "      <td>[-0.0, -0.0, -0.0, -0.0, -521372.9584010284, -...</td>\n",
+       "      <td>0.001919</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Credit card fees</td>\n",
+       "      <td>[-0.0, -0.0, -0.0, -0.0, -566709.7373924222, -...</td>\n",
+       "      <td>0.002086</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Repayment of debt</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...</td>\n",
+       "      <td>0.004957</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Battery Installed capital</td>\n",
+       "      <td>[29980000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...</td>\n",
+       "      <td>0.006090</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>PV Installed capital</td>\n",
+       "      <td>[48000000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...</td>\n",
+       "      <td>0.009750</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Interest expense</td>\n",
+       "      <td>[0.0, 3014061.306666667, 3014061.306666667, 30...</td>\n",
+       "      <td>0.010612</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Income taxes payable</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10479...</td>\n",
+       "      <td>0.012905</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>Operating Expenses</td>\n",
+       "      <td>Wind Fixed O&amp;M Costs</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 3876806.2499999986, 39737...</td>\n",
+       "      <td>0.014269</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Wind Installed capital</td>\n",
+       "      <td>[72700000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...</td>\n",
+       "      <td>0.014768</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>Financing cash outflow</td>\n",
+       "      <td>Dividends paid</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, -18026615.717025425, -179...</td>\n",
+       "      <td>0.040724</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>Operating Revenue</td>\n",
+       "      <td>Sale of non-depreciable assets</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...</td>\n",
+       "      <td>0.000108</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>Operating Revenue</td>\n",
+       "      <td>Cash on hand recovery</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...</td>\n",
+       "      <td>0.000183</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>Financing cash inflow</td>\n",
+       "      <td>Monetized tax losses</td>\n",
+       "      <td>[0.0, -1160413.6030666668, -1160413.6030666668...</td>\n",
+       "      <td>0.002839</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>Financing cash inflow</td>\n",
+       "      <td>One time capital incentive</td>\n",
+       "      <td>[21810000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...</td>\n",
+       "      <td>0.004430</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28</th>\n",
+       "      <td>Financing cash inflow</td>\n",
+       "      <td>Inflow of debt</td>\n",
+       "      <td>[43058018.66666667, 0.0, 0.0, 0.0, 0.0, 0.0, 0...</td>\n",
+       "      <td>0.008747</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>Financing cash inflow</td>\n",
+       "      <td>Inflow of equity</td>\n",
+       "      <td>[86116037.33333333, 2008118.3455666672, 185364...</td>\n",
+       "      <td>0.021550</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>30</th>\n",
+       "      <td>Operating Revenue</td>\n",
+       "      <td>Electricity sales</td>\n",
+       "      <td>[0.0, 0.0, 0.0, 0.0, 22668389.495696887, 23235...</td>\n",
+       "      <td>0.083433</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Type                            Name  \\\n",
+       "2       Operating Expenses        Licensing and Permitting   \n",
+       "3   Financing cash outflow     Capital gains taxes payable   \n",
+       "4       Operating Expenses          Non-depreciable assets   \n",
+       "5       Operating Expenses                    Rent of land   \n",
+       "6       Operating Expenses                           Labor   \n",
+       "7       Operating Expenses            Cash on hand reserve   \n",
+       "8       Operating Expenses         Administrative expenses   \n",
+       "9       Operating Expenses              Property insurance   \n",
+       "10      Operating Expenses        Total annual maintenance   \n",
+       "11      Operating Expenses                       Sales tax   \n",
+       "12      Operating Expenses                Credit card fees   \n",
+       "13  Financing cash outflow               Repayment of debt   \n",
+       "14  Financing cash outflow       Battery Installed capital   \n",
+       "15  Financing cash outflow            PV Installed capital   \n",
+       "16  Financing cash outflow                Interest expense   \n",
+       "17  Financing cash outflow            Income taxes payable   \n",
+       "18      Operating Expenses            Wind Fixed O&M Costs   \n",
+       "19  Financing cash outflow          Wind Installed capital   \n",
+       "20  Financing cash outflow                  Dividends paid   \n",
+       "24       Operating Revenue  Sale of non-depreciable assets   \n",
+       "25       Operating Revenue           Cash on hand recovery   \n",
+       "26   Financing cash inflow            Monetized tax losses   \n",
+       "27   Financing cash inflow      One time capital incentive   \n",
+       "28   Financing cash inflow                  Inflow of debt   \n",
+       "29   Financing cash inflow                Inflow of equity   \n",
+       "30       Operating Revenue               Electricity sales   \n",
+       "\n",
+       "                                               Amount       NPV  \n",
+       "2   [0.0, 0.0, 0.0, 0.0, 2153.781249999999, 2207.6...  0.000008  \n",
+       "3   [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...  0.000011  \n",
+       "4   [-304056, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  0.000062  \n",
+       "5   [0.0, 0.0, 0.0, 0.0, 53844.531249999985, 55190...  0.000198  \n",
+       "6   [0.0, 0.0, 0.0, 0.0, 58710.46303927179, 60982....  0.000246  \n",
+       "7   [0.0, 154470.6419666667, 0.0, 0.0, 130772.5676...  0.000255  \n",
+       "8   [0.0, 0.0, 0.0, 0.0, 113341.94747848444, 11617...  0.000417  \n",
+       "9   [0.0, 0.0, 0.0, 0.0, 1121535.504, 897775.70399...  0.000824  \n",
+       "10  [0.0, 0.0, 0.0, 0.0, 323067.1874999999, 331143...  0.001189  \n",
+       "11  [-0.0, -0.0, -0.0, -0.0, -521372.9584010284, -...  0.001919  \n",
+       "12  [-0.0, -0.0, -0.0, -0.0, -566709.7373924222, -...  0.002086  \n",
+       "13  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...  0.004957  \n",
+       "14  [29980000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...  0.006090  \n",
+       "15  [48000000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...  0.009750  \n",
+       "16  [0.0, 3014061.306666667, 3014061.306666667, 30...  0.010612  \n",
+       "17  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10479...  0.012905  \n",
+       "18  [0.0, 0.0, 0.0, 0.0, 3876806.2499999986, 39737...  0.014269  \n",
+       "19  [72700000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...  0.014768  \n",
+       "20  [0.0, 0.0, 0.0, 0.0, -18026615.717025425, -179...  0.040724  \n",
+       "24  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...  0.000108  \n",
+       "25  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...  0.000183  \n",
+       "26  [0.0, -1160413.6030666668, -1160413.6030666668...  0.002839  \n",
+       "27  [21810000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0...  0.004430  \n",
+       "28  [43058018.66666667, 0.0, 0.0, 0.0, 0.0, 0.0, 0...  0.008747  \n",
+       "29  [86116037.33333333, 2008118.3455666672, 185364...  0.021550  \n",
+       "30  [0.0, 0.0, 0.0, 0.0, 22668389.495696887, 23235...  0.083433  "
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pf.plot_costs()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                 cost\n",
+      "Name                                 \n",
+      "Wind Installed capital     72700000.0\n",
+      "PV Installed capital       48000000.0\n",
+      "Battery Installed capital  29980000.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pf.plot_capital_expenses()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pf.plot_cashflow()"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "c4181dcdfcea4d6481020f2ce48a9cbe5cdfeb7af5e211e5dfd3ac596bfed8bd"
+  },
+  "kernelspec": {
+   "display_name": "hopp",
+   "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.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/inputs/08-wind-solar-battery-profast.yaml b/examples/inputs/08-wind-solar-battery-profast.yaml
new file mode 100644
index 000000000..bd0fbba0e
--- /dev/null
+++ b/examples/inputs/08-wind-solar-battery-profast.yaml
@@ -0,0 +1,44 @@
+name: "Example 08"
+
+# SiteInfo
+site:
+  data:
+    lat: 35.2018863
+    lon: -101.945027
+    elev: 1099
+    year: 2012
+    tz: -6
+    site_boundaries:
+      verts:
+        - [3.06, 288.87]
+        - [0.0, 1084.03]
+        - [1784.05, 1084.24]
+        - [1794.09, 999.64]
+        - [1494.34, 950.97]
+        - [712.64, 262.8]
+        - [1216.98, 272.36]
+        - [1217.76, 151.62]
+        - [708.14, 0.0]
+    urdb_label: "5ca4d1175457a39b23b3d45e"
+  hub_height: 97.0
+  solar_resource_file: "resource_files/solar/35.2018863_-101.945027_psmv3_60_2012.csv"
+  wind_resource_file: "resource_files/wind/35.2018863_-101.945027_windtoolkit_2012_60min_80m_100m.srw"
+  grid_resource_file: "resource_files/grid/pricing-data-2015-IronMtn-002_factors.csv"
+  solar: true
+  wind: true
+  wave: false
+
+# Technologies
+technologies:
+  pv:
+    system_capacity_kw: 50000
+    dc_degradation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  wind:
+    num_turbines: 10
+    turbine_rating_kw: 5000
+  battery:
+    system_capacity_kwh: 20000
+    system_capacity_kw: 80000
+  grid:
+    interconnect_kw: 50000
+    ppa_price: 0.04
\ No newline at end of file
diff --git a/hopp/simulation/hybrid_simulation.py b/hopp/simulation/hybrid_simulation.py
index dcad3619e..457a9c76e 100644
--- a/hopp/simulation/hybrid_simulation.py
+++ b/hopp/simulation/hybrid_simulation.py
@@ -660,7 +660,14 @@ def simulate_power(self, project_life: int = 25, lifetime_sim=False):
         # Consolidate grid generation by copying over power and storage generation information
         if self.battery:
             self.grid.generation_profile_wo_battery = total_gen_before_battery
-        self.grid.simulate_grid_connection(hybrid_size_kw, total_gen, project_life, lifetime_sim, total_gen_max_feasible_year1)
+        self.grid.simulate_grid_connection(
+            hybrid_size_kw, 
+            total_gen, 
+            project_life, 
+            lifetime_sim,
+            total_gen_max_feasible_year1,
+            self.dispatch_builder.options
+        )
         self.grid.hybrid_nominal_capacity = hybrid_nominal_capacity
         self.grid.total_gen_max_feasible_year1 = total_gen_max_feasible_year1
         logger.info(f"Hybrid Peformance Simulation Complete. AEPs are {self.annual_energies}.")
diff --git a/hopp/simulation/technologies/dispatch/hybrid_dispatch_builder_solver.py b/hopp/simulation/technologies/dispatch/hybrid_dispatch_builder_solver.py
index 1c336553c..cbc5d694f 100644
--- a/hopp/simulation/technologies/dispatch/hybrid_dispatch_builder_solver.py
+++ b/hopp/simulation/technologies/dispatch/hybrid_dispatch_builder_solver.py
@@ -509,7 +509,22 @@ def battery_heuristic(self):
             prices = self.power_sources['grid'].dispatch.electricity_sell_price
             self.power_sources['battery'].dispatch.prices = prices
 
-        self.power_sources['battery'].dispatch.set_fixed_dispatch(tot_gen, grid_limit)
+        if  'load_following' in self.options.battery_dispatch:
+            # TODO: Look into how to define a system as load following or not in the config file
+            required_keys = ['desired_load']
+            if self.site.follow_desired_schedule:
+                # Get difference between baseload demand and power generation and control scenario variables
+                load_value = self.site.desired_schedule
+                load_difference =  [(load_value[x] - tot_gen[x]) for x in range(len(tot_gen))]
+                self.power_sources['battery'].dispatch.load_difference = load_difference
+            else:
+                raise ValueError(type(self).__name__ + " requires the following : desired_schedule")
+            # Adding goal_power for the simple battery heuristic method for power setpoint tracking 
+            goal_power = [load_value]*self.options.n_look_ahead_periods
+            ### Note: the inputs grid_limit and goal_power are in MW ###
+            self.power_sources['battery'].dispatch.set_fixed_dispatch(tot_gen, grid_limit, load_value)
+        else:
+            self.power_sources['battery'].dispatch.set_fixed_dispatch(tot_gen, grid_limit)
 
     @property
     def pyomo_model(self) -> pyomo.ConcreteModel:
diff --git a/hopp/simulation/technologies/dispatch/hybrid_dispatch_options.py b/hopp/simulation/technologies/dispatch/hybrid_dispatch_options.py
index b6a5fb4e8..69c26f1da 100644
--- a/hopp/simulation/technologies/dispatch/hybrid_dispatch_options.py
+++ b/hopp/simulation/technologies/dispatch/hybrid_dispatch_options.py
@@ -5,7 +5,8 @@
     SimpleBatteryDispatchHeuristic,
     SimpleBatteryDispatch,
     NonConvexLinearVoltageBatteryDispatch,
-    ConvexLinearVoltageBatteryDispatch
+    ConvexLinearVoltageBatteryDispatch,
+    HeuristicLoadFollowingDispatch,
 )
 
 
@@ -52,6 +53,10 @@ class HybridDispatchOptions:
 
             - **clustering_divisions** (dict, default={}): Custom number of averaging periods for classification metrics for data clustering. If empty, default values will be used.
 
+            - **use_higher_hours** bool (default = False): if True, the simulation will run extra hours analysis (must be used with load following)
+
+            - **higher_hours** (dict, default = {}): Higher hour count parameters: the value of power that must be available above the schedule and the number of hours in a row   
+
     """
     def __init__(self, dispatch_options: dict = None):
         self.solver: str = 'cbc'
@@ -74,6 +79,9 @@ def __init__(self, dispatch_options: dict = None):
         self.clustering_weights: dict = {}
         self.clustering_divisions: dict = {}
 
+        self.use_higher_hours: bool = False
+        self.higher_hours: dict = {}
+
         if dispatch_options is not None:
             for key, value in dispatch_options.items():
                 if hasattr(self, key):
@@ -103,7 +111,8 @@ def __init__(self, dispatch_options: dict = None):
             'heuristic': SimpleBatteryDispatchHeuristic,
             'simple': SimpleBatteryDispatch,
             'non_convex_LV': NonConvexLinearVoltageBatteryDispatch,
-            'convex_LV': ConvexLinearVoltageBatteryDispatch}
+            'convex_LV': ConvexLinearVoltageBatteryDispatch,
+            'load_following_heuristic': HeuristicLoadFollowingDispatch}
         if self.battery_dispatch in self._battery_dispatch_model_options:
             self.battery_dispatch_class = self._battery_dispatch_model_options[self.battery_dispatch]
             if 'heuristic' in self.battery_dispatch:
diff --git a/hopp/simulation/technologies/dispatch/power_storage/__init__.py b/hopp/simulation/technologies/dispatch/power_storage/__init__.py
index 15951a51d..73592b774 100644
--- a/hopp/simulation/technologies/dispatch/power_storage/__init__.py
+++ b/hopp/simulation/technologies/dispatch/power_storage/__init__.py
@@ -4,3 +4,4 @@
 from hopp.simulation.technologies.dispatch.power_storage.power_storage_dispatch import PowerStorageDispatch
 from hopp.simulation.technologies.dispatch.power_storage.simple_battery_dispatch import SimpleBatteryDispatch
 from hopp.simulation.technologies.dispatch.power_storage.simple_battery_dispatch_heuristic import SimpleBatteryDispatchHeuristic
+from hopp.simulation.technologies.dispatch.power_storage.heuristic_load_following_dispatch import HeuristicLoadFollowingDispatch
diff --git a/hopp/simulation/technologies/dispatch/power_storage/heuristic_load_following_dispatch.py b/hopp/simulation/technologies/dispatch/power_storage/heuristic_load_following_dispatch.py
new file mode 100644
index 000000000..2d6ae049a
--- /dev/null
+++ b/hopp/simulation/technologies/dispatch/power_storage/heuristic_load_following_dispatch.py
@@ -0,0 +1,62 @@
+from typing import Optional, List
+
+import pyomo.environ as pyomo
+from pyomo.environ import units as u
+import PySAM.BatteryStateful as BatteryModel
+import PySAM.Singleowner as Singleowner
+
+from hopp.simulation.technologies.dispatch.power_storage.simple_battery_dispatch_heuristic import SimpleBatteryDispatchHeuristic
+
+
+class HeuristicLoadFollowingDispatch(SimpleBatteryDispatchHeuristic):
+    """Operates the battery based on heuristic rules to meet the demand profile based power available from power generation profiles and 
+        power demand profile.
+
+    Currently, enforces available generation and grid limit assuming no battery charging from grid
+    """
+    def __init__(self,
+                 pyomo_model: pyomo.ConcreteModel,
+                 index_set: pyomo.Set,
+                 system_model: BatteryModel.BatteryStateful,
+                 financial_model: Singleowner.Singleowner,
+                 fixed_dispatch: Optional[List] = None,
+                 block_set_name: str = 'heuristic_load_following_battery',
+                 dispatch_options: Optional[dict] = None):
+        """
+
+        Args:
+            fixed_dispatch: list of normalized values [-1, 1] (Charging (-), Discharging (+))
+        """
+        super().__init__(
+            pyomo_model,
+            index_set,
+            system_model,
+            financial_model,
+            fixed_dispatch,
+            block_set_name,
+            dispatch_options
+        )
+
+    def set_fixed_dispatch(self, gen: list, grid_limit: list, goal_power: list):
+        """Sets charge and discharge power of battery dispatch using fixed_dispatch attribute and enforces available
+        generation and grid limits.
+
+        """
+        self.check_gen_grid_limit(gen, grid_limit)
+        self._set_power_fraction_limits(gen, grid_limit)
+        self._heuristic_method(gen, goal_power)
+        self._fix_dispatch_model_variables()
+
+    def _heuristic_method(self, gen, goal_power):
+        """ Enforces battery power fraction limits and sets _fixed_dispatch attribute
+            Sets the _fixed_dispatch based on goal_power and gen (power genration profile)
+        """
+        for t in self.blocks.index_set():
+            fd = (goal_power[t] - gen[t]) / self.maximum_power
+            if fd > 0.0:    # Discharging
+                if fd > self.max_discharge_fraction[t]:
+                    fd = self.max_discharge_fraction[t]
+            elif fd < 0.0:  # Charging
+                if -fd > self.max_charge_fraction[t]:
+                    fd = -self.max_charge_fraction[t]
+            self._fixed_dispatch[t] = fd        
\ No newline at end of file
diff --git a/hopp/simulation/technologies/dispatch/power_storage/simple_battery_dispatch_heuristic.py b/hopp/simulation/technologies/dispatch/power_storage/simple_battery_dispatch_heuristic.py
index 09077aac8..8c5760693 100644
--- a/hopp/simulation/technologies/dispatch/power_storage/simple_battery_dispatch_heuristic.py
+++ b/hopp/simulation/technologies/dispatch/power_storage/simple_battery_dispatch_heuristic.py
@@ -1,3 +1,5 @@
+from typing import Optional, List, Dict
+
 import pyomo.environ as pyomo
 from pyomo.environ import units as u
 
@@ -17,9 +19,9 @@ def __init__(self,
                  index_set: pyomo.Set,
                  system_model: BatteryModel.BatteryStateful,
                  financial_model: Singleowner.Singleowner,
-                 fixed_dispatch: list = None,
+                 fixed_dispatch: Optional[List] = None,
                  block_set_name: str = 'heuristic_battery',
-                 dispatch_options: dict = None):
+                 dispatch_options: Optional[Dict] = None):
         """
 
         :param fixed_dispatch: list of normalized values [-1, 1] (Charging (-), Discharging (+))
@@ -60,8 +62,13 @@ def check_gen_grid_limit(self, gen: list, grid_limit: list):
             raise ValueError("grid_limit must be the same length as fixed_dispatch.")
 
     def _set_power_fraction_limits(self, gen: list, grid_limit: list):
-        """Set battery charge and discharge power fraction limits based on available generation and grid capacity,
-        respectively.
+        """
+        Set battery charge and discharge power fraction limits based on
+        available generation and grid capacity, respectively.
+
+        Args:
+            gen: generation Blocks
+            grid_limit: grid capacity
 
         NOTE: This method assumes that battery cannot be charged by the grid.
         """
@@ -71,28 +78,52 @@ def _set_power_fraction_limits(self, gen: list, grid_limit: list):
                                                                                        / self.maximum_power)
 
     @staticmethod
-    def enforce_power_fraction_simple_bounds(power_fraction) -> float:
-        """ Enforces simple bounds (0,1) for battery power fractions."""
-        if power_fraction > 1.0:
-            power_fraction = 1.0
+    def enforce_power_fraction_simple_bounds(power_fraction: float) -> float:
+        """
+        Enforces simple bounds (0, .9) for battery power fractions.
+        
+        Args:
+            power_fraction: power fraction from heuristic method
+
+        Returns:
+            bounded power fraction
+        """
+        if power_fraction > 0.9:
+            power_fraction = 0.9
         elif power_fraction < 0.0:
             power_fraction = 0.0
         return power_fraction
 
-    def update_soc(self, power_fraction, soc0) -> float:
+    def update_soc(self, power_fraction: float, soc0: float) -> float:
+        """
+        Updates SOC based on power fraction threshold (0.1).
+        
+        Args:
+            power_fraction: power fraction from heuristic method. Below threshold
+                is charging, above is discharging
+            soc0: initial SOC
+        
+        Returns:
+            Updated SOC.
+        """
         if power_fraction > 0.0:
             discharge_power = power_fraction * self.maximum_power
             soc = soc0 - self.time_duration[0] * (1/(self.discharge_efficiency/100.) * discharge_power) / self.capacity
         elif power_fraction < 0.0:
-            charge_power = - power_fraction * self.maximum_power
+            charge_power = -power_fraction * self.maximum_power
             soc = soc0 + self.time_duration[0] * (self.charge_efficiency / 100. * charge_power) / self.capacity
         else:
             soc = soc0
-        soc = max(0, min(1, soc))
+
+        min_soc = self._system_model.value("minimum_SOC") / 100
+        max_soc = self._system_model.value("maximum_SOC") / 100
+
+        soc = max(min_soc, min(max_soc, soc))
+
         return soc
 
     def _heuristic_method(self, _):
-        """ Does specific heuristic method to fix battery dispatch."""
+        """Does specific heuristic method to fix battery dispatch."""
         self._enforce_power_fraction_limits()
 
     def _enforce_power_fraction_limits(self):
diff --git a/hopp/simulation/technologies/grid.py b/hopp/simulation/technologies/grid.py
index 701052115..a080061ab 100644
--- a/hopp/simulation/technologies/grid.py
+++ b/hopp/simulation/technologies/grid.py
@@ -1,4 +1,4 @@
-from typing import Iterable, List, Sequence, Optional, Union
+from typing import Iterable, List, Sequence, Optional, Union, TYPE_CHECKING
 
 import numpy as np
 from attrs import define, field
@@ -11,7 +11,10 @@
 from hopp.simulation.technologies.financial import FinancialModelType, CustomFinancialModel
 from hopp.type_dec import NDArrayFloat
 from hopp.utilities.validators import gt_zero
+from hopp.utilities.log import hybrid_logger as logger
 
+if TYPE_CHECKING:
+    from hopp.simulation.technologies.dispatch.hybrid_dispatch_options import HybridDispatchOptions
 
 @define
 class GridConfig(BaseClass):
@@ -91,7 +94,8 @@ def simulate_grid_connection(
         total_gen: Union[List[float], NDArrayFloat], 
         project_life: int, 
         lifetime_sim: bool, 
-        total_gen_max_feasible_year1: Union[List[float], NDArrayFloat]
+        total_gen_max_feasible_year1: Union[List[float], NDArrayFloat],
+        dispatch_options: Optional["HybridDispatchOptions"] = None
     ):
         """
         Sets up and simulates hybrid system grid connection. Additionally,
@@ -108,6 +112,8 @@ def simulate_grid_connection(
                 data is repeated
             total_gen_max_feasible_year1: Maximum generation profile of the hybrid
                 system (for capacity payments) [kWh]
+            dispatch_options: Hybrid dispatch options class, deliminates if the higher
+                power analysis for frequency regulation is run
 
         """
         if self.site.follow_desired_schedule:
@@ -125,8 +131,65 @@ def simulate_grid_connection(
             self.schedule_curtailed = np.array([gen - schedule if gen > schedule else 0. for (gen, schedule) in
                                             zip(total_gen, lifetime_schedule)])
             self.schedule_curtailed_percentage = sum(self.schedule_curtailed)/sum(lifetime_schedule)
+
+            # NOTE: This is currently only happening for load following, would be good to make it more general
+            #           i.e. so that this analysis can be used when load following isn't being used (without storage)
+            #           for comparison 
+            N_hybrid = len(self.generation_profile)
+
+            final_power_production = total_gen
+            schedule = [x for x in lifetime_schedule]
+            hybrid_power = [(final_power_production[x] - (schedule[x]*0.95)) for x in range(len(final_power_production))]
+
+            load_met = len([i for i in hybrid_power if i  >= 0])
+            self.time_load_met = 100 * load_met/N_hybrid
+
+            final_power_array = np.array(final_power_production)
+            power_met = np.where(final_power_array > schedule, schedule, final_power_array)
+            self.capacity_factor_load = np.sum(power_met) / np.sum(schedule) * 100
+
+            logger.info('Percent of time firm power requirement is met: ', np.round(self.time_load_met,2))
+            logger.info('Percent total firm power requirement is satisfied: ', np.round(self.capacity_factor_load,2))
+
+            ERS_keys = ['min_regulation_hours', 'min_regulation_power']
+            if dispatch_options is not None and dispatch_options.use_higher_hours:
+                """
+                Frequency regulation analysis for providing essential reliability services (ERS) availability operating case:
+                        Finds how many hours (in the group specified group size above the specified minimum
+                        power requirement) that the system has available to extra power that could be used to 
+                        provide ERS
+                Args:
+                    :param dispatch_options: need additional ERS arguments
+                                        'min_regulation_hours': minimum size of hours in a group to be considered for ERS (>= 1)
+                                        'min_regulation_power': minimum power available over the whole group of hours to be 
+                                                considered for ERS (> 0, in kW)
+
+                :returns: total_number_hours
+
+                """
+
+                # Performing frequency regulation analysis:
+                #    finding how many groups of hours satisfiy the ERS minimum power requirement
+                min_regulation_hours = dispatch_options.higher_hours['min_regulation_hours']
+                min_regulation_power = dispatch_options.higher_hours['min_regulation_power']
+
+                frequency_power_array = np.array(hybrid_power)
+                frequency_test = np.where(frequency_power_array > min_regulation_power, frequency_power_array, 0)
+                mask = (frequency_test!=0).astype(int)
+                padded_mask = np.pad(mask,(1,), "constant")
+                edge_mask = padded_mask[1:] - padded_mask[:-1]  # finding the difference between each array value
+
+                group_starts = np.where(edge_mask == 1)[0]
+                group_stops = np.where(edge_mask == -1)[0]
+
+                # Find groups and drop groups that are too small
+                groups = [group for group in zip(group_starts,group_stops) if ((group[1]-group[0]) >= min_regulation_hours)]
+                group_lengths = [len(final_power_production[group[0]:group[1]]) for group in groups]
+                self.total_number_hours = sum(group_lengths)
+
+                logger.info('Total number of hours available for ERS: ', np.round(self.total_number_hours,2))
         else:
-            self.generation_profile = list(total_gen)
+            self.generation_profile = total_gen
 
         self.total_gen_max_feasible_year1 = np.array(total_gen_max_feasible_year1)
         self.system_capacity_kw = hybrid_size_kw  # TODO: Should this be interconnection limit?
diff --git a/hopp/tools/dispatch/plot_tools.py b/hopp/tools/dispatch/plot_tools.py
index 7581eee8e..3fcf119a8 100644
--- a/hopp/tools/dispatch/plot_tools.py
+++ b/hopp/tools/dispatch/plot_tools.py
@@ -303,6 +303,13 @@ def plot_generation_profile(hybrid: HybridSimulation,
     ax.xaxis.set_ticks(list(range(start, end, hybrid.site.n_periods_per_day)))
     plt.grid()
     ax1 = plt.gca()
+
+    # Load following, if applicable
+    if hybrid.site.follow_desired_schedule:
+        desired_load = [p for p in hybrid.site.desired_schedule[time_slice]]
+        ax1.plot(time, desired_load, 'b--', label='Desired Load')
+        ax1.set_ylabel('Desired Load', fontsize=font_size)
+
     ax1.legend(fontsize=font_size-2, loc='upper left')
     ax1.set_ylabel('Power (MW)', fontsize=font_size)
 
@@ -335,6 +342,9 @@ def plot_generation_profile(hybrid: HybridSimulation,
     plt.xlabel('Time (hours)', fontsize=font_size)
     plt.title('Net Generation', fontsize=font_size)
 
+
+    plt.xlabel('Time (hours)', fontsize=font_size)
+    plt.title('Net Generation', fontsize=font_size)
     plt.tight_layout()
 
     if plot_filename is not None:
diff --git a/requirements-dev.txt b/requirements-dev.txt
index d0019162e..a065e45d1 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -3,4 +3,5 @@ pytest-subtests
 responses
 sphinx
 sphinx-rtd-theme
-sphinx-copybutton
\ No newline at end of file
+sphinx-copybutton
+Plotly
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index c93029223..91368e34c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,7 @@
 Cython
 NREL-PySAM==4.2.0
 Pillow
+Plotly
 Pyomo>=6.1.2
 diskcache
 fastkml
@@ -19,6 +20,7 @@ numpy-financial
 optuna
 pandas>=2.0.3
 pint
+plotly
 pvmismatch
 pyDOE2
 pymoo
@@ -42,3 +44,6 @@ CoolProp
 attrs
 utm
 pyyaml-include
+electrolyzer @ git+https://github.com/jaredthomas68/electrolyzer.git@smoothing
+ProFAST @ git+https://github.com/NREL/ProFAST.git
+openmdao
diff --git a/setup.py b/setup.py
index f55119176..ada6c28db 100644
--- a/setup.py
+++ b/setup.py
@@ -30,7 +30,9 @@
 ]
 
 package_data = {
-    "hopp": [str(file.relative_to(base_path)) for file in package_data_files]
+    "hopp": [str(file.relative_to(base_path)) for file in package_data_files],
+    "greenheart": [],
+    "ProFAST": []
 }
 
 setup(


Test patch:
diff --git a/tests/hopp/test_dispatch.py b/tests/hopp/test_dispatch.py
index 026179b71..b42c0c413 100644
--- a/tests/hopp/test_dispatch.py
+++ b/tests/hopp/test_dispatch.py
@@ -6,7 +6,7 @@
 from pyomo.util.check_units import assert_units_consistent
 
 from hopp.simulation import HoppInterface
-from hopp.simulation.technologies.sites import SiteInfo
+from hopp.simulation.technologies.sites import SiteInfo, flatirons_site
 from hopp.simulation.technologies.financial.custom_financial_model import CustomFinancialModel
 from hopp.simulation.technologies.wind.wind_plant import WindPlant, WindConfig
 from hopp.simulation.technologies.pv.pv_plant import PVPlant, PVConfig
@@ -992,3 +992,35 @@ def create_test_objective_rule(m):
     assert sum(battery.dispatch.discharge_power) > 0.0
     assert (sum(battery.dispatch.charge_power) * battery.dispatch.round_trip_efficiency / 100.0
             == pytest.approx(sum(battery.dispatch.discharge_power)))
+
+
+def test_hybrid_dispatch_baseload_heuristic_and_analysis(site):
+
+    desired_schedule = 8760*[20]
+
+    desired_schedule_site = SiteInfo(flatirons_site,
+                                     desired_schedule=desired_schedule)
+    wind_solar_battery = {key: technologies[key] for key in ('pv', 'wind', 'battery')}
+
+    dispatch_options = {'battery_dispatch': 'load_following_heuristic',
+                        'use_higher_hours': True, 
+                        'higher_hours': {'min_regulation_hours': 4, 'min_regulation_power': 5000}}
+
+    hopp_config = {
+        "site": desired_schedule_site,
+        "technologies": wind_solar_battery,
+        "config": {
+            "dispatch_options": dispatch_options
+        }
+    }
+    hopp_config["technologies"]["grid"] = {
+        "interconnect_kw": interconnect_mw * 1000
+    }
+    hi = HoppInterface(hopp_config)
+    hi.simulate(1)
+
+    hybrid_plant = hi.system
+
+    assert hybrid_plant.grid.time_load_met == pytest.approx(91.9, 1e-2)
+    assert hybrid_plant.grid.capacity_factor_load == pytest.approx(94.45, 1e-2)
+    assert hybrid_plant.grid.total_number_hours == pytest.approx(3732, 1e-2)
\ No newline at end of file