MJ2383_Lab_1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This line is specific when running from Colab and is used to\n",
    "# download all of the contents of Lab 1\n",
    "!git clone https://github.com/KTH-dESA/MJ2383.git\n",
    "!mv MJ2383/* .\n",
    "!rm -r MJ2383"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make sure to run this cell.\n",
    "# here we import all the libraries we will use in this session\n",
    "import numpy as np\n",
    "import itertools\n",
    "from plotly import express as px\n",
    "import pandas as pd\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, fixed\n",
    "from checkers import checker_df, checker_lcoe, checker_parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MJ2383: Lab 1 - Computing Levelised Cost of Electricity\n",
    "\n",
    "In this lab, we are going to explore computation of an important metric called **levelised cost of electricity**, or LCOE for short.\n",
    "\n",
    "The lab is broken up into several stages each of which culminates in writing a piece of Python code or doing some analysis. Don't worry if you've never written any Python before or done any programming - it is actually as easy as (or easier than) writing down equations.\n",
    "\n",
    "in [stage 0](#Stage-0---Basic-Python-commands) we'll go through Python basics. If you've never used Python or programming before, you'll want to start here.\n",
    "\n",
    "In [stage 1](#Stage-1---Compute-LCOE), we'll write a Python function that computes the levelised cost of electricity from input data. We'll then test that this function produces the result we expect. You'll be able to check that your function works at the end of the stage.\n",
    "\n",
    "In [stage 2](#Stage-2---Explore-Parameter-Values), we'll then use the function you wrote to compute LCOE for one technology and explore what happens when you change the parameter values.\n",
    "\n",
    "in [stage 3](#Stage-3:-Comparing-technologies), we'll use the LCOE function again to compare technologies against one another, and develop screen curves that allow us to visualise the trade-offs between technologies as a function of load factor.\n",
    "\n",
    "## Housekeeping\n",
    "\n",
    "- This is a Jupyter notebook. A notebook contains cells. Each cell contains either descriptive text (like this) or Python code.  You execute a cell by pressing `Shift + Enter` or using the `Run` button <i class=\"fa-play fa\" style=\"font-size: 12px;color:#666;\"></i>\n",
    "\n",
    "- To add a new cell you can use the `Plus` <i class=\"fa-plus fa\" style=\"font-size: 12px;color:#666;\"></i> button in the menu bar at the top of the page.\n",
    "  \n",
    "- Don't worry, you cannot break anything. If you think you've made a mistake, you can delete the content and try again. If you get really stuck, just open the original notebook again and make a fresh start\n",
    "  \n",
    "- Also, each stage allows you to begin afresh, so you can just move on when you are ready\n",
    "  \n",
    "- If you like, work together in pairs sharing a screen\n",
    "  \n",
    "- The notebook has been designed to help support your learning by enabling you to explore but also to challenge you. However, we are not trying to trick you. In most cases, the answers are in front of you\n",
    "  \n",
    "- If you have questions, please ask us!\n",
    "  \n",
    "- If you have any suggestions for how this could be improved, or find a bug or problem, please submit an issue\n",
    "  [here](https://github.com/KTH-dESA/MJ2383/issues/new/choose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"Stage-0---Basic-Python-commands\"></a>\n",
    "## Stage 0 - Basic Python commands\n",
    "In this section, we will go through an overview of the most basics in python. If you already have knowledge of python you can skip this stage and move to [stage 1](#Stage-1---Compute-LCOE).\n",
    "\n",
    "In Python we use the hash symbol `#` to make a comment in the code. A comment is for clarification porpuses to the person reading the code, but it is ignored by the computer when you run the program, thus having no effect on your code output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a comment used to provide additional information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python there exist many types of data, in here we are going to cover the most basic ones: integers, floats, strings, lists, dictionaries and arrays.\n",
    "\n",
    "```python\n",
    "integer (int): 5\n",
    "float: 2.6\n",
    "string (str): 'this is a string'\n",
    "list: [1, 2, 3, 4]\n",
    "dictionary (dict): {'key_1': value_1, 'Key_2': val\n",
    "numpy.ndarrayue_2da: np.array([3, 4, 6, 4])\n",
    "```\n",
    "* An integer is a whole number (not a fractional number) that can be positive, negative, or zero.\n",
    "* A float is any positive or negative decimal number (any number with a decimal point in it e.g. 2.4, 12.909 or -0.3).\n",
    "* A string represents text. It is a sequence of characters and can contain letters, numbers, symbols and even spaces. It must be enclosed in quotation marks for it to be recognized as a string.\n",
    "* Lists are one of the most used data structures in Python. They allow us to store elements of different data types in one ordered container. \n",
    "The contents of a list are enclosed by square brackets.\n",
    "* Dictionaries are used to store data values in `key: value` pairs. They are a collection of values and identifiers. Dictionaries are written with curly brackets, specifying their keys and value pairs.\n",
    "* NumPy arrays are represented as a grid of elements, all of the same data type, arranged in rows and columns, and can have multiple dimensions (e.g., 1D, 2D, or higher). NumPy arrays are used for efficient numerical computations and mathematical operations, making them essential for tasks involving data manipulation, scientific computing, and data analysis in Python.\n",
    "\n",
    "we can use the function `type` to check the type of a value. Pass different data types to the `type` function to see the different output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(1) # change the data inside parenthesis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic operators\n",
    "You can actually use Python as a calculator to compute equations and store values into variables. This means that you can use basic mathematical operators:\n",
    "```\n",
    "+   addition\n",
    "-   subtraction\n",
    "*   multiplication\n",
    "/   division\n",
    "**  exponent\n",
    "//  floor division\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3 + 5 * 10) / 4 - 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also store the output of an operation into a variable and use such variable for further operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3 ** 2\n",
    "y = 4 * x\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists and arrays\n",
    "Lists are variables containing a sequence of ints, floats, strings etc., even other lists.... Whatever you want to put in your list. We create a list by using square brackets `[]` and passing the values of the list separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3.5, 'Some text']\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access an element of a list by specifying the location of the element in order, counting the first position as 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An array is a list of values, which allows to make numerical calculations very efficiently. We create an array by calling the `numpy` library function `np.array()` and passing a list as argument (inside the parentesis):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array = np.array([1, 2, 3, 4])\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can use this array to make some elementwise computations or even pairwise computations between two arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array * np.array([4, 5, 6, 7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even sum all of the values of the array by calling the function `sum()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with lists, we can access value from the array specifying the location of the lements that we want (starting with 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also access several elements at a time by passing a list of their locations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array[[1, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Dictionaries are used to store data values in `key: value` pairs. They are a collection of values and identifiers. A dictionary is a collection which is ordered, changeable and do not allow duplicates.\n",
    "\n",
    "Dictionaries are written with curly brackets, and have keys and values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary = {'Name': 'John Doe',\n",
    "                 'Age': 30,\n",
    "                 'Address': 'Some street 83'}\n",
    "my_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary items are presented in `key: value` pairs, and can be referred to by using the key name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary['Name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even modify a value of a key by overwritting it value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary['Age'] = 35\n",
    "my_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary can have as value a dictionary too, or any other data structure. It is very common to have nested dictionaries to store data under different categories."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"Stage-1---Compute-LCOE\"></a>\n",
    "## Stage 1 - Compute LCOE\n",
    "\n",
    "According to [OEE](http://www.open-electricity-economics.org/book/text/03.html) the formula to calculate LCOE is as follows:\n",
    "\n",
    "$LCOE = \\frac{C_{fix} + \\sum_{y=1}^Y DF_y \\cdot C_y}{\\sum_{y=1}^Y DF_y \\cdot G_y}$\n",
    "\n",
    "where LCOE is the levelized cost in EUR per kWh, $C_{fix}$ is the capital investment costs incurred for setting up the project, $C_y$ are operational costs incurred in year $y$, $Y$ is the technical lifetime in years, and $G_y$ is electricity generation in kWh. The costs are called levelized because they are “leveled” over all units of output. Levelized costs can be calculated for a specific power plant or for generic types of generation technologies.\n",
    "\n",
    "Discount factor ($DF$) is calculated for each year ($y$) of the plant's technical lifetime\n",
    "\n",
    "$DF_y =  (1 + r)^{-y}$\n",
    "\n",
    "where $r$ is the discount rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can store the technical lifetime of our technology in a *variable* called ``technical_lifetime``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "technical_lifetime = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the value stored in the *variable* at anytime, by typing its name and press `shift` + `enter`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "technical_lifetime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then create an *array* of years using the value stored in ``technical_lifetime``. \n",
    "\n",
    "An *array* is like a list of values. The command ``np.arange()`` takes a number as an argument and creates an *array* of the same length containing the values from 0 to one less than the number. You can always check what are the parameters that a command (or function) accepts and what it returns as result. For this you can type the name of the function you need and open parenthesis, wait a second and the documentation window will appear:\n",
    "\n",
    "![Documentation](https://raw.githubusercontent.com/KTH-dESA/MJ2383/main/img/DocstringColab.gif \"Documentation\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "years = np.arange(technical_lifetime)\n",
    "years"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we calculate $DF$ for each year in our plant's technical lifetime according to the formula we saw earlier:\n",
    "$DF_y =  (1 + r)^{-y}$; $r$ is the discount rate, and $y$ is the year.\n",
    "\n",
    "**Implement the DF formula in the cell below. Remember that to exponentiate in Python we use** `**`.\n",
    "\n",
    "**Q. What happens if you change the discount rate?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "discount_rate = 0.05\n",
    "df = \"replace with formula\"\n",
    "print(df) # we use the command print, to show the values stored inside the df variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell to check your answer\n",
    "checker_df(value=df, \n",
    "           discount_rate=discount_rate, \n",
    "           years=years)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we've calculated $DF$, let's get some data for the other parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capital_costs = 1000.0  # €\n",
    "operational_costs = np.repeat(500, technical_lifetime)  # €\n",
    "electricity_generation = np.repeat(8760., technical_lifetime)  # kWh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code above creates variables, each containing an *array* of values. We automatically generate the arrays using `np.repeat(50, technical_lifetime)`. This creates an array of length `technical_lifetime` where each element in the array contains the value `50`.\n",
    "\n",
    "---\n",
    "\n",
    "Remember the formula? Let's check it again:\n",
    "\n",
    "\\\\(LCOE = \\frac{C_{fix} + \\sum_{y=1}^Y DF_y \\cdot C_y}{\\sum_{y=1}^Y DF_y \\cdot G_y}\\\\)\n",
    "\n",
    "Now, implement the LCOE formula in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lcoe = \"replace with formula\"\n",
    "print(lcoe)  # €/kWh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "checker_lcoe(value=lcoe, \n",
    "             capital_costs=capital_costs, \n",
    "             operational_costs=operational_costs, \n",
    "             electricity_generation=electricity_generation, \n",
    "             discount_rate=discount_rate, \n",
    "             technical_lifetime=technical_lifetime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"Writing-a-reusable-LCOE-function\"></a>\n",
    "### Writing a reusable LCOE function\n",
    "At the moment, this seems a pretty arbitrary result. We're just putting in nonsense data, and we are getting nonsense in return. In stage 2, we'll start working with real data, but first, we need to make this calculation re-useable.\n",
    "\n",
    "---\n",
    "\n",
    "In Python, if we want to reuse a piece of code, we'll create a \"function\". To do this, you use the ``def`` command like this:\n",
    "\n",
    "```python\n",
    "def get_lcoe(capital_costs, operational_costs, electricity_generation, discount_rate, technical_lifetime):\n",
    "    # <<Something should go here>>\n",
    "    return lcoe\n",
    "```\n",
    "\n",
    "- In the above example `get_lcoe` is the name of the function\n",
    "- The list of names in the round brackets `()` are arguments\n",
    "- Don't forget the `:` at the end of the list of arguments\n",
    "- Use four spaces to indent your code\n",
    "- The argument passed to `return` in the last line is what the function will give back when you run it\n",
    "\n",
    "**Q. What should go in the function?**\n",
    "\n",
    "Have a go below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_lcoe(capital_costs, operational_costs, electricity_generation, discount_rate, technical_lifetime):\n",
    "    # Write your code next, be sure to include any variable needed to calculate the lcoe value.\n",
    "    # Use the input variables of the function: \n",
    "    # (capital_costs, operational_costs, electricity_generation, discount_rate, technical_lifetime)\n",
    "    \n",
    "    # <Your code here>\n",
    "    years = \"replace with formula\"\n",
    "    df = \"replace with formula\"\n",
    "    lcoe = \"replace with formula\"\n",
    "    return lcoe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your `lcoe` function by running the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With the next line we make a call to the function you wrote passing some input values\n",
    "actual = get_lcoe(capital_costs=5000, \n",
    "                  operational_costs=np.array([100, 100, 100, 100]), \n",
    "                  electricity_generation=np.array([8760, 8760, 8760, 8760]), \n",
    "                  discount_rate=0.1, \n",
    "                  technical_lifetime=4)\n",
    "# We print the results\n",
    "print(actual)\n",
    "\n",
    "# We run the checker with your calculation and the same input data, to see if the results is correct\n",
    "checker_lcoe(value=actual, \n",
    "             capital_costs=5000, \n",
    "             operational_costs=np.array([100, 100, 100, 100]), \n",
    "             electricity_generation=np.array([8760, 8760, 8760, 8760]), \n",
    "             discount_rate=0.1, \n",
    "             technical_lifetime=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stage 1 - Summary\n",
    "\n",
    "If you managed to get it to work, well done! You've written a Python function which computes LCOE. If not, don't worry, the answer is below! Make sure to write it in the function so the following steps of the Lab work.\n",
    "\n",
    "- In this stage, we introduced the LCOE equation\n",
    "\\\\(LCOE = \\frac{C_{fix} + \\sum_{y=1}^Y DF_y \\cdot C_y}{\\sum_{y=1}^Y DF_y \\cdot G_y}\\\\)\n",
    "and implemented it using a Python function.\n",
    "- We also explored how the capital recovery factors weighs future years differently as a function of the discount rate.\n",
    "- We learnt a lot of Python concepts including *variables*, *arrays*, and *arguments*.\n",
    "- We learnt how to reuse Python code by writing a function.\n",
    "\n",
    "In the next stage, we'll extend our function to make it more useful and investigate the LCOE calculation itself.\n",
    "\n",
    "### Stage 1 - Answer LCOE Function\n",
    "\n",
    "As you can see, we just need to fill in the gaps. First build the array of years, calculate the array of DF and then add the lcoe calculation.\n",
    "```python\n",
    "def get_lcoe(capital_costs, operational_costs, electricity_generation, discount_rate, technical_lifetime):\n",
    "    year = np.arange(technical_lifetime)\n",
    "    df = (1 + discount_rate) ** - year\n",
    "    lcoe = (capital_costs + sum(df * operational_costs)) / sum(df * electricity_generation)\n",
    "    return lcoe\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"Stage-2---Explore-Parameter-Values\"></a>\n",
    "## Stage 2 - Explore Parameter Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll now make use of an LCOE function to explore the effect of different parameter values for one technology &mdash; a combined cycle gas turbine. In the following implementation of LCOE, we make the assumption that the yearly values for operational costs and electricity generation are the same in each year of the technology's lifetime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the parameters for a combined cycle gas turbine (CCGT):\n",
    "\n",
    "Parameter | Unit |Value\n",
    "---|---|---\n",
    "Lifetime| |25\n",
    "Discount rate | |\t\t\t8.0%\n",
    "Station size | MW |\t750.0\n",
    "Overnight cost | €/kW | 750.0\n",
    "Fixed O&M cost | €/kW\t| 3.0\n",
    "Efficiency | | 0.5\n",
    "Fuel price | €/kWh| 0.03\n",
    "Emission Factor\t| ton/kW-yr| 1.8\n",
    "Load factor | | 0.75\n",
    "\n",
    "Here's the information we need to calculate the LCOE using the simple LCOE equation we developed earlier.\n",
    "\n",
    "Parameter | Unit |Value\n",
    "---|---|---\n",
    "Capital cost | € | ?\n",
    "Electricity generation | kWh | ?\n",
    "Annual fixed O&M cost |\t€\t| ?\n",
    "Annual variable O&M cost |€| ?\n",
    "Annual operational cost | € | ?\n",
    "\n",
    "**Q. What's the levelised cost of electricity for the CCGT plant?**\n",
    "- work through the list of inputs methodically. \n",
    "- Pay close attention to the units.  \n",
    "- Use Python variables to store information you reuse.\n",
    "\n",
    "### Hints\n",
    "\n",
    "- Remember there are approximately `365 * 24 = 8760` hours in a year.\n",
    "- The load factor describes the proportion of those 8760 hours the plant is operational.\n",
    "- Total operational costs are made up of fixed costs (not a function of activity) and variable costs (function of activity).\n",
    "- The fixed costs are a function of capacity.\n",
    "- The variable cost will be the product of the amount of fuel used and the fuel price.\n",
    "- Fuel use can be computed from electricity generation and efficiency.\n",
    "- Create any new variable if you need to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Populate some variables using the information from the table\n",
    "\n",
    "lifetime = \n",
    "discount_rate = \n",
    "capacity =  # kW\n",
    "overnight_cost =  # €/kW the cost of a project if no interest was incurred during construction, as if the project was completed \"overnight.\"\n",
    "fixed_om_cost =  # €/kW\n",
    "efficiency = \n",
    "fuel_price =  # €/kWh\n",
    "load_factor = \n",
    "\n",
    "# 2. Calculate the intermediate values (you can use Python like a calculator)\n",
    "# Use *+-/ for multiply, add, substract, divide and np.repeat().\n",
    "\n",
    "capital_costs =  # in €\n",
    "electricity_generation =  # as an array of generation per year in kWh\n",
    "operational_costs =  # as an array of total operational costs per year in €\n",
    "\n",
    "print(capital_costs)\n",
    "print(electricity_generation)\n",
    "print(operational_costs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell to check your answers. \n",
    "# Note the input parameters needed by the function (remember that you can use `Shift + Tab` \n",
    "# to see the documentation of the function). \n",
    "# If you named your parameters differently, provide the right names to the function\n",
    "checker_parameters(el_gen=electricity_generation, \n",
    "                   op_costs=operational_costs, \n",
    "                   capacity=capacity, \n",
    "                   load_factor=load_factor, \n",
    "                   fixed_om_cost=fixed_om_cost, \n",
    "                   fuel_price=fuel_price, \n",
    "                   efficiency=efficiency, \n",
    "                   lifetime=lifetime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. Now use the earlier LCOE equation we developed to calculate the LCOE\n",
    "actual = get_lcoe(capital_costs=capital_costs, \n",
    "                  operational_costs=operational_costs, \n",
    "                  electricity_generation=electricity_generation, \n",
    "                  discount_rate=discount_rate, \n",
    "                  technical_lifetime=lifetime)\n",
    "print(actual)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Now we extend our calculation of LCOE with the parameters used above. We implement the same calculation you did, but inside the `get_lcoe_input` function. Then we use this function inside a new function called `extended_lcoe` to calculate the input parameters and the `lcoe` value using our previous definded `get_lcoe` [function](#Writing-a-reusable-LCOE-function). You do not need to change anything here, just check them below and make sure to run both cells as we will need them in the next steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_lcoe_input(station_size, overnight_cost, fuel_efficiency, technical_lifetime,\n",
    "                   fuel_price, fixed_om_cost, load_factor, variable_om_cost):\n",
    "    \"\"\"Calculates the input parameters for the lcoe function\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    station_size : float\n",
    "        The capacity of the technology in kW\n",
    "    overnight_cost : float\n",
    "        The capital cost of the technology in €/kW\n",
    "    fuel_efficiency : float\n",
    "        The ratio describing quantity of fuel required per unit of activity\n",
    "    fuel_price : float\n",
    "        The price paid per unit of input fuel in €/kWh\n",
    "    fixed_om_cost : float\n",
    "        The fixed operation and maintenance cost of the technology in €/kW\n",
    "    load_factor : float\n",
    "        The percentage of the year in which the technology generates electricity in %.\n",
    "    variable_om_cost : float\n",
    "        The variable operation and maintenance cost of the technology in €/kW\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    dict\n",
    "        A dictionary containing:\n",
    "            capital_cost : float \n",
    "                The capital cost of the technology €\n",
    "            total_fixed_om_cost : float\n",
    "                Fixed costs €\n",
    "            annual_electricity_generation : np.ndarray\n",
    "                annual electricity production kWh\n",
    "            total_variable_om_cost : float\n",
    "                variable cost due to fuel use €\n",
    "            annual_operational_cost : np.ndarray\n",
    "                annual operational cost €\n",
    "            \n",
    "    \"\"\"\n",
    "    HOURS_IN_YEAR = 8760\n",
    "    \n",
    "    capital_cost = station_size * overnight_cost\n",
    "    total_fixed_om_cost = station_size * fixed_om_cost\n",
    "    annual_electricity_generation = np.repeat(station_size * HOURS_IN_YEAR * load_factor, technical_lifetime)\n",
    "\n",
    "    total_variable_om_cost = ((annual_electricity_generation / fuel_efficiency) * fuel_price) + \\\n",
    "                             (annual_electricity_generation * variable_om_cost)\n",
    "    annual_operational_cost = total_fixed_om_cost + total_variable_om_cost\n",
    "    \n",
    "    return {'capital_cost': capital_cost, 'total_fixed_om_cost': total_fixed_om_cost,\n",
    "            'annual_electricity_generation': annual_electricity_generation, \n",
    "            'total_variable_om_cost': total_variable_om_cost, 'annual_operational_cost': annual_operational_cost}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extended_lcoe(station_size, overnight_cost, fuel_efficiency, fuel_price, fixed_om_cost, var_om_cost, \n",
    "                  load_factor, discount_rate, technical_lifetime):\n",
    "    \"\"\"Calculates levelised cost of electricity as a function of useful parameters\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    station_size : float\n",
    "        The capacity of the technology in kW\n",
    "    overnight_cost : float\n",
    "        The capital cost of the technology in €\n",
    "    fuel_efficiency : float\n",
    "        The ratio describing quantity of fuel required per unit of activity\n",
    "    fuel_price : float\n",
    "        The price paid per unit of input fuel in €/kWh\n",
    "    fixed_om_cost : float\n",
    "        The fixed operation and maintenance cost of the technology in €/kW\n",
    "    load_factor : float\n",
    "        The percentage of the year in which the technology generates electricity in %.\n",
    "    discount_rate : float\n",
    "        A decimal value less than 1\n",
    "    technical_lifetime : int\n",
    "        Technical lifetime of the technology in years\n",
    "    var_om_cost : float\n",
    "        Variable operational and maintenance cost\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        The levelised cost of electricity in €/kWh\n",
    "    \"\"\"\n",
    "    lcoe_params = get_lcoe_input(station_size, overnight_cost, fuel_efficiency, technical_lifetime,\n",
    "                                 fuel_price, fixed_om_cost, load_factor, var_om_cost)\n",
    "\n",
    "    value = get_lcoe(lcoe_params['capital_cost'], lcoe_params['annual_operational_cost'], \n",
    "                     lcoe_params['annual_electricity_generation'], discount_rate, \n",
    "                     technical_lifetime)\n",
    "    return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So to perform the calculation again using our new LCOE function, we get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ccgt_lcoe = extended_lcoe(station_size=750000, \n",
    "                          overnight_cost=750, \n",
    "                          fuel_efficiency=0.5, \n",
    "                          fuel_price=0.03, \n",
    "                          fixed_om_cost=3,\n",
    "                          var_om_cost=0, \n",
    "                          load_factor=0.75, \n",
    "                          discount_rate=0.08, \n",
    "                          technical_lifetime=25)\n",
    "ccgt_lcoe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q. What are the key parameters that determine the LCOE of the CCGT plant?\n",
    "\n",
    "Run the next cell to create an interactive slider widget which allows you to play with the `extended_lcoe` function and answer the following questions:\n",
    "\n",
    "1. Which is the most influential input parameter?\n",
    "2. Are all the responses linear? Is it easy to tell?\n",
    "3. What happens if gas is expensive?\n",
    "4. If the price of the gas turbine doubles from €750/kW to €1500/kW, what's the effect upon LCOE at different load factors?\n",
    "5. How important is discount rate compared to the fuel price?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "interact(extended_lcoe, \n",
    "         station_size=(100000,750000, 10000), \n",
    "         overnight_cost=(300, 2000), \n",
    "         fuel_efficiency=(0.3, 0.7, 0.01), \n",
    "         fuel_price=(0.00  , 0.20, 0.01), \n",
    "         fixed_om_cost=(1, 50, 0.001), \n",
    "         load_factor=(0.01, 1.0, 0.01), \n",
    "         discount_rate=(0.01, 0.30, 0.01), \n",
    "         technical_lifetime=(10, 60, 1), \n",
    "         var_om_cost=(0.0, 0.011, 0.001))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stage 2 - Summary\n",
    "\n",
    "- In this stage, we calculated the levelised cost for a CCGT plant.\n",
    "- Then, we explored the LCOE equation interactively to try to understand what parameters influence the LCOE of a technology.\n",
    "\n",
    "In the next stage, we compare LCOE across technologies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"Stage-3:-Comparing-technologies\"></a>\n",
    "# Stage 3: Comparing technologies\n",
    "\n",
    "In the previous stages, we developed our understanding of the LCOE equation, and applied it to one technology. Now comes the *really* fun part, where we develop a comparison across different technologies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now make a more advanced function that holds the logic to calculate LCOE when we have a number of extra input parameters. Now, we can pass a *list* (elements separated by commas inside square brackets) of parameter values, and the function returns a list of results.\n",
    "\n",
    "You don't need to change anything in the following function, just check it and run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_technology(station_size, overnight_cost, fixed_om_cost, load_factors, efficiency, \n",
    "                         fuel_price, discount_rates, technical_lifetime, technology, var_om_cost):\n",
    "    \"\"\"Calculate LCOE for cartesian product of all parameter lists\n",
    "    \"\"\"\n",
    "    results = []  # Create a list to hold the observations\n",
    "    \n",
    "    # Loop over cartesian product of parameter values\n",
    "    for (load_factor, discount_rate) in itertools.product(load_factors, discount_rates):\n",
    "\n",
    "        observation = {}  # Create a dictionary to store the observation\n",
    "        \n",
    "        params = get_lcoe_input(station_size, overnight_cost, efficiency, technical_lifetime,\n",
    "                                fuel_price, fixed_om_cost, load_factor, var_om_cost)\n",
    "\n",
    "        lcoe = extended_lcoe(station_size, overnight_cost, efficiency, fuel_price, fixed_om_cost, var_om_cost,\n",
    "                             load_factor, discount_rate, technical_lifetime)\n",
    "    \n",
    "        observation['Technology'] = technology\n",
    "        observation['StationSize'] = station_size\n",
    "        observation['OvernightCost'] = overnight_cost\n",
    "        observation['FixedOMCost'] = fixed_om_cost\n",
    "        observation['LoadFactor'] = load_factor\n",
    "        observation['Efficiency'] = efficiency\n",
    "        observation['FuelPrice'] = fuel_price\n",
    "        observation['DiscountRate'] = discount_rate\n",
    "        observation['Lifetime'] = technical_lifetime\n",
    "        observation['LCOE'] = lcoe\n",
    "        \n",
    "        year = np.arange(technical_lifetime)\n",
    "        df = (1 + discount_rate) ** - year\n",
    "        \n",
    "        observation['Fixed OM Cost'] = sum(df * params['total_fixed_om_cost']) / \\\n",
    "                                       sum(df * params['annual_electricity_generation'])\n",
    "        observation['Variable OM Cost'] = sum(df * params['total_variable_om_cost']) / \\\n",
    "                                          sum(df * params['annual_electricity_generation'])\n",
    "        observation['Capital Cost'] = params['capital_cost'] / \\\n",
    "                                      sum(df * params['annual_electricity_generation'])\n",
    "\n",
    "        results.append(observation)\n",
    "        \n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll use our new function to compare multiple technologies under their central operating characteristics, and explore how that changes under different discount rates. Run the folowing cell to pass all of the input values for each technology to the function. Give it a minute and you will se a plot below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we create an array of load factors from 0.1 to 1.0 in steps of 0.01\n",
    "load_factors = np.arange(0.1, 1.0, 0.01)\n",
    "# We set the discount rate to two values for the moment\n",
    "discount_rate = [0.05, 0.1] # %\n",
    "\n",
    "# CCGT plant parameters\n",
    "technical_lifetime = 25 # years\n",
    "station_size = 750000  # kW\n",
    "fuel_price = 0.03 # €/kWh\n",
    "overnight_cost = 750  # €/kW\n",
    "fixed_om_cost = 3.0 # €/kW\n",
    "var_om_cost = 0.01\n",
    "fuel_efficiency = 0.5\n",
    "\n",
    "ccgt_results = calculate_technology(\n",
    "    station_size, overnight_cost, fixed_om_cost, load_factors, fuel_efficiency, \n",
    "    fuel_price, discount_rate, technical_lifetime, 'CCGT', var_om_cost)\n",
    "\n",
    "# Coal plants\n",
    "technical_lifetime = 35 # years\n",
    "station_size = 1000000 # kW\n",
    "fuel_price = 0.01 # €/kWh\n",
    "overnight_cost = 2000  # €/kW\n",
    "fixed_om_cost = 5.0 # €/kW\n",
    "var_om_cost = 0.01\n",
    "fuel_efficiency = 0.4\n",
    "\n",
    "coal_results = calculate_technology(\n",
    "    station_size, overnight_cost, fixed_om_cost, load_factors, fuel_efficiency, \n",
    "    fuel_price, discount_rate, technical_lifetime, 'Coal', var_om_cost)\n",
    "\n",
    "# Nuclear plants\n",
    "technical_lifetime = 50 # years\n",
    "station_size = 1200000 # kW\n",
    "fuel_price = 0.005 # €/kWh\n",
    "overnight_cost = 4500  # €/kW\n",
    "fixed_om_cost = 2.0 # €/kW\n",
    "var_om_cost = 0.01\n",
    "fuel_efficiency = 0.4\n",
    "\n",
    "nuclear_results = calculate_technology(\n",
    "    station_size, overnight_cost, fixed_om_cost, load_factors, fuel_efficiency, \n",
    "    fuel_price, discount_rate, technical_lifetime, 'Nuclear', var_om_cost)\n",
    "\n",
    "# Concentrating solar power\n",
    "technical_lifetime = 25 # years\n",
    "station_size = 500000 # kW\n",
    "fuel_price = 0.0 # €/kWh\n",
    "overnight_cost = 3785  # €/kW\n",
    "fixed_om_cost = 5.0 # €/kW\n",
    "var_om_cost = 0.01\n",
    "fuel_efficiency = 1.0\n",
    "\n",
    "csp_results = calculate_technology(\n",
    "    station_size, overnight_cost, fixed_om_cost, load_factors, fuel_efficiency, \n",
    "    fuel_price, discount_rate, technical_lifetime, 'CSP', var_om_cost)\n",
    "\n",
    "# Wind turbines\n",
    "technical_lifetime = 25 # years\n",
    "station_size = 200000 # kW\n",
    "fuel_price = 0.0 # €/kWh\n",
    "overnight_cost = 1200  # €/kW\n",
    "fixed_om_cost = 2.0 # €/kW\n",
    "var_om_cost = 0.0001\n",
    "fuel_efficiency = 1.0\n",
    "\n",
    "wind_results = calculate_technology(\n",
    "    station_size, overnight_cost, fixed_om_cost, load_factors, fuel_efficiency, \n",
    "    fuel_price, discount_rate, technical_lifetime, 'Wind', var_om_cost)\n",
    "\n",
    "\n",
    "plotting = pd.DataFrame(ccgt_results + coal_results + nuclear_results + csp_results + wind_results)\n",
    "px.line(plotting, x='LoadFactor', y='LCOE', color='Technology', facet_col='DiscountRate', facet_col_wrap=2,\n",
    "        labels={'LoadFactor': 'LoadFactor (%)', 'LCOE': 'LCOE (€/kW)'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What do you see when you compare technologies at different load factors?\n",
    "- What does the LCOE graph *not* show you?\n",
    "\n",
    "Run the following cell to check another repreentation of the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = plotting.melt(id_vars=['Technology', 'LoadFactor', 'DiscountRate'], \n",
    "                   value_vars=['Fixed OM Cost', 'Variable OM Cost', 'Capital Cost'])\n",
    "\n",
    "px.area(df, x='LoadFactor', y='value', color='variable', facet_col='Technology', facet_row='DiscountRate',\n",
    "        labels={'LoadFactor': 'LoadFactor (%)', 'value': 'LCOE (€/kW)'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What can you say about the different costs per technology?\n",
    "* Does the wind technology really have the lowest levelised cost of electricity?\n",
    "* What happens if the cost of natural gas doubles? What happens if coal doubles in price?\n",
    "* What happens if concrete gets cheaper?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is it for today's lab, we hope you enjoyed it and that you got a good idea of what the LCOE is and how to use it."
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "af8ebb4e2d22b06da4313823d442847307ae4d45e401ef0669a9fed88d20d2aa"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}