{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Constrained Wake Steering Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Try this yourself](https://colab.research.google.com/github/DTUWindEnergy/TopFarm2/blob/master/docs/notebooks/wake_steering_and_loads.ipynb) (requires google account)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we perform an active yaw (wake steering) optimization while considering the fatigue loading as constraint. Here, the design variables are changed to the yaw angles of the turbines, which are dependent on the number of turbines and the wind speed and wind direction cases selected. In addition, we need to specify the wake deflection model to represent the wake behind the turbine as accurate as possible.\n",
    "\n",
    "Load calculations of the Damage Equivalent Loads (DEL) and Lifetime Damage Equivalent Loads (LDEL) are computed via PyWake for the turbines and flow cases selected. Then, the load constraints can be included either with the `AEPMaxLoadCostModel` or as **post_constraints** in the `TopFarmProblem`. Both types of set ups are included in this example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nv2ihk66SNgi"
   },
   "source": [
    "**Install TopFarm and PyWake if needed**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 67702,
     "status": "ok",
     "timestamp": 1623612898460,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "HP8XVx4URYcr"
   },
   "outputs": [],
   "source": [
    "# Install TopFarm if needed\n",
    "import importlib\n",
    "if not importlib.util.find_spec(\"topfarm\"):\n",
    "    !pip install git+https://gitlab.windenergy.dtu.dk/TOPFARM/TopFarm2.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TbtAki7QSZG4"
   },
   "source": [
    "**First we import basic Python elements and some Topfarm classes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionInfo": {
     "elapsed": 4290,
     "status": "ok",
     "timestamp": 1623612902741,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "5YqUNim5R3JG"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import newaxis as na\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "from topfarm.cost_models.cost_model_wrappers import AEPMaxLoadCostModelComponent\n",
    "from topfarm.easy_drivers import EasyScipyOptimizeDriver\n",
    "from topfarm import TopFarmProblem\n",
    "from topfarm.plotting import NoPlot\n",
    "\n",
    "from py_wake.examples.data.lillgrund import LillgrundSite\n",
    "from py_wake.deficit_models.gaussian import IEA37SimpleBastankhahGaussian, NiayifarGaussian\n",
    "from py_wake.turbulence_models.stf import STF2017TurbulenceModel\n",
    "from py_wake.examples.data.iea34_130rwt import IEA34_130_1WT_Surrogate \n",
    "from py_wake.deflection_models.jimenez import JimenezWakeDeflection\n",
    "from py_wake.superposition_models import MaxSum\n",
    "from py_wake.wind_turbines.power_ct_functions import SimpleYawModel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WjnaXixxSdZL"
   },
   "source": [
    "**Next, we select the site and wind turbine to use**.\n",
    "\n",
    "Usually, adding the loads as constraints into TOPFARM's problem requires an accurate calculation of the fatigue loading, which here is done by a surrogate of the IEA3 3.4MW turbine. In addition, it is necessary to specify a turbulence model (`STF2017TurbulenceModel`) that is adequate enough to represent the turbulence intensity in the site, which the surrogate model for the turbine will need for the load calculation. For the wake deflection, we will use the `JimenezWakeDeflection` model.\n",
    "\n",
    "For more information about wake models, please see: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/EngineeringWindFarmModels.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 1395,
     "status": "ok",
     "timestamp": 1623612904131,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "E-TFCSUSSt5e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 47ms/step\n"
     ]
    }
   ],
   "source": [
    "site = LillgrundSite()\n",
    "windTurbines = IEA34_130_1WT_Surrogate()\n",
    "wfm = IEA37SimpleBastankhahGaussian(site, windTurbines,deflectionModel=JimenezWakeDeflection(), turbulenceModel=STF2017TurbulenceModel(addedTurbulenceSuperpositionModel=MaxSum()))\n",
    "\n",
    "#choosing the flow cases for the optimization - this will determine the speed and accuracy of the simulation\n",
    "wsp = np.asarray([10, 15])\n",
    "wdir = np.asarray([90])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Next, we set up the load constraint**\n",
    "\n",
    "In this example, we will calculate nominal loads and use this as a basis for the load constraint. The loads are represented by the Lifetime Damage Equivalent Loads (LDEL)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1981,
     "status": "ok",
     "timestamp": 1623612906110,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "hjG7faI1iZBh",
    "outputId": "618fbcaa-ac5b-431e-81b2-00005db43238"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 28 calls to <function Model.make_predict_function.<locals>.predict_function at 0x00000196FADFEAF0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "WARNING:tensorflow:6 out of the last 29 calls to <function Model.make_predict_function.<locals>.predict_function at 0x00000196FBEB5700> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    }
   ],
   "source": [
    "%%capture\n",
    "x, y = site.initial_position.T\n",
    "\n",
    "#keeping only every second turbine as lillegrund turbines are approx. half the size of the iea 3.4MW\n",
    "x = x[::2]\n",
    "y = y[::2]\n",
    "n_wt = x.size\n",
    "\n",
    "#setting up the size of the yaw angle to represent the number of turbines, wind speeds and wind directions used\n",
    "i = n_wt\n",
    "k = wsp.size\n",
    "l = wdir.size\n",
    "yaw_zero = np.zeros((i, l, k))\n",
    "\n",
    "#choosing a load ratio for the constraint\n",
    "load_fact = 1.02\n",
    "simulationResult = wfm(x,y,wd=wdir, ws=wsp, yaw=yaw_zero, tilt=0)\n",
    "nom_loads = simulationResult.loads('OneWT')['LDEL'].values\n",
    "max_loads = nom_loads * load_fact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0v7KeHZvinpG"
   },
   "source": [
    "**Setting up optimization problem**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "executionInfo": {
     "elapsed": 13,
     "status": "ok",
     "timestamp": 1623612906112,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "VXXj960rjJt4"
   },
   "outputs": [],
   "source": [
    "#parameters needed for the optimization\n",
    "maxiter = 5\n",
    "driver = EasyScipyOptimizeDriver(optimizer='SLSQP', maxiter=maxiter)\n",
    "yaw_min, yaw_max =  - 40, 40\n",
    "yaw_init = np.zeros((i, l, k))\n",
    "tol = 1e-8\n",
    "ec = 1e-4\n",
    "step = 1e-2\n",
    "\n",
    "#setting up cost function - aep and nominal loads calculation\n",
    "def aep_load_func(yaw_ilk):\n",
    "    simres = wfm(x, y, wd=wdir, ws=wsp, yaw=yaw_ilk, tilt=0)\n",
    "    aep = simres.aep().sum()\n",
    "    loads = simres.loads('OneWT')['LDEL'].values\n",
    "    return [aep, loads]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S3Eq4hVNjWai"
   },
   "source": [
    "**Now, we can set up the gradient function used in the optimization**\n",
    "\n",
    "For some problems it is sufficient to rely on the automatic finite difference calculated by OpenMDAO or you can specify the explicit gradients from your model. In this case we don't have explicit gradients but the automatic finite difference is also inefficient, so we do a manual population of the Jacobian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "executionInfo": {
     "elapsed": 11,
     "status": "ok",
     "timestamp": 1623612906114,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "Ry6CRAZLj4VF"
   },
   "outputs": [],
   "source": [
    "s = nom_loads.shape[0]\n",
    "P_ilk = np.broadcast_to(simulationResult.P.values[na], (i, l, k))\n",
    "lifetime = float(60 * 60 * 24 * 365 * 20)\n",
    "f1zh = 10.0 ** 7.0\n",
    "lifetime_on_f1zh = lifetime / f1zh\n",
    "indices = np.arange(i * l * k).reshape((i, l, k))\n",
    "\n",
    "def aep_load_gradient(yaw_ilk):\n",
    "    simres0 = wfm(x, y, wd=wdir, ws=wsp, yaw=yaw_ilk, tilt=0)\n",
    "    aep0 = simres0.aep()\n",
    "    DEL0 = simulationResult.loads('OneWT')['DEL'].values\n",
    "    LDEL0 = simulationResult.loads('OneWT')['LDEL'].values\n",
    "    d_aep_d_yaw = np.zeros(i*l*k)\n",
    "    d_load_d_yaw = np.zeros((s * i, i * l * k))\n",
    "    for n in range(n_wt):\n",
    "        yaw_step = yaw_ilk.copy()\n",
    "        yaw_step = yaw_step.reshape(i, l, k)\n",
    "        yaw_step[n, :, :] += step\n",
    "        simres_fd = wfm(x, y, wd=wdir, ws=wsp, yaw=yaw_step, tilt=0)\n",
    "        aep_fd = simres_fd.aep()\n",
    "        d_aep_d_yaw[n * l * k : (n + 1) * l * k] = (((aep_fd.values - aep0.values) / step).sum((0))).ravel()\n",
    "        \n",
    "        DEL_fd = simres_fd.loads('OneWT')['DEL'].values\n",
    "        for _ls in range(s):\n",
    "            m = simulationResult.loads('OneWT').m.values[_ls]\n",
    "            for _wd in range(l):\n",
    "                for _ws in range(k):\n",
    "                    DEL_fd_fc = DEL0.copy()\n",
    "                    DEL_fd_fc[:, :, _wd, _ws] = DEL_fd[:, :, _wd, _ws]\n",
    "                    DEL_fd_fc = DEL_fd_fc[_ls, :, :, :]\n",
    "                    f = DEL_fd_fc.mean()\n",
    "                    LDEL_fd = (((P_ilk * (DEL_fd_fc/f) ** m).sum((1, 2)) * lifetime_on_f1zh) ** (1/m))*f\n",
    "                    d_load_d_yaw[n_wt * _ls : n_wt * (_ls + 1), indices[n, _wd, _ws]] = (LDEL_fd - LDEL0[_ls]) / step\n",
    "\n",
    "    return d_aep_d_yaw, d_load_d_yaw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TfbCb-z2j6nd"
   },
   "source": [
    "**Specifying the cost component and topfarm problem**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "executionInfo": {
     "elapsed": 12,
     "status": "ok",
     "timestamp": 1623612906115,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "5nqGrkbukCfd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: checking out_of_order\n",
      "INFO: checking system\n",
      "INFO: checking solvers\n",
      "INFO: checking dup_inputs\n",
      "INFO: checking missing_recorders\n",
      "INFO: checking unserializable_options\n",
      "INFO: checking comp_has_no_outputs\n",
      "INFO: checking auto_ivc_warnings\n"
     ]
    }
   ],
   "source": [
    "cost_comp = AEPMaxLoadCostModelComponent(input_keys=[('yaw_ilk', np.zeros((i, l, k)))],\n",
    "                                          n_wt = n_wt,\n",
    "                                          aep_load_function = aep_load_func,\n",
    "                                          aep_load_gradient = aep_load_gradient,\n",
    "                                          max_loads = max_loads, \n",
    "                                          objective=True,\n",
    "                                          income_model=True,\n",
    "                                          output_keys=[('AEP', 0), ('loads', np.zeros((s, i)))]\n",
    "                                          )\n",
    "\n",
    "problem = TopFarmProblem(design_vars={'yaw_ilk': (yaw_init, yaw_min, yaw_max)},\n",
    "                          n_wt=n_wt,\n",
    "                          cost_comp=cost_comp,\n",
    "                          driver=EasyScipyOptimizeDriver(optimizer='SLSQP', maxiter=maxiter, tol=tol),\n",
    "                          plot_comp=NoPlot(),\n",
    "                          expected_cost=ec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jt_GXqoHkV_W"
   },
   "source": [
    "**Now we run the optimization**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 538141,
     "status": "ok",
     "timestamp": 1623613843204,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "kOQhnRLUSGIz",
    "outputId": "6e174217-d355-472b-e3ef-9be7dee337da"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "cost, state, recorder = problem.optimize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can also do some plotting to visualize the final yaw angles found by the optimizer for a given flow case**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 293
    },
    "executionInfo": {
     "elapsed": 10125,
     "status": "ok",
     "timestamp": 1623613892575,
     "user": {
      "displayName": "Mikkel Friis-Møller",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiVrnxS0oNYcvEfwYdFjWYAU5G0YxLXELnknXMi=s64",
      "userId": "10444369613733539918"
     },
     "user_tz": -120
    },
    "id": "miJIu_aMtvwy",
    "outputId": "980c94bb-a157-45aa-de6a-6a2322a9dc58"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "simulationResult = wfm(x,y,wd=wdir[0], ws=wsp[0], yaw=state['yaw_ilk'][:,0,0], tilt=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'y [m]')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "simulationResult.flow_map().plot_wake_map()\n",
    "plt.xlabel('x [m]')\n",
    "plt.ylabel('y [m]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note:\n",
    "\n",
    "Due to the computational expensive nature of this problem, the maximum number of iterations were restricted to 5, for educational purposes. To see a convergence in loading and AEP, the number of iterations must be increased."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting up the load constraints as post_constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively to using the `AEPMaxLoadCostModelComponent`, the common `CostModelComponent` can also be used any load constrained problem. The main difference lies in the way the load constraints are specified within the `TopFarmProblem`. You should set up the load constraint as a **post_constraints** element. Below is an example on how to set up this type of problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: checking out_of_order\n",
      "INFO: checking system\n",
      "INFO: checking solvers\n",
      "INFO: checking dup_inputs\n",
      "INFO: checking missing_recorders\n",
      "INFO: checking unserializable_options\n",
      "INFO: checking comp_has_no_outputs\n",
      "INFO: checking auto_ivc_warnings\n"
     ]
    }
   ],
   "source": [
    "from topfarm.cost_models.cost_model_wrappers import CostModelComponent\n",
    "\n",
    "#setting up the cost model component and topfarm problem\n",
    "\n",
    "cost_comp = CostModelComponent([('yaw_ilk', np.zeros((i, l, k)))],\n",
    "                            n_wt=n_wt,\n",
    "                            cost_function=aep_load_func,\n",
    "                            cost_gradient_function=aep_load_gradient, \n",
    "                            objective=True,\n",
    "                            output_keys=[('AEP', 0.0), ('loads', np.zeros((s, i)))])\n",
    "\n",
    "#parameters for optimization\n",
    "maxiter = 5\n",
    "tol = 1e-4\n",
    "ec = 1\n",
    "\n",
    "problem = TopFarmProblem(design_vars={'yaw_ilk': (yaw_init, yaw_min, yaw_max)},\n",
    "                          n_wt = n_wt,\n",
    "                          post_constraints=[('loads', {'upper': max_loads})],\n",
    "                          cost_comp=cost_comp,\n",
    "                          driver=EasyScipyOptimizeDriver(optimizer='SLSQP', maxiter=maxiter, tol=tol),\n",
    "                          plot_comp=NoPlot(),\n",
    "                          expected_cost=ec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can evaluate the topfarm problem to make sure it is set up properly without having to run the optimization again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: checking out_of_order\n",
      "INFO: checking system\n",
      "INFO: checking solvers\n",
      "INFO: checking dup_inputs\n",
      "INFO: checking missing_recorders\n",
      "INFO: checking unserializable_options\n",
      "INFO: checking comp_has_no_outputs\n",
      "INFO: checking auto_ivc_warnings\n"
     ]
    }
   ],
   "source": [
    "%%capture\n",
    "problem.evaluate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluating the topfarm problem yields the initial conditions in terms of AEP and position of the turbines:\n",
    "\n",
    "    (72.12110945807837,\n",
    "     {'yaw_ilk': array([[[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]],\n",
    "  \n",
    "         [[0., 0.]]])})"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyOvPUxm8Sna0KLEzObl3Sp5",
   "name": "WakeSteeringOptimization.ipynb",
   "provenance": []
  },
  "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.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}