{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SPDX-FileCopyrightText: 2019 oemof developer group <contact@oemof.org>\n",
    "\n",
    "SPDX-License-Identifier: MIT\n",
    "\n",
    "SPDX-License-Identifier: CC-BY-4.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ModelChain example\n",
    "\n",
    "This example shows you the basic usage of the windpowerlib by using the ``ModelChain`` class.\n",
    "There are mainly three steps. First you have to import your weather data, then you need to specify your wind turbine, and in the last step call the windpowerlib functions to calculate the feed-in time series.\n",
    "\n",
    "Before you start you have to import the packages needed for these steps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import necessary packages and modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import requests\n",
    "\n",
    "from windpowerlib import ModelChain, WindTurbine, create_power_curve\n",
    "from windpowerlib import data as wt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the logging package to get logging messages from the windpowerlib. Change the logging level if you want more or less messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logging.getLogger().setLevel(logging.DEBUG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import weather data\n",
    "\n",
    "In order to use the windpowerlib you need to at least provide wind speed data for the time frame you want to analyze.\n",
    "The function below imports example weather data from the weather.csv file provided along with the windpowerlib. The data includes wind speed at two different heights in m/s, air temperature in two different heights in K, surface roughness length in m and air pressure in Pa.\n",
    "\n",
    "To find out which weather data in which units need to be provided to use the ModelChain or other functions of the windpowerlib see the individual function documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "variable_name             wind_speed          temperature         pressure\n",
      "height                            10       80           2      10        0\n",
      "2010-01-01 00:00:00+01:00    5.32697  7.80697      267.60  267.57  98405.7\n",
      "2010-01-01 01:00:00+01:00    5.46199  7.86199      267.60  267.55  98382.7\n",
      "2010-01-01 02:00:00+01:00    5.67899  8.59899      267.61  267.54  98362.9\n"
     ]
    }
   ],
   "source": [
    "def get_weather_data(filename='weather.csv', **kwargs):\n",
    "    r\"\"\"\n",
    "    Imports weather data from a file.\n",
    "\n",
    "    The data include wind speed at two different heights in m/s, air\n",
    "    temperature in two different heights in K, surface roughness length in m\n",
    "    and air pressure in Pa. The height in m for which the data applies is\n",
    "    specified in the second row.\n",
    "    In case no weather data file exists, an example weather data file is \n",
    "    automatically downloaded and stored in the same directory as this example.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    filename : str\n",
    "        Filename of the weather data file. Default: 'weather.csv'.\n",
    "\n",
    "    Other Parameters\n",
    "    ----------------\n",
    "    datapath : str, optional\n",
    "        Path where the weather data file is stored.\n",
    "        Default is the same directory this example is stored in.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    :pandas:`pandas.DataFrame<frame>`\n",
    "        DataFrame with time series for wind speed `wind_speed` in m/s,\n",
    "        temperature `temperature` in K, roughness length `roughness_length`\n",
    "        in m, and pressure `pressure` in Pa.\n",
    "        The columns of the DataFrame are a MultiIndex where the first level\n",
    "        contains the variable name as string (e.g. 'wind_speed') and the\n",
    "        second level contains the height as integer at which it applies\n",
    "        (e.g. 10, if it was measured at a height of 10 m). The index is a \n",
    "        DateTimeIndex.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    if 'datapath' not in kwargs:\n",
    "        kwargs['datapath'] = os.path.dirname(__file__)\n",
    "    \n",
    "    file = os.path.join(kwargs['datapath'], filename)\n",
    "    \n",
    "    # download example weather data file in case it does not yet exist\n",
    "    if not os.path.isfile(file):\n",
    "        logging.debug(\"Download weather data for example.\")\n",
    "        req = requests.get(\"https://osf.io/59bqn/download\")\n",
    "        with open(file, \"wb\") as fout:\n",
    "            fout.write(req.content)\n",
    "            \n",
    "    # read csv file \n",
    "    weather_df = pd.read_csv(\n",
    "        file,\n",
    "        index_col=0,\n",
    "        header=[0, 1],\n",
    "    )\n",
    "    weather_df.index = pd.to_datetime(weather_df.index, utc=True)\n",
    "    \n",
    "    # change time zone\n",
    "    weather_df.index = weather_df.index.tz_convert(\n",
    "        'Europe/Berlin')\n",
    "    \n",
    "    return weather_df\n",
    "\n",
    "\n",
    "# Read weather data from csv\n",
    "weather = get_weather_data(filename='weather.csv', datapath='')\n",
    "print(weather[['wind_speed', 'temperature', 'pressure']][0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize wind turbine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three ways to initialize a WindTurbine object in the windpowerlib. You can either use turbine data from the OpenEnergy Database (oedb) turbine library that is provided along with the windpowerlib, as done for the 'enercon_e126', or specify your own turbine by directly providing a power (coefficient) curve, as done below for 'my_turbine', or provide your own turbine data in csv files, as done for 'my_turbine2'.\n",
    "\n",
    "You can execute the following to get a table of all wind turbines for which power and/or power coefficient curves are provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   manufacturer turbine_type  has_power_curve  has_cp_curve\n",
      "1       Enercon   E-101/3050             True          True\n",
      "2       Enercon   E-101/3500             True          True\n",
      "3       Enercon   E-115/3000             True          True\n",
      "4       Enercon   E-115/3200             True          True\n",
      "5       Enercon   E-126/4200             True          True\n",
      "6       Enercon   E-126/7500             True         False\n",
      "7       Enercon   E-126/7580             True         False\n",
      "8       Enercon   E-141/4200             True          True\n",
      "9       Enercon     E-53/800             True          True\n",
      "10      Enercon    E-70/2000             True         False\n",
      "11      Enercon    E-70/2300             True          True\n",
      "12      Enercon    E-82/2000             True          True\n",
      "13      Enercon    E-82/2300             True          True\n",
      "14      Enercon    E-82/2350             True          True\n",
      "15      Enercon    E-82/3000             True          True\n",
      "16      Enercon    E-92/2350             True          True\n",
      "17      Enercon      E48/800             True          True\n"
     ]
    }
   ],
   "source": [
    "# get power curves\n",
    "# get names of wind turbines for which power curves and/or are provided\n",
    "# set print_out=True to see the list of all available wind turbines\n",
    "df = wt.get_turbine_types(print_out=False)\n",
    "\n",
    "# find all Enercons\n",
    "print(df[df[\"manufacturer\"].str.contains(\"Enercon\")])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  manufacturer turbine_type  has_power_curve  has_cp_curve\n",
      "1      Enercon   E-101/3050             True          True\n",
      "2      Enercon   E-101/3500             True          True\n"
     ]
    }
   ],
   "source": [
    "# find all Enercon 101 turbines\n",
    "print(df[df[\"turbine_type\"].str.contains(\"E-101\")])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specification of wind turbine where power curve is provided in the \n",
    "# oedb turbine library\n",
    "\n",
    "enercon_e126 = {\n",
    "        'turbine_type': 'E-126/4200',  # turbine type as in oedb turbine library\n",
    "        'hub_height': 135  # in m\n",
    "    }\n",
    "# initialize WindTurbine object\n",
    "e126 = WindTurbine(**enercon_e126)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specification of own wind turbine (Note: power curve values and\n",
    "# nominal power have to be in Watt)\n",
    "my_turbine = {\n",
    "    'nominal_power': 3e6,  # in W\n",
    "    'hub_height': 105,  # in m\n",
    "    'power_curve': pd.DataFrame(\n",
    "            data={'value': [p * 1000 for p in [\n",
    "                      0.0, 26.0, 180.0, 1500.0, 3000.0, 3000.0]],  # in W\n",
    "                  'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]})  # in m/s\n",
    "    }  \n",
    "# initialize WindTurbine object\n",
    "my_turbine = WindTurbine(**my_turbine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specification of wind turbine where power coefficient curve and nominal\n",
    "# power is provided in an own csv file\n",
    "\n",
    "# Read your turbine data from your data file using functions like\n",
    "# pandas.read_csv().\n",
    "# >>> import pandas as pd\n",
    "# >>> my_data = pd.read_csv(\"path/to/my/data/file\")\n",
    "# >>> my_power = my_data[\"my_power\"]\n",
    "# >>> my_wind_speed = my_data[\"my_wind_speed\"]\n",
    "    \n",
    "my_power = pd.Series(\n",
    "    [0.0, 39000.0, 270000.0, 2250000.0, 4500000.0, 4500000.0]\n",
    ")\n",
    "my_wind_speed = (0.0, 3.0, 5.0, 10.0, 15.0, 25.0)\n",
    "\n",
    "my_turbine2 = {\n",
    "    \"nominal_power\": 6e6,  # in W\n",
    "    \"hub_height\": 115,  # in m\n",
    "    \"power_curve\": create_power_curve(\n",
    "        wind_speed=my_wind_speed, power=my_power\n",
    "    ),\n",
    "}\n",
    "my_turbine2 = WindTurbine(**my_turbine2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use the ModelChain to calculate turbine power output\n",
    "\n",
    "The ModelChain is a class that provides all necessary steps to calculate the power output of a wind turbine. When calling the 'run_model' method, first the wind speed and density (if necessary) at hub height are calculated and then used to calculate the power output. You can either use the default methods for the calculation steps, as done for 'my_turbine', or choose different methods, as done for the 'e126'. Of course, you can also use the default methods while only changing one or two of them, as done for 'my_turbine2'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:root:Calculating wind speed using logarithmic wind profile.\n",
      "DEBUG:root:Calculating temperature using temperature gradient.\n",
      "DEBUG:root:Calculating density using ideal gas equation.\n",
      "DEBUG:root:Calculating power output using power coefficient curve.\n"
     ]
    }
   ],
   "source": [
    "# power output calculation for e126\n",
    "\n",
    "# own specifications for ModelChain setup\n",
    "modelchain_data = {\n",
    "    'wind_speed_model': 'logarithmic',      # 'logarithmic' (default),\n",
    "                                            # 'hellman' or\n",
    "                                            # 'interpolation_extrapolation'\n",
    "    'density_model': 'ideal_gas',           # 'barometric' (default), 'ideal_gas'\n",
    "                                            #  or 'interpolation_extrapolation'\n",
    "    'temperature_model': 'linear_gradient', # 'linear_gradient' (def.) or\n",
    "                                            # 'interpolation_extrapolation'\n",
    "    'power_output_model':\n",
    "        'power_coefficient_curve',          # 'power_curve' (default) or\n",
    "                                            # 'power_coefficient_curve'\n",
    "    'density_correction': True,             # False (default) or True\n",
    "    'obstacle_height': 0,                   # default: 0\n",
    "    'hellman_exp': None}                    # None (default) or None\n",
    "\n",
    "# initialize ModelChain with own specifications and use run_model method to\n",
    "# calculate power output\n",
    "mc_e126 = ModelChain(e126, **modelchain_data).run_model(\n",
    "    weather)\n",
    "# write power output time series to WindTurbine object\n",
    "e126.power_output = mc_e126.power_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:root:Calculating wind speed using logarithmic wind profile.\n",
      "DEBUG:root:Calculating power output using power curve.\n"
     ]
    }
   ],
   "source": [
    "# power output calculation for my_turbine\n",
    "\n",
    "# initialize ModelChain with default parameters and use run_model\n",
    "# method to calculate power output\n",
    "mc_my_turbine = ModelChain(my_turbine).run_model(weather)\n",
    "# write power output time series to WindTurbine object\n",
    "my_turbine.power_output = mc_my_turbine.power_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:root:Calculating wind speed using hellman equation.\n",
      "DEBUG:root:Calculating power output using power curve.\n"
     ]
    }
   ],
   "source": [
    "# power output calculation for example_turbine\n",
    "# own specification for 'power_output_model'\n",
    "mc_example_turbine = ModelChain(\n",
    "    my_turbine2,\n",
    "    wind_speed_model='hellman').run_model(weather)\n",
    "my_turbine2.power_output = mc_example_turbine.power_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot results\n",
    "\n",
    "If you have matplotlib installed you can visualize the calculated power output and used power (coefficient) curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try to import matplotlib\n",
    "logging.getLogger().setLevel(logging.WARNING)\n",
    "try:\n",
    "    from matplotlib import pyplot as plt\n",
    "    # matplotlib inline needed in notebook to plot inline\n",
    "    %matplotlib inline \n",
    "except ImportError:\n",
    "    plt = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot turbine power output\n",
    "if plt:\n",
    "    e126.power_output.plot(legend=True, label='Enercon E126')\n",
    "    my_turbine.power_output.plot(legend=True, label='myTurbine')\n",
    "    my_turbine2.power_output.plot(legend=True, label='myTurbine2')\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Power in W')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAfu0lEQVR4nO3de5xVdb3/8dcbZmRKQE0guQmkhoZ4naOmlpp51FKpRwqaWlYnumhGeUorT1k/+v3q9NOKtNSSxLtGpZR6TA0VE5GB8AJEknkZQBkguaggI5/zx1oD23HNzN7DrNmzZ97Px2M/WPf12Ys1+7O+37XW96uIwMzMrLle5Q7AzMy6JicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0xOENZtSHpW0gdbmPc+SUs6OyazSuYEYWUjaXdJGwo+IemVgvH3ddS+ImJWRIzuqO2Z9QRV5Q7Aeq6IeB7o2zQuKYD9I2JpKduRVBURjR0dXyXK81j4OPc8LkFYu6TVOV+T9ER61X+NpHdKulvSekn3SdolXfZOSV9qtv4Tkj7ayvavlTS5YPxoSfXN9n+hpCeAVyQ1Xez8m6RFkv4l6deSalpZ/z/TONZKurVp2XT+SZIWSHpZ0iOS9msl1pB0vqRnJK2S9CNJvdJ5vSRdLOk5SSslXSdpp3TeNEkXpMND0+2cm47vIWlNwXZajKeVY1EY4xhJ96bbfEnSN9t5nC+UNL3Ztn8qaUo6vFN6LqyQtEzSZEm9Wzp21rU5Qdj2+BhwHPBu4GTgbuCbwECSc+v8dLlpwFlNK0naHxgK3Lmd+z8D+DCwc8GV7ZnA8cAeaVwXt7L+eOAEYBSwH3BOGt+BwFTgc8CuwFXADEl9WtnWR4Fa4CBgHPDpdPo56ecY4F0kJabL03kPAkenw0cBzwDvLxifFRFbiown61iQfp9+wH3A/wBDgD2B+1v5Ls1t3TZwC/ChdJukP/7jgZvSZa8FGtN9HAj8O/AfJezLupCKTBCSpqZXY08Vufz49KpyoaSb2l7DivSziHgpIpYBs4A5EfHXiNgI/J7kBwJgBvBuSXul42cDt0bE69u5/ykR8UJEvFYw7fJ02hrg+yQ/bq2tvzxd9g/AAen0icBVETEnIt6IiGnAJuCwVrb1w4hYk1ab/aRgv2cCl0XEMxGxAfgGcHp6lf8gcGRaSng/8N/AEel6R6Xzi40n61g0OQl4MSIujYiNEbE+Iua08l2a27rtiHgOmE+SEAE+ALwaEY9KeifwIWBSRLwSESuBHwOnl7Av60IqMkGQXKWcUMyC6Y/SN4AjImIMMCnHuHqalwqGX8sY7wuQJoxbgbPSH8MzgOs7YP8vtDHtOZIr5pa8WDD8Ktvuh4wALkirc16W9DIwvI1ttbTfIel44bwq4J0R8Q/gFZLE9D7gj8BySaN5c4IoJp6sY9FkOPCPVua3pfm2b2JbAvw420oPI4BqYEVBnFcBg7Zj31ZGFZkgIuIhYE3htLTO9n8kzZM0S9Le6azPAldExL/SdVd2criWmEZyNX0syRXn7DaWfwV4e8H4bhnLZDVFPLxgeHdgeSlBpl4Avh8ROxd83h4RN7eyTkv7XU7yw1k4r5FtyfRB4FRgh7Qk9iDwSWAXYEEJ8bTWLPMLJNVbWdpznH8DHC1pGElJoilBvEBSshlQEGf/9MLMKlBFJogWXA18KSIOBv4T+Hk6/d0k1Rt/kfSopKJKHtax0oSwBbiU4koPC0jqut8haTeKL/mdK2mYpHcA3yIpuZTql8DnJR2qxI6SPtxU796Cr0naRdJw4MsF+70Z+IqkUZL6Av+XpHqt6T7Bg8B5wEPp+APp+MMR8cZ2xFPoj8BgSZMk9ZHUT9Kh6bySj3NENKRx/hr4Z0QsTqevAP4EXCqpf3qDfg9JRxUZp3Ux3SJBpH94hwO/kbSApFg7OJ1dBexFcjPwDOCXknYuR5zGdcBY4IYilr0eeBx4luRHp9gf+pvS5Z8hqVaZ3PribxURdSQlz8uBfwFLSW9gt+IOYB7JD+6dwDXp9Kkk3+Uh4J/ARqDwia4HgX5sSxAPk1zRN423N57C77Oe5GGCk0mq1Z4muWkO23ecP8i20kOTTwA7AIvSWKez7W/RKowqtcMgSSOBP0bEvpL6A0si4i0noqQrSW6e/jodvx+4KCLmdma8BpI+AUyMiCPLHUtHUvL+xl6lvr9h1tV1ixJERKwD/inpNIC0GL5/Ovt20kcJJQ0gqXJ6phxx9mSS3g58kaQq0MwqQEUmCEk3A7OB0ZLqJX2G5AboZyQ9DiwkeRYd4B5gtaRFwEzgaxGxuhxx91SSjgcaSG7M+jFjswpRsVVMZmaWr4osQZiZWf4qrrG+AQMGxMiRI8sdhplZRZk3b96qiBhYyjoVlyBGjhxJXV1ducMwM6sokp5re6k3cxWTmZllcoIwM7NMThBmZpap4u5BZNm8eTP19fVs3Lix3KF0upqaGoYNG0Z1dXW5QzGzbqZbJIj6+nr69evHyJEjkVTucDpNRLB69Wrq6+sZNWpUucMxs24mtyomSTWSHpP0eNpRz3czlumjpKvHpZLmpO0rlWzjxo3suuuuPSo5AEhi11137ZElJ8u2ct1Gxl81m5XrfU7YNivXbaRq1+GjS10vz3sQm4APRMT+JB2inCCpeY9cnwH+FRF7kvQ89cP27qynJYcmPfV7W7Yp9z/N3GfXMOW+p8sdinUhU+5/ml5Vffq2veSb5VbFFEkbHhvS0er007xdj3HAJenwdOBySQq3/2FWktEX382mxi1bx2+Y8zw3zHmePlW9WDL5xDJGZuX0pvOiHdeSuT7FJKl32j/DSuDejH5wh5J2Z5h2oLKWpFP25tuZKKlOUl1DQ0OeIXeKvn1LTuRmrZr19WM45YAh1FQnf9I11b0Yd8AQZl14TBtrWnfW/LwoVa4JIu1g/QBgGHCIpH3buZ2rI6I2ImoHDizpTfEWua7WupNB/Wvo16eKTY1b6FPVi02NW+jXp4pB/WrKHZqVUeF5QTtqZjrlPYiIeJmkqe3m3X0uI+3LV1IVsBPQKU1xd2Rd7UUXXcQVV1yxdfySSy5h8uTJHHvssRx00EGMHTuWO+644y3rPfDAA5x00klbx8877zyuvfZaAObNm8dRRx3FwQcfzPHHH8+KFSu2O07r3lZt2MSZh47g9188gjMPHUHDhk3lDsm6gKbzYvOaZYtLXTe3exCSBgKbI+JlSW8j6fKw+U3oGSQdtM8m6bj9z3nff8ijrnbChAlMmjSJc889F4DbbruNe+65h/PPP5/+/fuzatUqDjvsME455ZSibipv3ryZL33pS9xxxx0MHDiQW2+9lW9961tMnTq1XfFZz3DV2bVbhyd/pF2FdeuGms6L72/e+Fqp6+b5HsRgYJqk3iQlldsi4o+SvgfURcQMkn57r5e0FFgDnJ5jPEBSJzf5rsX8aeGLbNy8hZrqXhw/Zje+9eF92r3NAw88kJUrV7J8+XIaGhrYZZdd2G233fjKV77CQw89RK9evVi2bBkvvfQSu+22W5vbW7JkCU899RTHHXccAG+88QaDB7tbXzPrXHk+xfQEcGDG9G8XDG8ETssrhix51dWedtppTJ8+nRdffJEJEyZw44030tDQwLx586iurmbkyJFveV+hqqqKLVu2lWaa5kcEY8aMYfbs2dsVk5nZ9uiRbTHlUVc7YcIEbrnlFqZPn85pp53G2rVrGTRoENXV1cycOZPnnntrS7sjRoxg0aJFbNq0iZdffpn7778fgNGjR9PQ0LA1QWzevJmFCxdud4xmZqXoFk1tlCqPutoxY8awfv16hg4dyuDBgznzzDM5+eSTGTt2LLW1tey9995vWWf48OGMHz+efffdl1GjRnHggUmBa4cddmD69Omcf/75rF27lsbGRiZNmsSYMWM6JFYzs2JUXJ/UtbW10bzDoMWLF7PPPu2/h1Dpevr3N7O2SZoXEbVtL7lNj6xiMjOztjlBmJlZpm6TICqtqqyj9NTvbWb56xYJoqamhtWrV/e4H8um/iBqatycgpl1vG7xFNOwYcOor6+nOzTkV6qmHuXMzDpat0gQ1dXV7lHNzKyDdYsqJjMz63hOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0xOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCxTbglC0nBJMyUtkrRQ0pczljla0lpJC9LPt/OKx8zMSpNnh0GNwAURMV9SP2CepHsjYlGz5WZFxEk5xmFmZu2QWwkiIlZExPx0eD2wGBia1/7MzKxjdco9CEkjgQOBORmz3yvpcUl3SxrTwvoTJdVJquuJ/U6bmZVD7glCUl/gt8CkiFjXbPZ8YERE7A/8DLg9axsRcXVE1EZE7cCBA/MN2MzMgJwThKRqkuRwY0T8rvn8iFgXERvS4buAakkD8ozJzMyKk+dTTAKuARZHxGUtLLNbuhySDknjWZ1XTGZmVrw8n2I6AjgbeFLSgnTaN4HdASLiSuBU4AuSGoHXgNMjInKMyczMipRbgoiIhwG1sczlwOV5xWBmZu3nN6nNzCyTE4SZmWVygjAzs0xOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0xOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0xOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZcksQkoZLmilpkaSFkr6csYwkTZG0VNITkg7KKx4zMytNVY7bbgQuiIj5kvoB8yTdGxGLCpY5Edgr/RwK/CL918zMyiy3EkRErIiI+enwemAxMLTZYuOA6yLxKLCzpMF5xWRmZsXrlHsQkkYCBwJzms0aCrxQMF7PW5MIkiZKqpNU19DQkFeYZmZWIPcEIakv8FtgUkSsa882IuLqiKiNiNqBAwd2bIBmZpYp1wQhqZokOdwYEb/LWGQZMLxgfFg6zczMyizPp5gEXAMsjojLWlhsBvCJ9Gmmw4C1EbEir5jMzKx4eT7FdARwNvCkpAXptG8CuwNExJXAXcCHgKXAq8CncozHzMxKkFuCiIiHAbWxTADn5hWDmZm1n9+kNjOzTE4QZmaWqcUqJkmrSd5b+AvwCDAnIl7trMDMzKy8WitBjAJ+AlQD3wBeSF9W+6mk8Z0SnZmZlU2LJYj0pbY/pR8k7UjylNEk4Dzgts4I0MzMyqO1KqYhwOHp59/SyfOAi4HZ+YdmZmbl1NpjrvXAfODHwEUR8XrnhGRmZl1BawniCOC9wEeBr0p6lqTkMBuoi4hN+YdnZmbl0to9iKZkcBlsbZH1ZGAaSZtJNfmHZ2Zm5dLqm9SS9mbbfYgjgJ2BR4Er8w/NzMzKqbWb1KuA5SSliIeAH0TE0s4KzMzMyqu1EsQeEbG20yIxM7MupcUX5ZwczMx6NrfFZGZmmZwgzMwsU5v9QUjqA3wMGFm4fER8L7+wzMys3IrpMOgOYC1JMxt+Oc7MrIcoJkEMi4gTco/EzMy6lGLuQTwiaWzukZiZWZdSTAniSOAcSf8kqWISSXfS++UamZmZlVUxCeLE3KMwM7Mup7WmNvqnnQat78R4zMysi2itBHETcBLJ00tBUrXUJIB35RiXmZmVWWvNfZ+U/juq88IxM7OuIrc3qSVNlbRS0lMtzD9a0lpJC9LPt/OKxbq3les2Mv6q2axcv7HcoZh1K3k2tXEt0Nb7E7Mi4oD04zezrV2m3P80c59dw5T7ni53KGbdSjFPMbVLRDyU9kJnlovRF9/NpsYtW8dvmPM8N8x5nj5VvVgy2Q/fmW2vVksQknpL+luO+3+vpMcl3S1pTCtxTJRUJ6muoaEhx3Csksz6+jGccsAQaqqT07imuhfjDhjCrAuPKXNkZt1DqwkiIt4AlkjaPYd9zwdGRMT+wM+A21uJ4+qIqI2I2oEDB+YQilWiQf1r6Nenik2NW+hT1YtNjVvo16eKQf3cXbpZRyimimkXYKGkx4BXmiZGxCnbs+P0HYum4bsk/VzSgIhYtT3btZ5l1YZNnHnoCD5+yO7c9NjzNPhGtVmHKSZB/FceO5a0G/BSRISkQ0hKM6vz2Jd1X1edXbt1ePJH9i1jJGbdT5sJIiIelDQC2Csi7pP0dqB3W+tJuhk4GhggqR74DlCdbvNK4FTgC5IagdeA0yMi2v1NzMysQxXTYdBngYnAO4A9gKHAlcCxra0XEWe0Mf9y4PKiIzUzs05VzHsQ5wJHAOsAIuJpYFCeQZmZWfkVkyA2RcTrTSOSqkjaYjIzs26smATxoKRvAm+TdBzwG+AP+YZlZmblVkyCuAhoAJ4EPgfcBVycZ1BmZlZ+xTzmegxwQ0T8Mu9gzMys6yimBPEJ4HFJj0r6kaSTJe2Sd2BmZlZexbwH8UkASUNI3l24AhhSzLpmZla5inkP4izgfcBYYBXJuwuzco7LzMzKrJhSwE+Af5C8HDczIp7NNSIzM+sS2rwHEREDgE8DNcD3JT0m6frcIzMzs7JqM0FI6g/sDowARgI7AVtaW8fMzCpfMVVMDxd8Lo+I+nxDMjOzrqCYp5j2A5DUN/9wzMysqyimimlfSX8FFgKLJM2T5Ib3zcy6uWJelLsa+GpEjIiI3YEL0mlmZtaNFZMgdoyImU0jEfEAsGNuEZmZWZdQzE3qZyT9F9D0aOtZwDP5hWRmZl1BMSWITwMDgd8BvwWa3oswM7NurMUShKQa4PPAniRNfV8QEZs7KzAzMyuv1koQ04BakuRwIvCjTonIzMy6hNbuQbwnIsYCSLoGeKxzQjIzs66gtRLE1uqkiGjshFjMzKwLaa0Esb+kdemwSPqkXpcOR0T0zz06MzMrmxYTRET07sxAzMysaynmMdd2kTRV0kpJT7UwX5KmSFoq6QlJB+UVi5mZlS63BAFcC5zQyvwTgb3Sz0TgFznGYmZmJcotQUTEQ8CaVhYZB1wXiUeBnSUNziseMzMrTZ4liLYMBV4oGK9Pp72FpImS6iTVNTQ0dEpwZmY9XTkTRNEi4uqIqI2I2oEDB5Y7HDOzHqGcCWIZMLxgfFg6zczMuoByJogZwCfSp5kOA9ZGxIoyxmNmZgWKae67XSTdDBwNDJBUD3wHqAaIiCuBu4APAUuBV4FP5RWLmZmVLrcEERFntDE/gHPz2r+ZmW2firhJbWZmnc8JwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0xOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0xOEGZmlskJwszMMjlBmJlZJicIMzPL5ARhZmaZnCDMzCyTE4SZmWVygjAzs0y5JghJJ0haImmppIsy5p8jqUHSgvTzH3nGY2ZmxavKa8OSegNXAMcB9cBcSTMiYlGzRW+NiPPyisPMzNonzxLEIcDSiHgmIl4HbgHG5bg/MzPrQHkmiKHACwXj9em05j4m6QlJ0yUNz9qQpImS6iTVNTQ05BGrmZk1U+6b1H8ARkbEfsC9wLSshSLi6oiojYjagQMHdmqAZmY9VZ4JYhlQWCIYlk7bKiJWR8SmdPRXwME5xmNmZiXIM0HMBfaSNErSDsDpwIzCBSQNLhg9BVicYzxmZlaC3J5iiohGSecB9wC9gakRsVDS94C6iJgBnC/pFKARWAOck1c8ZmZWGkVEuWMoSW1tbdTV1ZU7DDOziiJpXkTUlrJOuW9Sm5lZF+UEYWZmmZwgzMwskxOEmZllcoIwM7NMThBmZpbJCcLMzDI5QZiZWSYnCDMzy+QEYWZmmZwgzMwskxOEmZllcoKoUCvXbWT8VbNZuX5juUMxs27KCaJCTbn/aeY+u4Yp9z1d7lDMrJvKrT8Iy8foi+9mU+OWreM3zHmeG+Y8T5+qXiyZfGIZIzOz7sYliAoz6+vHcMoBQ6ipTv7raqp7Me6AIcy68JgyR2Zm3Y0TRIUZ1L+Gfn2q2NS4hT5VvdjUuIV+faoY1K+m3KGZWTfjKqYKtGrDJs48dAQfP2R3bnrseRp8o9rMcuAuR83MegB3OWpmZh3GCcLMzDI5QZiZWSYniA7kt5vNrDtxguhAfrvZzLqTXJ9iknQC8FOgN/CriPhBs/l9gOuAg4HVwISIeLa1bb5jxD7xt6f+2qWe+2/+dnMTv91sZl1Fl3qKSVJv4ArgROA9wBmS3tNssc8A/4qIPYEfAz9sa7uvvN7Y5a7Q/XazmXVHeVYxHQIsjYhnIuJ14BZgXLNlxgHT0uHpwLGS1NaGb5jzPCMvupPRF9/doQG3l99uNrPuKM8EMRR4oWC8Pp2WuUxENAJrgV2bb0jSREl1kuqga16hN73d/PsvHsGZh46gYcOmcodkZrZdKqKpjYi4GrgaoGbwXtEVr9CvOntb1d7kj+xbxkjMzDpGniWIZcDwgvFh6bTMZSRVATuR3Kxu0Z6D+voK3cysE+RZgpgL7CVpFEkiOB34eLNlZgCfBGYDpwJ/jjYeq6qp7u0rdDOzTpBbgoiIRknnAfeQPOY6NSIWSvoeUBcRM4BrgOslLQXWkCQRMzPrAnK9BxERdwF3NZv27YLhjcBpecZgZmbt4zepzcwskxOEmZllcoIwM7NMThBmZpap4roclbQeWFLuOLqIAcCqcgfRRfhYbONjsY2PxTajI6JfKStUxJvUzSwptUXC7kpSnY9FwsdiGx+LbXwstmlqqqgUrmIyM7NMThBmZpapEhPE1eUOoAvxsdjGx2IbH4ttfCy2KflYVNxNajMz6xyVWIIwM7NO4ARhZmaZKipBSDpB0hJJSyVdVO54yknSs5KelLSgPY+vVTJJUyWtlPRUwbR3SLpX0tPpv7uUM8bO0sKxuETSsvTcWCDpQ+WMsTNIGi5ppqRFkhZK+nI6vcedF60ci5LPi4q5ByGpN/B34DiS7kvnAmdExKKyBlYmkp4FaiOix70EJOn9wAbguojYN53238CaiPhBevGwS0RcWM44O0MLx+ISYENE/P9yxtaZJA0GBkfEfEn9gHnAR4Bz6GHnRSvHYjwlnheVVII4BFgaEc9ExOvALcC4MsdkZRARD5H0H1JoHDAtHZ5G8gfR7bVwLHqciFgREfPT4fXAYpI+73vcedHKsShZJSWIocALBeP1tPNLdxMB/EnSPEkTyx1MF/DOiFiRDr8IvLOcwXQB50l6Iq2C6vbVKoUkjQQOBObQw8+LZscCSjwvKilB2JsdGREHAScC56ZVDQak3dZWRt1pPn4B7AEcAKwALi1vOJ1HUl/gt8CkiFhXOK+nnRcZx6Lk86KSEsQyYHjB+LB0Wo8UEcvSf1cCvyepguvJXkrrXpvqYFeWOZ6yiYiXIuKNiNgC/JIecm5Iqib5QbwxIn6XTu6R50XWsWjPeVFJCWIusJekUZJ2IOm/ekaZYyoLSTumN5+QtCPw78BTra/V7c0APpkOfxK4o4yxlFXTD2Lqo/SAc0OSSPq4XxwRlxXM6nHnRUvHoj3nRcU8xQSQPpb1E6A3MDUivl/mkMpC0rtISg2QtMh7U086FpJuBo4macr5JeA7wO3AbcDuwHPA+Ijo9jdvWzgWR5NUIwTwLPC5gnr4bknSkcAs4ElgSzr5myR17z3qvGjlWJxBiedFRSUIMzPrPJVUxWRmZp3ICcLMzDI5QZiZWSYnCDMzy+QEYWZmmZwgrMuR9GNJkwrG75H0q4LxSyV9VdIppbbqK+laSad2ZLylknSOpMszppf8fUrYZ7Wk+Xls27ovJwjriv4CHA4gqRfJM/5jCuYfDjwSETMi4gdliC8XOX+fI0mOq1nRnCCsK3oEeG86PIbkjc/1knaR1AfYB5hfeCWelgymSHpE0jNNpQQlLk/7EbkPGJS1Q0nnp+3nPyHplnTaJZKulzQ77U/gswXLf03S3HT57xZMP0vSY2l7+1elzdQj6VOS/i7pMeCIFmJo8/s0W36kpL+ly/5d0o2SPijpL2m8hU0pnADcnb6Ff6ekxyU9JWlCMf8h1jNVlTsAs+YiYrmkRkm7k5QWZpO03PteYC3wZES8nrQo8CaDSa6U9yZpYmE6SZMCo4H3kLTkuQiYmrHbi4BREbFJ0s4F0/cDDgN2BP4q6U5gX2AvkrZsBMxIG0tsACYAR0TEZkk/B86UdC/wXeDgNP6ZwF+LOBRZ36e5PYHTgE+TNEfz8XSdU0jenm1q3vqYNIYTgeUR8WEASTsVEYf1UE4Q1lU9QpIcDgcuI0kQh5P8wLZUVXJ72hDZIklNzTq/H7g5It4Alkv6cwvrPgHcKOl2kmY7mtwREa8Br0maSZIUjiRp/6rpR74vScLYjyQJzE2T19tIGoc7FHggIhoAJN0KvLuIY5D1fZr7Z0Q8mW53IXB/RISkJ4GR6fShJJ3mvJpOv1TSD4E/RsSsIuKwHspVTNZVNd2HGEtSxfQoSQnicJLkkWVTwfBbihdt+DBwBXAQyQ9808VT87ZoIt32/4uIA9LPnhFxTTp9WsH00RFxSYlxFCrm+xQus6VgfAvbLgBPAO4BiIi/k3zHJ4HJkr69HfFZN+cEYV3VI8BJJFe+b6QNrO1MkiRaShBZHgImSOqdtmZ5TPMF0hvhwyNiJnAhsBNJqQBgnKQaSbuSNII3l+TH9tNK2ttH0lBJg4D7gVPT4ab+kEeQNBh3lKRdlTTDfFpJR2L7nQDcncY0BHg1Im4AfkSSLMwyuYrJuqonSZ5euqnZtL4l9sP9e+ADJPcenie5n9Fcb+CGtD5ewJSIeDmtJnqC5J7BAOD/RMRykqqqfYDZ6TIbgLMiYpGki0l6+usFbAbOjYhHlfQTPRt4GVhQQvzbJb1JvmdE/C2dNBb4kaQtaXxf6KxYrPK4NVezFqQ/6iV18t7VpE0/nxURny93LFZ5XIIw68Yi4mHg4XLHYZXJJQgzM8vkm9RmZpbJCcLMzDI5QZiZWSYnCDMzy+QEYWZmmf4XZNV6c3Io/OkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot power (coefficient) curves\n",
    "if plt:\n",
    "    if e126.power_coefficient_curve is not None:\n",
    "        e126.power_coefficient_curve.plot(\n",
    "            x='wind_speed', y='value', style='*',\n",
    "            title='Enercon E126 power coefficient curve')\n",
    "        plt.xlabel('Wind speed in m/s')\n",
    "        plt.ylabel('Power coefficient $\\mathrm{C}_\\mathrm{P}$')\n",
    "        plt.show()\n",
    "    if e126.power_curve is not None:\n",
    "        e126.power_curve.plot(x='wind_speed', y='value', style='*',\n",
    "                              title='Enercon E126 power curve')\n",
    "        plt.xlabel('Wind speed in m/s')\n",
    "        plt.ylabel('Power in W')\n",
    "        plt.show()\n",
    "    if my_turbine.power_coefficient_curve is not None:\n",
    "        my_turbine.power_coefficient_curve.plot(\n",
    "            x='wind_speed', y='value', style='*',\n",
    "            title='myTurbine power coefficient curve')\n",
    "        plt.xlabel('Wind speed in m/s')\n",
    "        plt.ylabel('Power in W')\n",
    "        plt.show()\n",
    "    if my_turbine.power_curve is not None:\n",
    "        my_turbine.power_curve.plot(x='wind_speed', y='value', style='*',\n",
    "                                    title='myTurbine power curve')\n",
    "        plt.xlabel('Wind speed in m/s')\n",
    "        plt.ylabel('Power in W')\n",
    "        plt.show()\n",
    "    if my_turbine2.power_coefficient_curve is not None:\n",
    "        my_turbine2.power_coefficient_curve.plot(\n",
    "            x='wind_speed', y='value', style='*',\n",
    "            title='myTurbine2 power coefficient curve')\n",
    "        plt.xlabel('Wind speed in m/s')\n",
    "        plt.ylabel('Power in W')\n",
    "        plt.show()\n",
    "    if my_turbine2.power_curve is not None:\n",
    "        my_turbine2.power_curve.plot(x='wind_speed', y='value', style='*',\n",
    "                                    title='myTurbine2 power curve')\n",
    "        plt.xlabel('Wind speed in m/s')\n",
    "        plt.ylabel('Power in W')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}