examples/tutorial_1_WaveBot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 1 - WaveBot\n",
    "The goal of this tutorial is to familiarize new users with how to set up and run optimization problems using WecOptTool. \n",
    "It uses a one-body WEC, the WaveBot, in one degree of freedom in regular waves. \n",
    "\n",
    "![WaveBot Photo](https://live.staticflickr.com/65535/51855905347_de87ccaaba_z.jpg)\n",
    "\n",
    "At the end of this tutorial the user will perform control co-design of the WEC's geometry and a corresponding optimal controller to maximize electrical power. \n",
    "We build up to this problem in three parts of successive complexity:\n",
    "\n",
    "1. [Optimal control for maximum mechanical power](#1.-Optimal-control-for-maximum-mechanical-power)\n",
    "2. [Optimal control for maximum electrical power](#2.-Optimal-control-for-maximum-electrical-power)\n",
    "3. [Control co-design of the WEC's geometry for maximum electrical power](#3.-Control-co-design-of-the-WEC-geometry-for-maximum-electrical-power)\n",
    "\n",
    "We will start by loading the necessary modules: \n",
    "\n",
    "* Import Autograd (wrapper on NumPy, required) for automatic differentiation\n",
    "* Import other packages we will use in this tutorial \n",
    "* Import WecOptTool "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import autograd.numpy as np\n",
    "import capytaine as cpy\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import brute\n",
    "\n",
    "import wecopttool as wot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Optimal control for maximum mechanical power\n",
    "This example illustrates how to set up, run, and analyze a basic optimization problem within WecOptTool.\n",
    "\n",
    "The objective of this example is to **find the optimal PTO force time-series** that produces the most mechanical power subject to the WEC dynamics and a maximum force the PTO can exert.\n",
    "\n",
    "WecOptTool requires the following to be defined to successfully run its optimization routines:\n",
    "- The WEC object, including all of its properties and constraints\n",
    "- The wave condition\n",
    "- The objective function\n",
    "\n",
    "<div>\n",
    "<img src=\"https://live.staticflickr.com/65535/52435098523_37d6a2ca94_k.jpg\" width=\"1000\">\n",
    "</div>\n",
    "\n",
    "The graphic shows all the requirements for this first part of the tutorial: from the wave on the left, to the objective (mechanical power) on the right.\n",
    "The WEC object, with all it's components, is illustrated in the middle. The components inside the blue box are the WEC properties that are actually passed on to the optimizer.\n",
    "In short, the WEC's hydrodynamic properties are modelled by\n",
    "1. Defining the WEC's geometry\n",
    "2. Meshing the geometry\n",
    "3. Obtaining the WEC's BEM cofficients based on the mesh\n",
    "4. Determening the WEC's intrinsic impedance model based on the BEM coefficients\n",
    "\n",
    "For this first part of the tutorial, the heave-only, WEC-PTO kinematics are trivial (Unity) and the PTO is assumed to be lossless."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WEC object\n",
    "In this section we will create the `WEC` object, which contains all the information about the WEC and its dynamics. This constitutes the vast majority of the setup required to run WecOptTool.\n",
    "\n",
    "Our `WEC` object requires information about the mesh, degrees of freedom, mass and hydrostatic properties, linear hydrodynamic coefficients (from a BEM solution), any additional dynamic forces (e.g. PTO force, mooring, non-linear hydrodynamics), and constraints (e.g. maximum PTO extension). \n",
    "In this case, the only additional force will be the PTO force and the only constraint will be a maximum PTO force of $2,000 N$.\n",
    "\n",
    "#### Mesh\n",
    "First, we will create a surface mesh for the hull and store it using the `FloatingBody` object from Capytaine. The WaveBot mesh is pre-defined in the `wecopttool.geom` module, so we will call it directly from there. We will only model the heave degree of freedom in this case. Note that the Capytaine `from_meshio` method can also import from other file types (STL, VTK, MSH, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wb = wot.geom.WaveBot()  # use standard dimensions\n",
    "mesh_size_factor = 0.5 # 1.0 for default, smaller to refine mesh\n",
    "mesh = wb.mesh(mesh_size_factor)\n",
    "fb = cpy.FloatingBody.from_meshio(mesh, name=\"WaveBot\")\n",
    "fb.add_translation_dof(name=\"Heave\")\n",
    "ndof = fb.nb_dofs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point we can visualize the mesh for inspection.\n",
    "Capytaine has built-in methods for visualizing meshes (`fb.show`, and `fb.show_matplotlib`). \n",
    "When running outside a Notebook, these are interactive.  \n",
    "The included WaveBot example also has a method for plotting the cross-section of the device. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fb.show_matplotlib()\n",
    "_ = wb.plot_cross_section(show=True)  # specific to WaveBot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Frequency and mesh check\n",
    "We will analyze 50 frequencies with a spacing of 0.05 Hz. These frequencies will be used for the Fourier representation of both the wave and the desired PTO force in the pseudo-spectral problem. See the Theory section of the Documentation for more details on the pseudo-spectral problem formulation.\n",
    "\n",
    "The `fb.minimal_computable_wavelength` parameter checks the mesh to determine the minimum wavelength that can be reliably computed using Capytaine. This warning is ignored here because the BEM results have been validated, but can be used as a guide for mesh refinement to ensure accurate BEM results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f1 = 0.05\n",
    "nfreq = 50\n",
    "freq = wot.frequency(f1, nfreq, False) # False -> no zero frequency\n",
    "\n",
    "min_computable_wavelength = fb.minimal_computable_wavelength\n",
    "g = 9.81\n",
    "min_period = 1/(f1*nfreq)\n",
    "min_wavelength = (g*(min_period)**2)/(2*np.pi)\n",
    "\n",
    "if min_wavelength < min_computable_wavelength:\n",
    "    print(f'Warning: Minimum wavelength in frequency spectrum ({min_wavelength}) is smaller'\n",
    "         f' than the minimum computable wavelength ({min_computable_wavelength}).')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BEM\n",
    "With our Capytaine floating body created, we can now run the Boundary Element Method solver in Capytaine to get the hydrostatic and hydrodynamic coefficients of our WEC object. This is wrapped into the `wecopttool.run_bem` function.\n",
    "\n",
    "If you would like to save our BEM data to a NetCDF file for future use, see the `wecopttool.write_netcdf` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bem_data = wot.run_bem(fb, freq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PTO\n",
    "WecOptTool includes the `PTO` class to encompass all properties of the power take-off system of the WEC. Data wrapped into our `PTO` class will be used to help define our `WEC` object and optimization problem later.\n",
    "\n",
    "To create an instance of the `PTO` class, we need:\n",
    "- The kinematics matrix, which converts from the WEC degrees of freedom to the PTO degrees of freedom. The PTO extracts power directly from the WEC's heave in this case, so the kinematics matrix is simply the $1 \\times 1$ identity matrix.\n",
    "- The definition of the PTO controller. The `wecopttool.pto` submodule includes P, PI, and PID controller functions that can be provided to the `PTO` class and return the PTO force. However, we will be using an unstructured controller in this case, so we will set `None` for the controller.\n",
    "- Any PTO impedance. We're only interested in mechanical power for this first problem, so we will leave this empty for now\n",
    "- The non-linear power conversion loss (assumed 0% if `None`)\n",
    "- The PTO system name, if desired"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = [\"PTO_Heave\",]\n",
    "kinematics = np.eye(ndof)\n",
    "controller = None\n",
    "loss = None\n",
    "pto_impedance = None\n",
    "pto = wot.pto.PTO(ndof, kinematics, controller, pto_impedance, loss, name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's define the PTO forcing on the WEC and the PTO constraints. For our optimization problem, the constraints must be in the correct format for `scipy.optimize.minimize()`. We will enforce the constraint at 4 times more points than the dynamics (see Theory for why this is helpful for the pseudo-spectral problem)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PTO dynamics forcing function\n",
    "f_add = {'PTO': pto.force_on_wec}\n",
    "\n",
    "# Constraint\n",
    "f_max = 2000.0\n",
    "nsubsteps = 4\n",
    "\n",
    "def const_f_pto(wec, x_wec, x_opt, waves): # Format for scipy.optimize.minimize\n",
    "    f = pto.force_on_wec(wec, x_wec, x_opt, waves, nsubsteps)\n",
    "    return f_max - np.abs(f.flatten())\n",
    "\n",
    "ineq_cons = {'type': 'ineq',\n",
    "             'fun': const_f_pto,\n",
    "             }\n",
    "constraints = [ineq_cons]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `WEC` creation\n",
    "We are now ready to create the `WEC` object itself! Since we ran our BEM already, we can define the object using the `wecopttool.WEC.from_bem` function. If we saved our BEM data to a NetCDF file, we can also provide the path to that file instead of specifying the BEM `Dataset` directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wec = wot.WEC.from_bem(\n",
    "    bem_data,\n",
    "    constraints=constraints,\n",
    "    friction=None,\n",
    "    f_add=f_add,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: We might receive a warning regarding negative linear damping values. Per default, WecOptTool ensures that the BEM data does not contain non-negative damping values. If you would like to correct the BEM solution manually to a minimum damping value you can specify `min_damping`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Waves\n",
    "The wave environment must be specified as a 2-dimensional `xarray.DataArray` containing the complex amplitude (m). \n",
    "The two coordinates are the radial frequency ``omega`` (rad/s)  and the direction ``wave_direction`` (rad). \n",
    "The `wecopttool.waves` submodule contains functions for creating this `xarray.DataArray` for different types of wave environments. \n",
    "\n",
    "In this case we will use a regular wave with a frequency of 0.3 Hz and an amplitude of 0.0625 m. \n",
    "We will use the `wecopttool.waves.regular_wave` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amplitude = 0.0625  \n",
    "wavefreq = 0.3\n",
    "phase = 30\n",
    "wavedir = 0\n",
    "waves = wot.waves.regular_wave(f1, nfreq, wavefreq, amplitude, phase, wavedir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objective function\n",
    "The objective function is the quantity (scalar) we want to optimize—in this case, the average mechanical power. The objective function is itself a function of the optimization state, the size of which we need to properly define our call to `scipy.optimize.minimize()`. The average mechanical power can be taken directly from the `PTO` object we created.\n",
    "\n",
    "One technical quirk here: `nstate_opt` is one smaller than would be expected for a state space representing the mean (DC) component and the real and imaginary Fourier coefficients. This is because WecOptTool excludes the imaginary Fourier component of the highest frequency (the 2-point wave). Since the 2-point wave is sampled at multiples of $\\pi$, the imaginary component is evaluated as $sin(n\\pi); n = 0, 1, 2, ..., n_{freq}$, which is always zero. Excluding this component speeds up the optimization as the state space is reduced by one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_fun = pto.mechanical_average_power\n",
    "nstate_opt = 2*nfreq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solve\n",
    "We are now ready to solve the problem. WecOptTool uses `scipy.optimize.minimize` as its optimization driver, which is wrapped into `wecopttool.WEC.solve` for ease of use.\n",
    "\n",
    "Note that the only required inputs for defining and solving the problem are: (1) the waves, (2) the objective function, and (3) the size of the optimization state. Optional inputs can be provided to control the optimization execution if desired, which we do here to change the default iteration maximum and tolerance. See `scipy.optimize.minimize` docs for more details.\n",
    "\n",
    "To help the optimization we will scale the problem before solving it (see Documentation). WecOptTool allows you to scale the WEC dynamics state, your optimization state (in this case the Fourier coefficients for the PTO force), and the objective function separately. See the `wecopttool.WEC.solve()` function for more information.\n",
    "\n",
    "\n",
    "Pay attention to the `Exit mode`: an exit mode of $0$ indicates a successful solution. For an easy problem (linear, single Dof, unconstrained, etc.) your iterations shouldn't need to exceed 100. If they do, try adjusting the scales by orders of magnitude, one at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = {'maxiter': 200}\n",
    "scale_x_wec = 1e1\n",
    "scale_x_opt = 1e-3\n",
    "scale_obj = 1e-2\n",
    "\n",
    "results = wec.solve(\n",
    "    waves, \n",
    "    obj_fun, \n",
    "    nstate_opt,\n",
    "    optim_options=options, \n",
    "    scale_x_wec=scale_x_wec,\n",
    "    scale_x_opt=scale_x_opt,\n",
    "    scale_obj=scale_obj,\n",
    "    )\n",
    "\n",
    "opt_mechanical_average_power = results[0].fun\n",
    "print(f'Optimal average mechanical power: {opt_mechanical_average_power} W')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyzing results\n",
    "We will use two post-processing functions to obtain frequency- and time-domain results for the WEC and PTO responses. The pseudospectral method gives continuous in time results. To get smoother looking plots, we specify the number of subpoints betweeen co-location points. In this case we will use 5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nsubsteps = 5\n",
    "pto_fdom, pto_tdom = pto.post_process(wec, results[0], waves.sel(realization=0), nsubsteps=nsubsteps)\n",
    "wec_fdom, wec_tdom = wec.post_process(results[0], waves.sel(realization=0), nsubsteps=nsubsteps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `pto.post_process` function returns `xarray.Dataset`s, which have built-in integration with PyPlot for smart plotting that automagically sets titles and formatting. We will plot the mechanical power (`mech_power`), position (`pos`), and the PTO force (`force`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "pto_tdom['power'].loc['mech',:,:].plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could similarly plot any time- or frequency-domain repsonse of the WEC or PTO. For instance, here is the PTO heave motion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "wec_tdom['pos'].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "pto_tdom['force'].plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there are other dynamic responses available in the post-processed WEC and PTO variables (`wec_tdom`, `pto_tdom`, `wec_fdom`, `pto_fdom`). For example, the time domain PTO variable contains the following response:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pto_tdom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Optimal control for maximum electrical power\n",
    "\n",
    "The rest of this tutorial will focus on optimizing for electrical power (new objective function) rather than mechanical, as this is a form of power that is usable and transportable.\n",
    "\n",
    "Since we're still dealing with the same WaveBot as in part 1, we can reuse the BEM and wave data from before. Look back at part 1 if you need a refresher on how to create these data.\n",
    "\n",
    "<div>\n",
    "<img src=\"https://live.staticflickr.com/65535/52435033525_b8efc28d16_k.jpg\" width=\"1000\">\n",
    "</div>\n",
    "The WEC-PTO kinematics remain the same as well (unity). The major difference now is that we consider the dynamics of PTO, since they impact the electrical power and we shall not assume a lossless PTO.\n",
    "\n",
    "We will express the PTO's dynamics in form of a 2-port impedance model, to incoporate the dynamics of the drive-train and the dynamics of the generator.\n",
    "The additional mechanical energy storage through the drive-train is modelled using Newton's second law and we assume a linear generator using a power-invariant park transform.\n",
    "\n",
    "The PTO impedance matrix components are then obtained under open-circuit  conditions, i.e.  no  load  current  or  no  WEC  velocity,  respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## PTO impedance definition\n",
    "omega = bem_data.omega.values\n",
    "gear_ratio = 12.0\n",
    "torque_constant = 6.7\n",
    "winding_resistance = 0.5\n",
    "winding_inductance = 0.0\n",
    "drivetrain_inertia = 2.0\n",
    "drivetrain_friction = 1.0\n",
    "drivetrain_stiffness = 0.0\n",
    "\n",
    "drivetrain_impedance = (1j*omega*drivetrain_inertia + \n",
    "                        drivetrain_friction + \n",
    "                        1/(1j*omega)*drivetrain_stiffness) \n",
    "\n",
    "winding_impedance = winding_resistance + 1j*omega*winding_inductance\n",
    "\n",
    "\n",
    "pto_impedance_11 = -1* gear_ratio**2 * drivetrain_impedance\n",
    "off_diag = np.sqrt(3.0/2.0) * torque_constant * gear_ratio\n",
    "pto_impedance_12 = -1*(off_diag+0j) * np.ones(omega.shape) \n",
    "pto_impedance_21 = -1*(off_diag+0j) * np.ones(omega.shape)\n",
    "pto_impedance_22 = winding_impedance\n",
    "pto_impedance_2 = np.array([[pto_impedance_11, pto_impedance_12],\n",
    "                            [pto_impedance_21, pto_impedance_22]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will create a new `PTO` object with this impedance matrix. We will also update the definitions of our PTO constraint and additional dynamic forcing function to use the new object. We will set our PTO constraint to $600 N$ for this example, since the dynamics for optimal electrical power will be different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Update PTO\n",
    "name_2 = ['PTO_Heave_Ex2']\n",
    "pto_2 = wot.pto.PTO(ndof, kinematics, controller, pto_impedance_2, loss, name_2)\n",
    "\n",
    "## Update PTO constraints and forcing\n",
    "f_max_2 = 600.0\n",
    "def const_f_pto_2(wec, x_wec, x_opt, waves):\n",
    "    f = pto_2.force_on_wec(wec, x_wec, x_opt, waves, nsubsteps)\n",
    "    return f_max_2 - np.abs(f.flatten())\n",
    "ineq_cons_2 = {'type': 'ineq', 'fun': const_f_pto_2}\n",
    "constraints_2 = [ineq_cons_2]\n",
    "f_add_2 = {'PTO': pto_2.force_on_wec}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's update our `WEC` object with the new PTO constraint, then run our optimization problem. Note we're now using `average_power` instead of `mechanical_average_power` as our objective function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update WEC\n",
    "\n",
    "wec_2 = wot.WEC.from_bem(bem_data,\n",
    "                         constraints=constraints_2,\n",
    "                         friction=None,\n",
    "                         f_add=f_add_2\n",
    ")\n",
    "\n",
    "# Update objective function\n",
    "obj_fun_2 = pto_2.average_power\n",
    "\n",
    "# Solve\n",
    "scale_x_wec = 1e1  \n",
    "scale_x_opt = 1e-3  \n",
    "scale_obj = 1e-2  \n",
    "\n",
    "results_2 = wec_2.solve(\n",
    "    waves, \n",
    "    obj_fun_2, \n",
    "    nstate_opt, \n",
    "    scale_x_wec=scale_x_wec,\n",
    "    scale_x_opt=scale_x_opt,\n",
    "    scale_obj=scale_obj,\n",
    ")\n",
    "opt_average_power = results_2[0].fun\n",
    "print(f'Optimal average electrical power: {opt_average_power} W')\n",
    "\n",
    "# Post-process\n",
    "wec_fdom_2, wec_tdom_2 = wec_2.post_process(results_2[0], waves.sel(realization=0), nsubsteps)\n",
    "pto_fdom_2, pto_tdom_2 = pto_2.post_process(wec_2, results_2[0], waves.sel(realization=0), nsubsteps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will compare our optimal results to the unconstrained case to gain some insight into the effect of the constraint on the optimal PTO force. Let's do the same process as before, but unset the `constraints` parameter in a new `WEC` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wec_2_nocon = wot.WEC.from_bem(\n",
    "    bem_data,\n",
    "    constraints=None,\n",
    "    friction=None,\n",
    "    f_add=f_add_2)\n",
    "\n",
    "results_2_nocon = wec_2_nocon.solve(\n",
    "    waves,\n",
    "    obj_fun_2, \n",
    "    nstate_opt,\n",
    "    scale_x_wec=scale_x_wec,\n",
    "    scale_x_opt=scale_x_opt,\n",
    "    scale_obj=scale_obj,\n",
    ")\n",
    "opt_average_power = results_2_nocon[0].fun\n",
    "print(f'Optimal average electrical power: {opt_average_power} W')\n",
    "wec_fdom_2_nocon, wec_tdom_2_nocon = wec_2_nocon.post_process(\n",
    "    results_2_nocon[0], waves.sel(realization=0), nsubsteps)\n",
    "pto_fdom_2_nocon, pto_tdom_2_nocon = pto_2.post_process(\n",
    "    wec_2_nocon, results_2_nocon[0], waves.sel(realization=0), nsubsteps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the optimal constrained PTO force follows the optimal unconstrained solution (sinusoidal) whenever the unconstrained solution is within the constraint. \n",
    "When the constraint is active the optimal PTO force is the maximum PTO force of $600 N$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "wec_tdom_2['pos'].plot(label='constrained')\n",
    "wec_tdom_2_nocon['pos'].plot(label='unconstrained')\n",
    "plt.legend(loc='lower right')\n",
    "\n",
    "plt.figure()\n",
    "pto_tdom_2['force'].plot(label='constrained')\n",
    "pto_tdom_2_nocon['force'].plot(label='unconstrained')\n",
    "plt.legend(loc='lower right')\n",
    "\n",
    "plt.figure()\n",
    "pto_tdom_2['power'].loc['elec',:,:].plot(label='constrained')\n",
    "pto_tdom_2_nocon['power'].loc['elec',:,:].plot(label='unconstrained')\n",
    "plt.legend(loc='lower right')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attentive user might have noticed that the amplitude of the position, force and power signals is about half the magnitude of the signals we plotted in the first part of the tutorial. We can see that optimizing for electrical power requires optimal state trajectories with smaller amplitudes. For most WECs the electrical power is the usable form of power, thus the WEC should be designed for electrical power and we can avoid over-designing, which would results from expecting the forces associated with the optimal trajectories for mechanical power maximisation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Control co-design of the WEC geometry for maximum electrical power\n",
    "The first two examples only used the inner optimization loop in WecOptTool to optimize PTO power. Here in Part 3 we bring it all together and show how to use both the inner and outer optimization loops in WecOptTool to do control co-optimization of a hull design in conjunction with an optimal controller for electrical power.\n",
    "Again, we use the WaveBot WEC in one degree of freedom in regular waves. \n",
    "The goal is to **find the optimal keel radius** (`r2`) that maximizes the average produced electrical power, while maintaining a constant hull volume. \n",
    "A constant volume is achieved by setting the height of the conical section (`h2`) in conjunction with the keel radius (`r2`).\n",
    "\n",
    "This example demonstrates a complete case of the types of optimization studies WecOptTool is meant for. \n",
    "The main optimization (outer optimization loop) is to find the optimal geometry (radius `r2`), and for each geometry considered the optimal PTO force (inner optimization loop) will be found.\n",
    "The inner loop was showcased in Example 2 and uses a gradient-based optimization method, with the gradients obtained with automatic differentiation. \n",
    "The outer loop optimization is for the user to setup. \n",
    "In this example, we will do a simple *brute force* optimization using `scipy.optimize.brute`.  \n",
    "\n",
    "![Device Diagram](https://live.staticflickr.com/65535/51751577441_515afec334_z.jpg) \n",
    "<div>\n",
    "<img src=\"https://live.staticflickr.com/65535/52434071157_187eb4334c_k.jpg\" width=\"1000\">\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem setup\n",
    "First, we define a function for `h2` based on `r1` that maintains a constant volume. \n",
    "We see that, as expected, smaller values of `r2` require larger values of `h2` in order to maintain a constant hull volume."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r1 = 0.88\n",
    "r2_0 = 0.35\n",
    "h2_0 = 0.37\n",
    "V0 = 1/3*np.pi*h2_0*(r1**2+r2_0**2+(r1*r2_0))\n",
    "\n",
    "r2_vals = np.linspace(0.05, 0.88*0.999, 8, endpoint=True)\n",
    "\n",
    "\n",
    "def h2_from_r2(r2, V=V0, r1=r1):\n",
    "    h2 = V/(1/3*np.pi*(r1**2+r2**2+(r1*r2)))\n",
    "    return h2\n",
    "\n",
    "\n",
    "# plot\n",
    "mapres = map(h2_from_r2, r2_vals)\n",
    "h2_vals = list(mapres)\n",
    "\n",
    "fig1, ax1 = plt.subplots(figsize=(8,5))\n",
    "for r2, h2 in zip(r2_vals.tolist(), h2_vals):\n",
    "    _ = wot.geom.WaveBot(r2=r2, h2=h2, freeboard=0.2).plot_cross_section(\n",
    "        ax=ax1, label=f\"r2={r2:.2f}, h2={h2:.2f}\")\n",
    "ax1.legend(loc='best', fontsize='small',ncol=2)\n",
    "_ = ax1.set_title('WaveBot hull cross-sections')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will define an objective function for our design optimization problem. We use the same workflow illustrated in Part 2 to set up a WaveBot device and solve for the optimal solution, but wrap this in a function definition which can set `r2` and (indirectly) `h2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def design_obj_fun(x):\n",
    "\n",
    "    # Unpack geometry variables\n",
    "    r2 = x[0]\n",
    "    h2 = h2_from_r2(r2)\n",
    "    print(f\"\\nr2 = {r2:.2f}:\")\n",
    "\n",
    "    # Set up Capytaine floating body\n",
    "    wb = wot.geom.WaveBot(r2=r2, h2=h2)\n",
    "    mesh = wb.mesh(mesh_size_factor=0.5)\n",
    "    fb = cpy.FloatingBody.from_meshio(mesh, name=\"WaveBot\")\n",
    "    fb.add_translation_dof(name=\"Heave\")\n",
    "    ndof = fb.nb_dofs\n",
    "\n",
    "    # Run BEM\n",
    "    f1 = 0.05\n",
    "    nfreq = 50\n",
    "    bem_data = wot.run_bem(fb, freq)\n",
    "\n",
    "    # Impedance definition\n",
    "    omega = bem_data.omega.values\n",
    "    gear_ratio = 12.0\n",
    "    torque_constant = 6.7\n",
    "    winding_resistance = 0.5\n",
    "    winding_inductance = 0.0\n",
    "    drivetrain_inertia = 2.0\n",
    "    drivetrain_friction = 1.0\n",
    "    drivetrain_stiffness = 0.0\n",
    "\n",
    "    drivetrain_impedance = (1j*omega*drivetrain_inertia + \n",
    "                            drivetrain_friction + \n",
    "                            1/(1j*omega)*drivetrain_stiffness) \n",
    "\n",
    "    winding_impedance = winding_resistance + 1j*omega*winding_inductance\n",
    "\n",
    "\n",
    "    pto_impedance_11 = -1* gear_ratio**2 * drivetrain_impedance\n",
    "    off_diag = np.sqrt(3.0/2.0) * torque_constant * gear_ratio\n",
    "    pto_impedance_12 = -1*(off_diag+0j) * np.ones(omega.shape) \n",
    "    pto_impedance_21 = -1*(off_diag+0j) * np.ones(omega.shape)\n",
    "    pto_impedance_22 = winding_impedance\n",
    "    pto_impedance_3 = np.array([[pto_impedance_11, pto_impedance_12],\n",
    "                            [pto_impedance_21, pto_impedance_22]])\n",
    "\n",
    "    # Set PTO object\n",
    "    name = [\"PTO_Heave\",]\n",
    "    kinematics = np.eye(ndof)\n",
    "    efficiency = None\n",
    "    controller = None\n",
    "    pto = wot.pto.PTO(ndof, kinematics, controller, pto_impedance_3, efficiency, name)\n",
    "    \n",
    "\n",
    "    # Set PTO constraint and additional dynamic force\n",
    "    nsubsteps = 4\n",
    "    f_max = 600.0\n",
    "\n",
    "    def const_f_pto(wec, x_wec, x_opt, waves):\n",
    "        f = pto.force_on_wec(wec, x_wec, x_opt, waves, nsubsteps)\n",
    "        return f_max - np.abs(f.flatten())\n",
    "\n",
    "    ineq_cons = {'type': 'ineq', 'fun': const_f_pto}\n",
    "    constraints = [ineq_cons]\n",
    "\n",
    "    f_add = {'PTO': pto.force_on_wec}\n",
    "\n",
    "    # Create WEC\n",
    "    wec = wot.WEC.from_bem(bem_data,\n",
    "            constraints=constraints,\n",
    "            friction=None, \n",
    "            f_add=f_add,\n",
    "            )\n",
    "\n",
    "    # Waves\n",
    "    wfreq = 0.3\n",
    "    amplitude = 0.0625\n",
    "    phase = -40\n",
    "    waves_3 = wot.waves.regular_wave(f1, nfreq, wfreq, amplitude, phase)\n",
    "\n",
    "    # Objective function\n",
    "    obj_fun = pto.average_power\n",
    "    nstate_opt = 2*nfreq\n",
    "    \n",
    "    # Solve\n",
    "    scale_x_wec = 1e1  \n",
    "    scale_x_opt = 1e-3  \n",
    "    scale_obj = 1e-2  \n",
    "    res = wec.solve(\n",
    "        waves, \n",
    "        obj_fun, \n",
    "        nstate_opt, \n",
    "        scale_x_wec=scale_x_wec,\n",
    "        scale_x_opt=scale_x_opt,\n",
    "        scale_obj=scale_obj)\n",
    "\n",
    "    return res[0].fun"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solve\n",
    "Finally, we may call this objective function with an optimization algorithm. \n",
    "Here, a simple *brute force* optimization approach is used for illustrative purposes, but any variety of options could be applied. \n",
    "The optimization algorithm will call our objective function, which in turn will create a new WaveBot hull, run the necessary BEM calculations for the hull, and find the PTO force that provides the most electric power for that hull. \n",
    "This process will be conducted for the range of `r2` values that we specify.\n",
    "\n",
    "_(note: the cell below will likely take 5+ minutes to run on a standard personal computer)_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wot.set_loglevel(\"error\")  # Suppress warnings\n",
    "\n",
    "# range over which to search\n",
    "ranges = (slice(r2_vals[0], r2_vals[-1]+np.diff(r2_vals)[0], np.diff(r2_vals)[0]),)\n",
    "\n",
    "# solve\n",
    "opt_x0, opt_fval, x0s, fvals = brute(func=design_obj_fun, ranges=ranges, full_output=True,  finish=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "From a quick plot of the results, we see that the power absorption (where negative power is power absorbed by the device) generally improves for smaller values of `r2`.\n",
    "It is also clear that when the WEC is cylindrical (where `r2=0.88`), power absorption is reduced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "colors = plt.rcParams['axes.prop_cycle'].by_key()['color'][:len(x0s)]\n",
    "ax.plot(x0s, fvals, 'k', zorder=0)\n",
    "ax.scatter(x0s, fvals, c=colors, zorder=1)\n",
    "\n",
    "ax.set_xlabel('Keel radius, $r_2$ [m]')\n",
    "ax.set_ylabel('Average Power [W]')\n",
    "ax.set_title('Design optimization results')\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in this case the magnitude of average power between the different keel radii is rather small, this is because the PTO force constraint is active most of the time, therefore all considered geometries perform similarily. If you remove the PTO constraint and re-run the co-optimization study you will see that the impact of radius on average electrical power is significantly higher."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "wot_dev",
   "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"
  },
  "vscode": {
   "interpreter": {
    "hash": "a3e13d9eb6391ec8c830b5b864d7e2cac256aef786c5e95ba02dc5258710976f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}