example/modelchain_example.ipynb

{
 "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",
    "\n",
    "from windpowerlib.modelchain import ModelChain\n",
    "from windpowerlib.wind_turbine import WindTurbine\n",
    "from windpowerlib import wind_turbine 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 file is located in the example folder of the\n",
    "    windpowerlib. The height in m for which the data applies is specified in\n",
    "    the second row.\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: 'windpowerlib/example'.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    weather_df : :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 (e.g. wind_speed) and the second level\n",
    "        contains the height at which it applies (e.g. 10, if it was\n",
    "        measured at a height of 10 m).\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    if 'datapath' not in kwargs:\n",
    "        kwargs['datapath'] = os.path.join(os.path.split(\n",
    "            os.path.dirname(__file__))[0], 'example')\n",
    "    file = os.path.join(kwargs['datapath'], filename)\n",
    "    \n",
    "    # read csv file \n",
    "    weather_df = pd.read_csv(\n",
    "        file, index_col=0, header=[0, 1],\n",
    "        date_parser=lambda idx: pd.to_datetime(idx, utc=True))\n",
    "    \n",
    "    # change type of index to datetime and set time zone\n",
    "    weather_df.index = pd.to_datetime(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": [
    "To initialize a specific turbine you need a dictionary that contains the basic parameters. A turbine is defined by its nominal power, hub height, rotor diameter, and power or power coefficient curve.\n",
    "\n",
    "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 'dummy_turbine'.\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": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Data base connection successful.\n"
     ]
    },
    {
     "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-141/4200             True          True\n",
      "7       Enercon     E-53/800             True          True\n",
      "8       Enercon    E-70/2000             True          True\n",
      "9       Enercon    E-70/2300             True          True\n",
      "10      Enercon    E-82/2000             True          True\n",
      "11      Enercon    E-82/2300             True          True\n",
      "12      Enercon    E-82/2350             True          True\n",
      "13      Enercon    E-82/3000             True          True\n",
      "14      Enercon    E-92/2350             True          True\n",
      "15      Enercon   E/126/7500             True         False\n",
      "16      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": 32,
   "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": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/birgit/virtualenvs/windpowerlib/git_repos/windpowerlib/windpowerlib/wind_turbine.py:322: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  wpp_df.dropna(axis=1, inplace=True)\n"
     ]
    }
   ],
   "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": 35,
   "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",
    "csv_path = 'data'\n",
    "dummy_turbine = {\n",
    "    'turbine_type': 'DUMMY 1',  # turbine type as in file\n",
    "    'hub_height': 100,  # in m\n",
    "    'rotor_diameter': 70,  # in m\n",
    "    'path': csv_path\n",
    "}\n",
    "# initialize WindTurbine object\n",
    "dummy_turbine = WindTurbine(**dummy_turbine)"
   ]
  },
  {
   "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 'dummy_turbine'."
   ]
  },
  {
   "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 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": 10,
   "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 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': 'power_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": 11,
   "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 barometric height equation.\n",
      "DEBUG:root:Calculating power output using power coefficient curve.\n"
     ]
    }
   ],
   "source": [
    "# power output calculation for example_turbine\n",
    "# own specification for 'power_output_model'\n",
    "mc_example_turbine = ModelChain(\n",
    "    dummy_turbine,\n",
    "    power_output_model='power_coefficient_curve').run_model(weather)\n",
    "dummy_turbine.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": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.font_manager:findfont: Matching :family=sans-serif:style=normal:variant=normal:weight=normal:stretch=normal:size=10.0 to DejaVu Sans ('/home/sabine/virtualenvs/windpowerlib/lib/python3.6/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans.ttf') with score of 0.050000.\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n"
     ]
    },
    {
     "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",
    "    dummy_turbine.power_output.plot(legend=True, label='dummyTurbine')\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Power in W')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.font_manager:findfont: Matching :family=sans-serif:style=normal:variant=normal:weight=normal:stretch=normal:size=12.0 to DejaVu Sans ('/home/sabine/virtualenvs/windpowerlib/lib/python3.6/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans.ttf') with score of 0.050000.\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ4AAAEWCAYAAABWn/G6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3de5xdVX338c93MsMMlYRrArkHgXIJlCDTcFMhtEJildC+IFxSAR+U9ilYgVIuSiva+BQtQhsvLSgIGAIqoiCCEdIAKYSQiSCX0DQRQy5cMklIQtSMGfJ7/thr6HGYyznDnH0m53zfr9d5zT5rX9Zvz5mcX9baa++liMDMzCwvdZUOwMzMaosTj5mZ5cqJx8zMcuXEY2ZmuXLiMTOzXDnxmJlZrpx4zMwsV048VlGSVkj6raQtBa+vVTquvpI0TlJ0Op8tks5I6ydJmidpk6QVnfYdJulOSa+k9Y9LOqrTNkMlzU7r35B0R46nZ9Yv6isdgBnw0Yh4uJwVSKqPiPZy1tHJbt3U92vgFuBO4DOd1u0CLAIuBdYC5wM/kTQuIrakbe5J24wBfgMcWobY+50kAYqI7TvSsa083OKxAUvSeZL+S9J16X/3v5I0pWD9rpJulvSqpDWSZkgaVLDv45JukLQeuCaVf1LSi5LelLRE0vtS+cGSHpG0UdILkk4pqOdWSV+X9JO030JJ+/XlnCLiqYj4DvBSF+teiojrI+LViHgrIm4CdgIOTHGcBIwG/j4iNkXEtoh4uoff3wpJV6XzfEPStyU1Faz/pKTlkjZIuk/SiFT+eUlfTcsNkn4t6V/S+50lbZW0R3p/tKQn0u/tF5JOKDj+I5K+KOlxsiT53i5iHC3pHkmtktZ3tHYlXSNpVsF2HS3J+m6O/feSWjod+xJJ96XlxvR3tFLS65L+Q9LO3X9SVk5OPDbQHQUsBfYCvgzcnP6HC3Ar0A7sDxwBnAR8otO+LwF7A1+UdDpZAjoHGAKcAqyX1AD8GPgZMAz4FHCHpAMLjnUm8Hlgd2A58MV+Ps93kDSBLPEsT0VHk/0ubktf0oskHd/LYaYDJwP7AX8IXJ2OfSLwz8A0YDjwMnBX2udR4IS0/MfAa8AH0/tjgKURsUHSSOAnwAxgD+Ay4AeShhbU/zHgAmBwqqPw/AYB96fyccDIghiKUXjs/wAOlHRAwfqzgdlp+dp0/hPI/l5GAv9YQl3WnyLCL78q9gJWAFuAjQWvT6Z15wHLC7b9AyCAfciSSRuwc8H6s4B5Bfuu7FTXHODTXcTwAbIv17qCsjuBa9LyrcC3CtZ9GPjvbs5nXIpxY6fXwZ22+1NgRQ+/lyHAc8BVBWU3pWOfDzSQJcONwF49/G7/ulPcv0zLNwNfLli3C7Atxb8zsBXYE7iSrEtwddrm88DMtM8VwHe6+B2fm5YfAb7QwzkeA7QC9V2suwaY1cXvtb67YwOzgH9MywcAb6a/GZF1ce7Xqe5fVfrvv1ZfbvHYQHBqROxW8PpmwbrXOhYi4jdpcRdgLNmX76upm2cjcCNZi6XDqk71jAZ+2UX9I4BV8fvXCF4m+1/xO+Ig69rZpZdz2qvTOb3Yy/ZvS11APwaejIh/Llj1W7JkdXNk3Wx3kZ3jcT0crvB38DLZuZJ+vt0Ciewa0npgZET8FmgBjidr6TwKPJHqOT69h+wzOL3j958+g/eTtaC6qr+z0cDL0fdrb52PPZvsPx+QtXZ+lP5mhpIloMUFcf40lVsFeHCB7ahWkbV49urhi6vzo9dXkXU5dfYKMFpSXUHyGQP8T79EWgJJjcCPyFoYf9Vp9bPARzuV9fZ4+dEFy2PIzpX0c2xBve8ha+GsSUWPAieSdWEuSu9PBiYCj6VtVpG1eD7ZQ/09xbcKGNPNwI9fkyWLDvsUceyHgKGpi/Is4JJUvo4saY+PiDVYxbnFYzukiHiV7JrMVyQNkVQnab9ernl8C7hM0pHK7C9pLLCQrBVzebqYfgLZF3wp1xuKkuJsImutSVKTpJ3SugbgbrIvyXPjnaO0fgjsLulcSYMknQaMAh7vocoLJY1KgwE+C3w3ld8JfFzShJTs/h+wMCJWpPWPkl0LWxIRvyPr2voEWfdUa9pmFvBRSSeneJoknSBpVJG/jqeAV4FrJb0n7d/RensG+KCkMZJ2Ba7q7WARsQ34PvAvZNecHkrl24FvAjdIGgYgaaSkk4uM0/qZE48NBD/W79/z8sMi9zuH7OL7EuANsi/t4d1tHBHfJxsUMJus//9HwB7pi/WjwBSy/x1/AzgnIv67rycEbOx0Tpem8g+SJZYHyFogvyVLoADHAh8hGyRRuP8HUvwbyAZEXAZsIrv+MjUi1vUQx+x0/JfIuhlnpGM9DPwD8AOyL//9yK4ZdXiC7FpPR+tmCdl1n473RMQqYCrZNaBWshbM31Pk90pEvEX2e98fWEnWyjsjrXuILEk+CywmG4RQjNlk18++36kVdQXZII0nJW0GHiaNFrT8KcITwZlVI2U3qH4iynyPlFmp3OIxM7NcOfGYmVmu3NVmZma5covHzMxy5ft4erHXXnvFuHHjKh2GmdkOZfHixesiosubdJ14ejFu3DhaWlp639DMzN4m6eXu1rmrzczMcuXEY2ZmuXLiMTOzXPkaTx9s27aN1atXs3Xr1kqHkqumpiZGjRpFQ0NDpUMxsx2YE08frF69msGDBzNu3Dj+d06y6hYRrF+/ntWrV7PvvvtWOhwz24G5q60Ptm7dyp577lkzSQdAEnvuuWfNtfKqydrNW5l24wLWvln8Z5jHPo6rOuIqhRNPH9VS0ulQi+dcTWbOXcaiFRuY+fCyAbWP46qOuErhR+b0orm5OTrfx/Piiy9y8MEHVyiiyqrlc99RHXj1g7S1d57aBxrr61g6Y0rF9nFc1RFXdyQtjojmrta5xVMDdtmlt1mabUdTSjfI/MsnccqEETQ1ZP/cmxrqmDphBPOvmFTRfRxXdcTVF048OSlnf6nVnlK6QYYNaWJwYz1t7dtprK+jrX07gxvrGTa4qaL7OK7qiKsvPKotJ4VfFDP+/LB3dawrr7yS0aNHc+GFFwJwzTXXUF9fz7x583jjjTfYtm0bM2bMYOrUqb+33yOPPMJ1113H/fdnkzledNFFNDc3c95557F48WIuvfRStmzZwl577cWtt97K8OHdTuZpFdK5G2TWwpXMWriy126QdVvamH7UWM6eOIbZT62ktYj/AOWxj+OqjrhK5Ws8vXi313j6q7+00NNPP83FF1/Mo48+CsAhhxzCnDlz2HXXXRkyZAjr1q3j6KOPZtmyZUhil112YcuWLd0mnunTp3P88cdz7733MnToUL773e8yZ84cbrnllnfU7Ws8lbV281ZmPPAiP3vhNbZu205TQx0nj9+Hz/7Zwf36P1Kzd6unazxu8ZTZ/MsndftF0VdHHHEEa9eu5ZVXXqG1tZXdd9+dffbZh0suuYTHHnuMuro61qxZw+uvv84+++zT6/GWLl3K888/z4c+9CEA3nrrLbd2Bqg8ukHMys2Jp8zK9UVx+umnc/fdd/Paa69xxhlncMcdd9Da2srixYtpaGhg3Lhx77jnpr6+nu3b/7f11bE+Ihg/fjwLFix4VzFZPsrdDWJWbmUfXCBpkKSnJd2f3u8raaGk5ZK+K2mnVN6Y3i9P68cVHOOqVL5U0skF5ZNT2XJJVxaUl1xHOXV8Ufzwb45j+lFjad3S9q6PecYZZ3DXXXdx9913c/rpp7Np0yaGDRtGQ0MD8+bN4+WX3/lE8rFjx7JkyRLa2trYuHEjc+fOBeDAAw+ktbX17cSzbds2XnjhhXcdo5XHjR9rZsaph3LIiCHMOPVQbvxYl70ZZgNWHqPaPg28WPD+S8ANEbE/8AZwfio/H3gjld+QtkPSIcCZwHhgMvCNlMwGAV8HpgCHAGelbUuuo9zK8UUxfvx43nzzTUaOHMnw4cOZPn06LS0tHHbYYdx+++0cdNBB79hn9OjRTJs2jUMPPZRp06ZxxBFHALDTTjtx9913c8UVV3D44YczYcIEnnjiiXcdoxXPox6tpkRE2V7AKGAucCJwPyBgHVCf1h8DzEnLc4Bj0nJ92k7AVcBVBceck/Z7e99UflV6lVxHT+dw5JFHRmdLlix5R1mtqOVzL6fP3vNsjLvy/vjsPc9WOhSzfgG0RDffq+W+xvOvwOXA4PR+T2BjRLSn96uBkWl5JLAKICLaJW1K248Eniw4ZuE+qzqVH9XHOta9u9M065u+Do8225GVratN0keAtRGxuFx1lIukCyS1SGppbW2tdDhWxfK4S9xsoCnnNZ7jgFMkrQDuIutu+zdgN0kdLa1RwJq0vAYYDZDW7wqsLyzvtE935ev7UMfviYibIqI5IpqHDh3a5clFDd7/VIvnXG4eHm21qGyJJyKuiohRETGObHDAf0bEdGAecFra7Fzg3rR8X3pPWv+fqZ/wPuDMNCJtX+AA4ClgEXBAGsG2U6rjvrRPqXWUpKmpifXr19fUF3Gk+XiamvyF2N/KMerRbCDL5ckFkk4ALouIj0h6L1kLaA/gaeAvI6JNUhPwHeAIYANwZkS8lPb/LPB/gHbg4oh4MJV/mOw60iDgloj4YiovuY7udPXkAs9A6hlIzaxnPT25wI/M6UVXicfMzHrmaRHMzGzAcOIxM7NcOfGYmVmunHjMzCxXTjxmZpYrJx4zM8uVE4+ZmeXKicfMzHLlxGPWzzy3jlnPnHjM+tnMuctYtGIDMx9eVulQzAakcs/HY1YzPLeOWXHc4jHrJ55bx6w4Tjxm/cRz65gVx11tZv2oY26dsyeOYfZTK2n1AAOzd/C0CL3wtAhmZqXztAhmZjZgOPGYmVmunHjMzCxXTjxmZpYrJx4zM8uVE4+ZmeXKicfMzHLlxGNmZrly4jEzs1w58ZiZWa6ceMzMLFdOPGZmlisnHjMzy5UTj5mZ5cqJx8zMcuXEY2ZmuXLiMTOzXDnxmJlZrpx4zHqwdvNWpt24gLVvbq10KGZVw4nHrAcz5y5j0YoNzHx4WaVDMasa9ZUOwGwgOvDqB2lr3/72+1kLVzJr4Uoa6+tYOmNKBSMz2/G5xWPWhfmXT+KUCSNoasj+iTQ11DF1wgjmXzGpwpGZ7ficeMy6MGxIE4Mb62lr305jfR1t7dsZ3FjPsMFNlQ7NbIfnrjazbqzb0sb0o8Zy9sQxzH5qJa0eYGDWLxQR5Tmw1AQ8BjSSJbi7I+JzkvYF7gL2BBYDH4uI30lqBG4HjgTWA2dExIp0rKuA84G3gL+NiDmpfDLwb8Ag4FsRcW0qL7mO7jQ3N0dLS0v//FLMzGqEpMUR0dzVunJ2tbUBJ0bE4cAEYLKko4EvATdExP7AG2QJhfTzjVR+Q9oOSYcAZwLjgcnANyQNkjQI+DowBTgEOCttS6l1mJlZfsqWeCKzJb1tSK8ATgTuTuW3Aaem5anpPWn9n0hSKr8rItoi4lfAcmBiei2PiJci4ndkLZypaZ9S6zAzs5yUdXBBapk8A6wFHgJ+CWyMiPa0yWpgZFoeCawCSOs3kXWVvV3eaZ/uyvfsQx2d475AUoukltbW1r6dvJmZdamsiSci3oqICcAoshbKQeWsr79ExE0R0RwRzUOHDq10OGZmVSWX4dQRsRGYBxwD7CapYzTdKGBNWl4DjAZI63clGwDwdnmnfborX9+HOszMLCdlSzyShkraLS3vDHwIeJEsAZ2WNjsXuDct35fek9b/Z2RD7u4DzpTUmEarHQA8BSwCDpC0r6SdyAYg3Jf2KbUOMzPLSTnv4xkO3JZGn9UB34uI+yUtAe6SNAN4Grg5bX8z8B1Jy4ENZImEiHhB0veAJUA7cGFEvAUg6SJgDtlw6lsi4oV0rCtKqcPMzPJTtvt4qoXv4zEzK12l7uMxMzN7ByceMzPLlROPmZnlyonHzMxy5cRjZma5cuIxM7NcOfGYmVmunHjMzCxXTjxmZpYrJx4zM8tVt4lH0qmShuUZjJmZVb+eWjx/CTwtaZmk29LkaIfmFZiZmVWnbhNPRJwWESPJpjOYA/wR2dOmWyU9kFeAZmZWXXqdFiEiVkhqAnZOr45lMzOzknWbeCR9hmzG0KHAUuBJ4GvABR3z4ZiZmZWqpxbPOcCvgR8DTwALI2JTLlGZmVnV6jbxRMRBkvYAjgVOAK6UtAvwC+CJiPh2PiGamVk16fE+nojYEBH3A/8IXAV8H5gEfCuH2Mz63drNW5l24wLWvrm10qGY1aye7uM5RdK1kuYDa4HrgD2BvwP2ySk+s341c+4yFq3YwMyHl1U6FLOapYjoeoV0D/A42fWdxRHxuzwDGyiam5ujpaWl0mHYu3Tg1Q/S1r79HeWN9XUsnTGlAhGZVTdJiyOiuat1Pd3H8xcR8ZWIWFCrSceqx/zLJ3HKhBE0NWR/8k0NdUydMIL5V0yqcGRmtcfParOaMGxIE4Mb62lr305jfR1t7dsZ3FjPsMFNlQ7NrOb0egOpWbVYt6WN6UeN5eyJY5j91EpaPcDArCK6vcZjGV/jMTMrXU/XeHpt8Ug6DrgGGJu2FxAR8d7+DNLMzGpDMV1tNwOXAIsBPyrHzMzelWISz6aIeLDskZiZWU0oJvHMk/QvwD1AW0dhRPy8bFGZmVnVKibxHJV+Fl4kCuDE/g/HzMyqXTHz8fgOOzMz6zc9zcfzlxExS9KlXa2PiOvLF5aZmVWrnlo870k/B+cRiJmZ1Yae5uO5Mf38fH7hmJlZtfOz2szMLFdOPGZmlqseE4+kOknT8grGzMyqX29TX28HLs8pFjMzqwHFdLU9LOkySaMl7dHxKntkZmZWlYpJPGcAFwKPkT0odDHQ6zwBKVHNk7RE0guSPp3K95D0kKRl6efuqVySZkpaLulZSe8rONa5aftlks4tKD9S0nNpn5mS1Nc6zMwsH70mnojYt4tXMVMitAN/FxGHAEcDF0o6BLgSmBsRBwBz03uAKcAB6XUB8O+QJRHgc2SP7pkIfK4jkaRtPlmw3+RUXlIdZmaWn14Tj6Q/kHS1pJvS+wMkfaS3/SLi1Y4HiUbEm8CLwEhgKnBb2uw24NS0PBW4PTJPArtJGg6cDDwUERsi4g3gIWByWjckIp6MbDa72zsdq5Q6zMwsJ8V0tX0b+B1wbHq/BphRSiWSxgFHAAuBvSPi1bTqNWDvtDwSWFWw2+pU1lP56i7K6UMdneO9QFKLpJbW1tbiTtLMzIpSTOLZLyK+DGwDiIjfkM1CWhRJuwA/AC6OiM2F61JLpaxzb/eljoi4KSKaI6J56NChZYrMzKw2FZN4fidpZ9KXt6T9KJiXpyeSGsiSzh0RcU8qfr2jeyv9XJvK1wCjC3Yflcp6Kh/VRXlf6jAzs5wUk3iuAX4KjJZ0B9nF+l7v7UkjzG4GXuz0JOv7gI6RaecC9xaUn5NGnh1NNvPpq8Ac4CRJu6dBBScBc9K6zZKOTnWd0+lYpdRhZmY5KWY+np9JWkw2Mk3ApyNiXRHHPg74GPCcpGdS2WeAa4HvSTofeBnoeDLCA8CHgeXAb4CPp/o3SPonYFHa7gsRsSEt/w1wK7Az8GB6UWodZmaWH2WXQHrYQJoFPArMj4j/ziWqAaS5uTlaWnq9bcnMzApIWhwRzV2tK6ar7WZgOPBVSS9J+kHHzaBmZmalKuYG0nnAF4F/AL4JNAP/t8xxmfVq7eatTLtxAWvf3FrpUMysBMXcQDoXeJzs0TlLgT+OiIPKHZhZb2bOXcaiFRuY+fCySodiZiXodXAB8CxwJHAosAnYKGlBRPy2rJGZdePAqx+krX372+9nLVzJrIUraayvY+mMKRWMzMyKUUxX2yUR8UHgL4D1ZE8y2FjuwMy6M//ySZwyYQRNDdmfb1NDHVMnjGD+FZMqHJmZFaPXFo+ki4APkLV6VgC3APPLG5ZZ94YNaWJwYz1t7dtprK+jrX07gxvrGTa4qdKhmVkRiulqawKuBxZHRHuZ4zEryrotbUw/aixnTxzD7KdW0uoBBmY7jF7v4wGQdDhZqwey+3l+UdaoBhDfx2NmVrp3dR+PpL8F7gCGpdcsSZ/q3xDNzKxWFNPV9gngqIj4NYCkLwELgK+WMzAzM6tOxTy5QMBbBe/fooRpEczMzAoV0+L5NrBQ0g/T+1PJHqNjZmZWsmKeTn29pEeA96eij0fE02WNyszMqla3iUdSE/DXwP7Ac8A3PJzazMzerZ6u8dxG9kDQ54ApwHW5RGRmZlWtp662QyLiMABJNwNP5ROSmZlVs55aPNs6FtzFZmZm/aWnFs/hkjanZQE7p/cCIiKGlD06MzOrOt0mnogYlGcgZmZWG4q5gdTMzKzfOPGYmVmunHjMzCxXTjxmZpYrJx4zM8uVE4+ZmeXKicfMzHLlxGNmZrly4jEzs1w58diAsHbzVqbduIC1b26tdChmVmZOPDYgzJy7jEUrNjDz4WWVDsXMyqyYqa/NyubAqx+krX372+9nLVzJrIUraayvY+mMKRWMzMzKxS0eq6j5l0/ilAkjaGrI/hSbGuqYOmEE86+YVOHIzKxcnHisooYNaWJwYz1t7dtprK+jrX07gxvrGTa4qdKhmVmZuKvNKm7dljamHzWWsyeOYfZTK2n1AAOzqqaIqHQMA1pzc3O0tLRUOgwzsx2KpMUR0dzVOne1mZlZrpx4zMwsV048ZmaWq7IlHkm3SFor6fmCsj0kPSRpWfq5eyqXpJmSlkt6VtL7CvY5N22/TNK5BeVHSnou7TNTkvpah5mZ5aecLZ5bgcmdyq4E5kbEAcDc9B5gCnBAel0A/DtkSQT4HHAUMBH4XEciSdt8smC/yX2pw8zM8lW2xBMRjwEbOhVPBW5Ly7cBpxaU3x6ZJ4HdJA0HTgYeiogNEfEG8BAwOa0bEhFPRjYs7/ZOxyqlDjMzy1He13j2johX0/JrwN5peSSwqmC71amsp/LVXZT3pY53kHSBpBZJLa2trUWempmZFaNigwtSS6WsNxH1tY6IuCkimiOieejQoWWIzMysduWdeF7v6N5KP9em8jXA6ILtRqWynspHdVHelzrMzCxHeSee+4COkWnnAvcWlJ+TRp4dDWxK3WVzgJMk7Z4GFZwEzEnrNks6Oo1mO6fTsUqpw8zMclS2Z7VJuhM4AdhL0mqy0WnXAt+TdD7wMjAtbf4A8GFgOfAb4OMAEbFB0j8Bi9J2X4iIjgELf0M2cm5n4MH0otQ6zMwsX35WWy/8rDYzs9L5WW1mZjZgOPGYmVmunHjMzCxXTjxWFms3b2XajQtY60ndzKwTJx4ri5lzl7FoxQZmPrys0qGY2QDjqa+tXx149YO0tW9/+/2shSuZtXAljfV1LJ0xpYKRmdlA4RaP9av5l0/ilAkjaGrI/rSaGuqYOmEE86+YVOHIzGygcOKxfjVsSBODG+tpa99OY30dbe3bGdxYz7DBTZUOzcwGCHe1Wb9bt6WN6UeN5eyJY5j91EpaPcDAzAr4yQW98JMLzMxK5ycXmJnZgOHEY2ZmuXLiMTOzXDnxmJlZrpx4zMwsV048ZmaWKyceMzPLlROPmZnlyonHzMxy5cRjvfLcOmbWn5x4rFeeW8fM+pMfEmrd8tw6ZlYObvFYtzy3jpmVgxOPdctz65hZObirzXrkuXXMrL95Pp5eeD4eM7PSeT4eMzMbMJx4zMwsV048ZmaWKyeeGuOnEJhZpTnx1Bg/hcDMKs3DqWuEn0JgZgOFWzw1wk8hMLOBwomnRvgpBGY2ULirrYb4KQRmNhD4yQW9GOhPLli7eSsX3fk0Xzv7CLdezGzA8JMLqphHqZnZjsZdbTsoj1Izsx1VzbV4JE2WtFTScklXlquevtyoWco+HqVmZjuqmko8kgYBXwemAIcAZ0k6pBx19aULrJR9PErNzHZUtdbVNhFYHhEvAUi6C5gKLOmvCvrSBdbXbjOPUjOzHVFNjWqTdBowOSI+kd5/DDgqIi7qtN0FwAUAY8aMOfLll18uuo61m7cy44EX+dkLr7F123aaGuo4efw+fPbPDu62NdKXfczMBjKPaitRRNwUEc0R0Tx06NCS9u1LF5i7zcysltRaV9saYHTB+1GprF/1pQvM3WZmVitqrautHvgf4E/IEs4i4OyIeKG7fQb6DaRmZgNRT11tNdXiiYh2SRcBc4BBwC09JR0zM+t/NZV4ACLiAeCBSsdhZlarPLjAzMxy5cRjZma5cuIxM7NcOfGYmVmuamo4dV9IagU6Hl2wF7CuguFUks+9dtXy+dfyucO7O/+xEdHlHfhOPCWQ1NLduPRq53OvzXOH2j7/Wj53KN/5u6vNzMxy5cRjZma5cuIpzU2VDqCCfO61q5bPv5bPHcp0/r7GY2ZmuXKLx8zMcuXEY2ZmuXLiKYKkyZKWSlou6cpKx5M3SSskPSfpGUlVPUeEpFskrZX0fEHZHpIekrQs/dy9kjGWUzfnf42kNenzf0bShysZY7lIGi1pnqQlkl6Q9OlUXvWffw/nXpbP3td4eiFpENkcPh8CVpPN4XNWRCypaGA5krQCaI6Iqr+RTtIHgS3A7RFxaCr7MrAhIq5N//HYPSKuqGSc5dLN+V8DbImI6yoZW7lJGg4Mj4ifSxoMLAZOBc6jyj//Hs59GmX47N3i6d1EYHlEvBQRvwPuAqZWOCYrk4h4DNjQqXgqcFtavo3sH2RV6ub8a0JEvBoRP0/LbwIvAiOpgc+/h3MvCyee3o0EVhW8X00ZP5ABKoCfSVos6YJKB1MBe0fEq2n5NWDvSgZTIRdJejZ1xVVdV1NnksYBRwALqbHPv9O5Qxk+eyceK8b7I+J9wBTgwtQdU5Mi65uutf7pfwf2AyYArwJfqWw45SVpF+AHwMURsblwXbV//l2ce1k+eyee3q0BRhe8H5XKakZErEk/1wI/JOt+rCWvpz7wjr7wtRWOJ1cR8XpEvBUR24FvUsWfv6QGsi/eOyLinlRcE59/V+ders/eiad3i4ADJO0raSfgTOC+CseUG0nvSRcbkfQe4CTg+Z73qjr3Aeem5XOBeysYS+46vnSTP6dKP39JAm4GXoyI6wtWVf3n3925l+uz96i2IqQhhP8KDAJuiYgvVjik3Eh6L1krB8Nl+EsAAAQhSURBVKAemF3N5y/pTuAEssfBvw58DvgR8D1gDNkUGdMioiovwHdz/ieQdbUEsAL4q4JrHlVD0vuB+cBzwPZU/Bmyax1V/fn3cO5nUYbP3onHzMxy5a42MzPLlROPmZnlyonHzMxy5cRjZma5cuIxM7NcOfFYzZN0g6SLC97PkfStgvdfkXSppBGS7i7x2OdJ+lp/xlsqSeMKnzZdUF7y+ZRY74OSRpXr+LbjcuIxg8eBYwEk1ZHdwzK+YP2xwBMR8UpEnFaB+MqinOcjaWdgz4hYXY7j247NiccMngCOScvjye7OflPS7pIagYOBnxe2HFJL5h5JP03ztHy542CSPi7pfyQ9BRzXVYWSji+Y4+RpSYMlnSDpMUk/UTb/03+kRIikkyQtkPRzSd9Pz9RC0pGSHk0PcJ1T8GiXIyX9QtIvgAu7iaGo8+m0zwpJ/5zibpH0vlTvLyX9dcGmJwCPpH2uVTbPy7OSqnpqBSuOE4/VvIh4BWiXNIasdbOA7G71Y4Bm4Lk0JUZnE4AzgMOAM5RNpjUc+DxZwnk/cEg31V4GXBgRE4APAL9N5ROBT6X99gP+QtJewNXAn6aHtbYAl6Zna30VOC0ijgRuATqeKvFt4FMRcXgJv4p3nE83261Mcc8HbgVOA45O591hCvBTSXuSPWplfET8ETCjhHisStVXOgCzAeIJsqRzLHA92dQXxwKbyLriujI3IjYBSFoCjCXrpnskIlpT+XeBP+xi38eB6yXdAdwTEauzx2XxVES8lPa9kyx5bSVLRI+nbXYiS44HAocCD6XyQcCrknYDdktz6wB8hywR9Kar81nVxXYdzyp8Dtglzd/ypqQ2SbtFxEayxHsZ2eNXtgI3S7ofuL+IOKzKOfGYZTqu8xxG1tW2Cvg7YDNZ66ErbQXLb1HCv6c0m+VPgA+TJZSTO1Z13hQQ8FBEnFW4QtJhwAsRcUyn8t2KjaOTYs+nY7vtnfbZDtSn5/ut6mglSpoI/AlZy+gi4MQ+xmdVwl1tZpkngI+QTXH8VnoI5G5k3W1PlHCchcDxkvZMXWGnd7WRpP0i4rmI+BLZE9APSqsmpieh15F1e/0X8CRwnKT9077vkfSHwFJgqKRjUnmDpPGpxbExPfgRYHoJ8feHKcBPU0y7ALtGxAPAJUApXX9WpZx4zDLPkXWTPdmpbFNErCv2IOnJvdeQdYU9TjaFcFculvS8pGeBbcCDqXwR8LW036+AH6Zuu/OAO9P2C4CDUoviNOBLaRDBM6TRecDHga9LeoasxZSnyaTEAwwG7k9x/xdwac6x2ADkp1ObDRCSTgAui4iPVDqWvkqjAB+PiOZKx2IDl6/xmFm/iYg2spGAZt1yi8fMzHLlazxmZpYrJx4zM8uVE4+ZmeXKicfMzHLlxGNmZrn6/5W5/5ZKJ6dsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n",
      "DEBUG:matplotlib.axes._base:update_title_pos\n"
     ]
    },
    {
     "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 in W')\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()"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}