diff --git a/examples/FOSWEC.mp4 b/examples/FOSWEC.mp4 new file mode 100644 index 00000000..17f6731a Binary files /dev/null and b/examples/FOSWEC.mp4 differ diff --git a/examples/data/FOSWEC_bem_0.53draft.nc b/examples/data/FOSWEC_bem_0.53draft.nc new file mode 100644 index 00000000..e981a5fd Binary files /dev/null and b/examples/data/FOSWEC_bem_0.53draft.nc differ diff --git a/examples/data/FOSWEC_bem_0.56draft.nc b/examples/data/FOSWEC_bem_0.56draft.nc new file mode 100644 index 00000000..d1719914 Binary files /dev/null and b/examples/data/FOSWEC_bem_0.56draft.nc differ diff --git a/examples/data/FOSWEC_bem_0.5draft.nc b/examples/data/FOSWEC_bem_0.5draft.nc new file mode 100644 index 00000000..0fc8f53d Binary files /dev/null and b/examples/data/FOSWEC_bem_0.5draft.nc differ diff --git a/examples/data/FOSWEC_empirical_data.nc b/examples/data/FOSWEC_empirical_data.nc new file mode 100644 index 00000000..9dd1fead Binary files /dev/null and b/examples/data/FOSWEC_empirical_data.nc differ diff --git a/examples/data/FOSWEC_ramps.nc b/examples/data/FOSWEC_ramps.nc new file mode 100644 index 00000000..8a3452bf Binary files /dev/null and b/examples/data/FOSWEC_ramps.nc differ diff --git a/examples/tutorial_5_FOSWEC.ipynb b/examples/tutorial_5_FOSWEC.ipynb new file mode 100644 index 00000000..09bb3e0a --- /dev/null +++ b/examples/tutorial_5_FOSWEC.ipynb @@ -0,0 +1,3012 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial 5 - FOSWEC\n", + "The goal of this tutorial is to show a design problem for a bottom-hinged oscillating-surge WEC.\n", + "The WEC in this tutorial is a single, fixed-bottom flap of the floating oscillating-surge WEC (FOSWEC).\n", + "\n", + "* SAND report: https://doi.org/10.2172/1717884\n", + "* Journal paper: https://doi.org/10.1016/j.energy.2021.122485\n", + "* YouTube video: https://youtu.be/OUxbaEC2K6Y\n", + "\n", + "This tutorial introduces..." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "import autograd.numpy as np\n", + "import capytaine as cpy\n", + "from capytaine.io.meshio import load_from_meshio\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import brute\n", + "import pygmsh\n", + "import gmsh\n", + "import xarray as xr\n", + "\n", + "import wecopttool as wot\n", + "\n", + "## set colorblind-friendly colormap for plots\n", + "plt.style.use('tableau-colorblind10')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experimental validation\n", + "During the testing campaign for the FOSWEC, a number of trials were run while providing white noise inputs to the generator at the hinge of each flap.\n", + "The base of the FOSWEC was kept fixed for these tests.\n", + "The white noise inputs and the WEC reponse allowed for the understanding of the excitation and the impedance associated with the aft and bow flaps.\n", + "To establish a reliable model, a fixed FOSWEC is modeled below and compared to the impedance from the experiment." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Load Impedance\n", + "First, we can load in the impedance data which has been calculated based on the white noise runs." + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [], + "source": [ + "datafile = 'data/FOSWEC_empirical_data.nc'\n", + "empirical_data = xr.load_dataset(datafile)\n", + "\n", + "f_vec_exp = empirical_data['omega']/(2*np.pi)\n", + "Zi_data_exp = empirical_data.Zi_data_real + 1j*empirical_data.Zi_data_imag" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Hydrostatic stiffness\n", + "Among the experiments completed in the wave tank included gradually ramping up the torque applied by the generator to determine the relationship between torque on the flap and the resultant position.\n", + "These tests were performed without any wave conditions.\n", + "The relationship between the torque and position of the flap reveals the hydrostatic stiffness.\n", + "The experiments were performed on one flap but the hydrostatic stiffness should be the same for both because they are identical.\n", + "We do it linearly here, but nonlinearly later...." + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Torque (Nm)')" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# load in data from ramps experiments\n", + "datafile = 'data/FOSWEC_ramps.nc'\n", + "ramps_data = xr.load_dataset(datafile)\n", + "\n", + "# fit a linear curve\n", + "coefficients = np.polyfit(ramps_data['position'], ramps_data['torque'], 1)\n", + "pos_fitted = np.linspace(-1,1,100)\n", + "torque_fitted = np.polyval(coefficients, pos_fitted)\n", + "\n", + "plt.figure(figsize=(4,3))\n", + "plt.plot(ramps_data['position'], ramps_data['torque'],'.')\n", + "plt.plot(pos_fitted,torque_fitted,'-')\n", + "plt.text(-0.8, -50, f'slope = {round(coefficients[0],2)}')\n", + "plt.xlabel('Rotation (rad)')\n", + "plt.ylabel('Torque (Nm)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### FOSWEC Geometry\n", + "The FOSWEC geometry is intended to be the same as from the experiments. \n", + "Inputs to the function used to create the FOSWEC FloatingBody are the draft (uncertain from experiments) and hydrostatic coefficient (from ramps data above).\n", + "By testing a few values for the flap draft and comparing to the impedance data, we can determine a draft value which achieves a good match between the BEM data and empirical impedance." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "def fixed_FOSWEC(draft, hs_coeff):\n", + "\n", + " # parameters from experiments\n", + " flap_height = 0.58 \n", + " flap_draft = draft\n", + " flap_freeboard = flap_height - flap_draft\n", + " flap_width = 0.76\n", + " flap_thickness_bottom = 0.05\n", + " flap_thickness_top = 0.12\n", + " hinge_location = -flap_draft - .046\n", + " mass = 23.1\n", + " pitch_inertia_about_cg = 1.19\n", + " z_cg_from_bottom = 0.17\n", + " z_cg = -flap_draft + z_cg_from_bottom\n", + " distance_between_flaps = 1.28\n", + "\n", + " mesh_size_factor = 0.2 # appropriate mesh size to avoid frequency spikes\n", + "\n", + " # mesh 1st flap\n", + " with pygmsh.geo.Geometry() as geom:\n", + " gmsh.option.setNumber('Mesh.MeshSizeFactor', mesh_size_factor)\n", + " flap_poly = geom.add_polygon(\n", + " [[-flap_thickness_bottom/2, -flap_width/2, -flap_draft],\n", + " [flap_thickness_bottom/2, -flap_width/2, -flap_draft],\n", + " [flap_thickness_top/2, -flap_width/2, flap_freeboard],\n", + " [-flap_thickness_top/2, -flap_width/2, flap_freeboard]],mesh_size=mesh_size_factor)\n", + " geom.extrude(flap_poly,[0,flap_width,0])\n", + " flap_mesh = geom.generate_mesh()\n", + "\n", + " # mesh 2nd flap\n", + " with pygmsh.geo.Geometry() as geom:\n", + " gmsh.option.setNumber('Mesh.MeshSizeFactor', mesh_size_factor)\n", + " flap_poly2 = geom.add_polygon(\n", + " [[-flap_thickness_bottom/2 + distance_between_flaps, -flap_width/2, -flap_draft],\n", + " [flap_thickness_bottom/2 + distance_between_flaps, -flap_width/2, -flap_draft],\n", + " [flap_thickness_top/2 + distance_between_flaps, -flap_width/2, flap_freeboard],\n", + " [-flap_thickness_top/2 + distance_between_flaps, -flap_width/2, flap_freeboard]],mesh_size=mesh_size_factor)\n", + " geom.extrude(flap_poly2,[0,flap_width,0])\n", + " flap_mesh2 = geom.generate_mesh()\n", + "\n", + " # add degrees of freedom for rotation around bottom hinge\n", + " flap1_fb = cpy.FloatingBody(flap_mesh, name='flap_bow', center_of_mass=(0, 0, z_cg))\n", + " axis1 = cpy.Axis(vector=(0, 1, 0), point=(0, 0, hinge_location))\n", + " flap1_fb.add_rotation_dof(axis = axis1, name=\"pitch_bow_hinge\") # used for BEM\n", + " flap1_fb.rotation_center = (0, 0, hinge_location) # rotation center hydrostatics if not defined manually\n", + " flap1_fb.keep_immersed_part() # keep immersed part should be run on each body separately before combining!\n", + "\n", + " flap2_fb = cpy.FloatingBody(flap_mesh2, name='flap_aft', center_of_mass=(distance_between_flaps, 0, z_cg))\n", + " axis2 = cpy.Axis(vector=(0, 1, 0), point=(distance_between_flaps, 0, hinge_location))\n", + " flap2_fb.add_rotation_dof(axis = axis2, name=\"pitch_aft_hinge\")\n", + " flap2_fb.rotation_center = (distance_between_flaps, 0, hinge_location)\n", + " flap2_fb.keep_immersed_part() \n", + "\n", + " foswec_fb = flap1_fb + flap2_fb\n", + "\n", + " # use parallel axis theorem to move inertia to base\n", + " pitch_inertia_about_base = pitch_inertia_about_cg + mass*(z_cg - hinge_location)\n", + " rigid_inertia_matrix_xr = xr.DataArray(data=np.diag([pitch_inertia_about_base, pitch_inertia_about_base]),\n", + " dims=['influenced_dof', 'radiating_dof'],\n", + " coords={'influenced_dof': list(foswec_fb.dofs),\n", + " 'radiating_dof': list(foswec_fb.dofs)},\n", + " name=\"inertia_matrix\")\n", + " foswec_fb.inertia_matrix = rigid_inertia_matrix_xr\n", + "\n", + " stiffness_matrix_xr = xr.DataArray(data=np.diag([np.squeeze(hs_coeff), np.squeeze(hs_coeff)]),\n", + " dims=['influenced_dof', 'radiating_dof'],\n", + " coords={'influenced_dof': list(foswec_fb.dofs),\n", + " 'radiating_dof': list(foswec_fb.dofs)},\n", + " name=\"hydrostatic_stiffness\")\n", + " foswec_fb.hydrostatic_stiffness = stiffness_matrix_xr\n", + "\n", + " return foswec_fb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check Rotation\n", + "To make sure the flap is rotating about the correct point, we can use Capytaine's animation features.\n", + "Open the `FOSWEC.mp4` file to check that both flaps are rotating about their respective hinges." + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "foswec_fb = fixed_FOSWEC(0.53, -coefficients[0])\n", + "\n", + "# Create the animation\n", + "animation = foswec_fb.animate(motion={i: 0.5 for i in foswec_fb.dofs.keys()}, loop_duration=4.0)\n", + "animation.save('FOSWEC.mp4', nb_loops=4, camera_position=(-4, -4, 4), resolution=(800, 800))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tune Model Variables\n", + "While the model has been parameterized to the best of our ability, some uncertainty remains in terms of a couple variables:\n", + "\n", + "* draft - The flaps were close to fully immersed during the experiments, but the exact draft value was not measured.\n", + "* friction - Because the torque used to calculate the empirical impedance is the generator torque, friction from the mechanical drivetrain and generator are included in the resultant impedance.\n", + "\n", + "Ideally, these would have been discreetly measured during the experiments, but we can still use the measured impedance to determine relatively accurate valyes for the draft and friction.\n", + "Below, we plot the empirical impedance and the impedance derived from BEM while varying the draft and friction.\n", + "By comparing the impedance (rather than time-domain results), we can evaluate the hydrodynamics directly across a range of relevant frequencies.\n", + "While the plots below are a bit busy, there are a few valuable takeaways that are applicable to both flaps:\n", + "\n", + "- The draft primarily impacts the frequency at which the trough of impedance is found. This means that the draft changes the mechanical natural frequency of the flap. \n", + "- The friction primarily impacts the depth of the trough of impedance. This means the friction is changing the magnitude of the flap's response near the mechanical natural frequency.\n", + "\n", + "By comparing the BEM data to the empirical impedance data, it is clear that the following values provide a relatively accurate model for the fixed-bottom FOSWEC.\n", + "\n", + "* draft - 0.53 m\n", + "* friction - 12 Ns/rad" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-100.0, 100.0)" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draft_check = np.linspace(0.5, 0.56, 3) \n", + "friction_check = np.linspace(2, 22, 3)\n", + "\n", + "f1 = .01\n", + "nfreq = 100\n", + "freq = wot.frequency(f1, nfreq, False) # False -> no zero frequency\n", + "\n", + "fig, axes = wot.utilities.plot_bode_impedance(Zi_data_exp,'FOSWEC Intrinsic Impedance')\n", + "\n", + "labels = []\n", + "\n", + "for draft in draft_check:\n", + " foswec_fb = fixed_FOSWEC(draft, -coefficients[0])\n", + " #foswec_fb.show_matplotlib()\n", + "\n", + " filename = f'data/FOSWEC_bem_{round(draft,2)}draft.nc'\n", + " try:\n", + " bem_data = wot.read_netcdf(filename)\n", + " except:\n", + " bem_data = wot.run_bem(foswec_fb, freq)\n", + " wot.write_netcdf(filename, bem_data)\n", + "\n", + " for friction in friction_check:\n", + " friction_mat = friction*np.diag((2,2))\n", + " hd = wot.add_linear_friction(bem_data, friction = friction_mat) \n", + " hd = wot.check_radiation_damping(hd)\n", + " Zi_bem = wot.hydrodynamic_impedance(hd)\n", + " fig, axes = wot.utilities.plot_bode_impedance(Zi_bem, 'FOSWEC Intrinsic Impedance', fig_axes=[fig, axes])\n", + " \n", + " labels.append(f'BEM: draft={draft} m, friction={friction:.0f} Ns/rad')\n", + "\n", + "fig.set_size_inches(10, 10)\n", + "fig.legend(np.append('Empirical Data',labels), bbox_to_anchor=(1.3, 0.96))\n", + "axes[0,0].set_xlim([0.05,1])\n", + "axes[1,0].set_ylim([-100, 100])\n", + "axes[3,1].set_ylim([-100, 100])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single Flap Design Study\n", + "Because the hydrodynamics are so similar between both flaps of the FOSWEC (as evidenced by impedance plots above), we can simplify the design study to consider just one flap.\n", + "Results from the study should be applicable to both flaps. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Wave Conditions\n", + "Here, we define the wave conditions to select a proper frequency vector.\n", + "Because this study is only for regular waves, the fundamental frequency can be equal to the wave frequency and we only need about 12 frequencies total to capture all nonlinearities." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "period = 8 # s\n", + "wavefreq = 1/period # Hz\n", + "amplitude = 1 # m\n", + "phase = 0 # degrees\n", + "wavedir = 0 # degrees\n", + "\n", + "f1 = wavefreq\n", + "nfreq = 12\n", + "\n", + "waves = wot.waves.regular_wave(f1, nfreq, wavefreq, amplitude, phase, wavedir)\n", + "freq = wot.frequency(f1, nfreq, False) # False -> no zero frequency" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Design Loop\n", + "The design loop here includes the tuned variables from above (draft and friction) as well as the center of gravity vertical location and rated generator power.\n", + "This enables a study which considers the impacts of changing the center of gravity of the flap (without altering the total mass) and using generators with different power ratings." + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [], + "source": [ + "def one_flap_FOSWEC(draft, hs_coeff, z_cg_from_bottom, rated_power):\n", + "\n", + " # parameters from experiments\n", + " flap_height = 0.58 \n", + " flap_draft = draft\n", + " flap_freeboard = flap_height - flap_draft\n", + " flap_width = 0.76\n", + " flap_thickness_bottom = 0.05\n", + " flap_thickness_top = 0.12\n", + " hinge_location = -flap_draft - .046\n", + " mass = 23.1\n", + " pitch_inertia_about_cg = 1.19\n", + " z_cg_from_bottom = z_cg_from_bottom\n", + " z_cg = -flap_draft + z_cg_from_bottom\n", + "\n", + " mesh_size_factor = 0.2 # appropriate mesh size to avoid frequency spikes\n", + "\n", + " # mesh 1st flap\n", + " with pygmsh.geo.Geometry() as geom:\n", + " gmsh.option.setNumber('Mesh.MeshSizeFactor', mesh_size_factor)\n", + " flap_poly = geom.add_polygon(\n", + " [[-flap_thickness_bottom/2, -flap_width/2, -flap_draft],\n", + " [flap_thickness_bottom/2, -flap_width/2, -flap_draft],\n", + " [flap_thickness_top/2, -flap_width/2, flap_freeboard],\n", + " [-flap_thickness_top/2, -flap_width/2, flap_freeboard]],mesh_size=mesh_size_factor)\n", + " geom.extrude(flap_poly,[0,flap_width,0])\n", + " flap_mesh = geom.generate_mesh()\n", + "\n", + " # add degrees of freedom for rotation around bottom hinge\n", + " flap_fb = cpy.FloatingBody(flap_mesh, name='flap_bow', center_of_mass=(0, 0, z_cg))\n", + " axis = cpy.Axis(vector=(0, 1, 0), point=(0, 0, hinge_location))\n", + " flap_fb.add_rotation_dof(axis = axis, name=\"pitch_bow_hinge\") # used for BEM\n", + " flap_fb.rotation_center = (0, 0, hinge_location) # rotation center hydrostatics if not defined manually\n", + " flap_fb.keep_immersed_part()\n", + "\n", + " # use parallel axis theorem to move inertia to base\n", + " pitch_inertia_about_base = pitch_inertia_about_cg + mass*(z_cg - hinge_location)\n", + " rigid_inertia_matrix_xr = xr.DataArray(data=pitch_inertia_about_base,\n", + " dims=['influenced_dof', 'radiating_dof'],\n", + " coords={'influenced_dof': list(flap_fb.dofs),\n", + " 'radiating_dof': list(flap_fb.dofs)},\n", + " name=\"inertia_matrix\")\n", + " flap_fb.inertia_matrix = rigid_inertia_matrix_xr\n", + "\n", + " stiffness_matrix_xr = xr.DataArray(data=hs_coeff,\n", + " dims=['influenced_dof', 'radiating_dof'],\n", + " coords={'influenced_dof': list(flap_fb.dofs),\n", + " 'radiating_dof': list(flap_fb.dofs)},\n", + " name=\"hydrostatic_stiffness\")\n", + " flap_fb.hydrostatic_stiffness = stiffness_matrix_xr\n", + "\n", + " bem_data = wot.run_bem(flap_fb, freq) ## PTO impedance definition\n", + " omega = bem_data.omega.values\n", + " gear_ratio = 3.75\n", + " torque_constant = 6.7\n", + " winding_resistance = 0.5\n", + " winding_inductance = 0\n", + " drivetrain_inertia = 0\n", + " drivetrain_friction = 0\n", + " drivetrain_stiffness = 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 = np.array([[pto_impedance_11, pto_impedance_12],\n", + " [pto_impedance_21, pto_impedance_22]])\n", + "\n", + " ## Update PTO\n", + " name = ['PTO_Pitch']\n", + " kinematics = np.eye(1)\n", + " pto_ndof = 1\n", + " controller = None # unstructured controller\n", + " loss = None\n", + " pto = wot.pto.PTO(pto_ndof, kinematics, controller, pto_impedance, loss, name)\n", + "\n", + " # PTO dynamics forcing function\n", + " f_add = {'PTO': pto.force_on_wec}\n", + "\n", + " # Constraint\n", + " pos_max = 25*np.pi/180\n", + " rms_max = rated_power\n", + " nsubsteps = 4\n", + "\n", + " def const_pos_pto(wec, x_wec, x_opt, waves):\n", + " pos = pto.position(wec, x_wec, x_opt, waves, nsubsteps) # computed pto position is the same as wec position\n", + " return pos_max - np.abs(pos.flatten())\n", + "\n", + " def const_rms_power_pto(wec, x_wec, x_opt, waves):\n", + " power = pto.power(wec, x_wec, x_opt, waves, nsubsteps)\n", + " return rms_max - np.sqrt(np.mean(power**2))\n", + "\n", + " constraints = [{'type': 'ineq', 'fun': const_pos_pto}, {'type': 'ineq', 'fun': const_rms_power_pto}] \n", + "\n", + " wec = wot.WEC.from_bem(bem_data,\n", + " constraints=constraints,\n", + " friction=12*np.eye(1), # tuned variable\n", + " f_add=f_add,)\n", + "\n", + " return wec, pto" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:wecopttool.core:center_of_mass already defined as [ 0. 0. -0.49].\n" + ] + }, + { + "data": { + "text/html": [ + "
[14:49:42] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m[14:49:42]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m. \u001b[1;36m0\u001b[0m. \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n" + ] + }, + { + "data": { + "text/html": [ + "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n" + ], + "text/plain": [ + "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n", + "\"ipywidgets\" for Jupyter support\n", + " warnings.warn('install \"ipywidgets\" for Jupyter support')\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.19200073911391302\n",
+      "            Iterations: 61\n",
+      "            Function evaluations: 62\n",
+      "            Gradient evaluations: 61\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:49:58] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:49:58]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.3845026763084878\n",
+      "            Iterations: 72\n",
+      "            Function evaluations: 73\n",
+      "            Gradient evaluations: 72\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:50:14] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:50:14]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.5608842787565614\n",
+      "            Iterations: 50\n",
+      "            Function evaluations: 51\n",
+      "            Gradient evaluations: 50\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:50:27] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:50:27]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.6609714872765836\n",
+      "            Iterations: 46\n",
+      "            Function evaluations: 47\n",
+      "            Gradient evaluations: 46\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:50:40] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:50:40]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.716017086942256\n",
+      "            Iterations: 35\n",
+      "            Function evaluations: 36\n",
+      "            Gradient evaluations: 35\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:50:52] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:50:52]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7270501383083127\n",
+      "            Iterations: 34\n",
+      "            Function evaluations: 35\n",
+      "            Gradient evaluations: 34\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:51:04] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:51:04]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7270499658131816\n",
+      "            Iterations: 35\n",
+      "            Function evaluations: 35\n",
+      "            Gradient evaluations: 35\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.49].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:51:15] WARNING  center_of_mass already defined as [ 0.    0.   -0.49].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:51:15]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.49\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7270538778018165\n",
+      "            Iterations: 37\n",
+      "            Function evaluations: 37\n",
+      "            Gradient evaluations: 37\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:51:28] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:51:28]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.19247189894001748\n",
+      "            Iterations: 80\n",
+      "            Function evaluations: 81\n",
+      "            Gradient evaluations: 80\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:51:45] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:51:45]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.38435546859115993\n",
+      "            Iterations: 174\n",
+      "            Function evaluations: 287\n",
+      "            Gradient evaluations: 174\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:52:14] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:52:14]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.5625963201573524\n",
+      "            Iterations: 60\n",
+      "            Function evaluations: 61\n",
+      "            Gradient evaluations: 60\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:52:29] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:52:29]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.6634521646957504\n",
+      "            Iterations: 39\n",
+      "            Function evaluations: 40\n",
+      "            Gradient evaluations: 39\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:52:42] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:52:42]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7181857607661226\n",
+      "            Iterations: 40\n",
+      "            Function evaluations: 40\n",
+      "            Gradient evaluations: 40\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:52:55] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:52:55]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.728442455977667\n",
+      "            Iterations: 37\n",
+      "            Function evaluations: 38\n",
+      "            Gradient evaluations: 37\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:53:07] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:53:07]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.72843797501101\n",
+      "            Iterations: 29\n",
+      "            Function evaluations: 30\n",
+      "            Gradient evaluations: 29\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.31].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:53:18] WARNING  center_of_mass already defined as [ 0.    0.   -0.31].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:53:18]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.31\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7284420264634917\n",
+      "            Iterations: 36\n",
+      "            Function evaluations: 36\n",
+      "            Gradient evaluations: 36\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:53:31] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:53:31]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.19242832026629658\n",
+      "            Iterations: 63\n",
+      "            Function evaluations: 64\n",
+      "            Gradient evaluations: 63\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:53:47] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:53:47]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.3851322771782544\n",
+      "            Iterations: 103\n",
+      "            Function evaluations: 111\n",
+      "            Gradient evaluations: 103\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:54:08] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:54:08]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.5640509089765183\n",
+      "            Iterations: 57\n",
+      "            Function evaluations: 58\n",
+      "            Gradient evaluations: 57\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:54:31] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:54:31]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.6656499468668335\n",
+      "            Iterations: 46\n",
+      "            Function evaluations: 47\n",
+      "            Gradient evaluations: 46\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:54:47] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:54:47]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.720024627096115\n",
+      "            Iterations: 36\n",
+      "            Function evaluations: 37\n",
+      "            Gradient evaluations: 36\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:55:02] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:55:02]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7295802311449843\n",
+      "            Iterations: 37\n",
+      "            Function evaluations: 37\n",
+      "            Gradient evaluations: 37\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:55:16] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:55:16]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7295805875348697\n",
+      "            Iterations: 36\n",
+      "            Function evaluations: 36\n",
+      "            Gradient evaluations: 36\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:center_of_mass already defined as [ 0.    0.   -0.13].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
[14:55:28] WARNING  center_of_mass already defined as [ 0.    0.   -0.13].                                         \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[14:55:28]\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m center_of_mass already defined as \u001b[1m[\u001b[0m \u001b[1;36m0\u001b[0m.    \u001b[1;36m0\u001b[0m.   \u001b[1;36m-0.13\u001b[0m\u001b[1m]\u001b[0m.                                         \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:wecopttool.core:rotation_center already defined as (0, 0, -0.5760000000000001).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
           WARNING  rotation_center already defined as (0, 0, -0.5760000000000001).                                \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m          \u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING \u001b[0m rotation_center already defined as \u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[1;36m0\u001b[0m, \u001b[1;36m-0.5760000000000001\u001b[0m\u001b[1m)\u001b[0m.                                \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\rich\\live.py:231: UserWarning: install \n",
+       "\"ipywidgets\" for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\jtgrasb\\AppData\\Local\\anaconda3\\envs\\wot_dev\\Lib\\site-packages\\wecopttool\\core.py:759: UserWarning: The `squeeze` kwarg to GroupBy is being removed.Pass .groupby(..., squeeze=False) to disable squeezing, which is the new default, and to silence this warning.\n",
+      "  for realization, wave in waves.groupby('realization'):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -0.7295801199240253\n",
+      "            Iterations: 36\n",
+      "            Function evaluations: 37\n",
+      "            Gradient evaluations: 36\n"
+     ]
+    }
+   ],
+   "source": [
+    "cg_vals = np.linspace(0.04,0.4,3) # distance above bottom\n",
+    "rms_vals = np.linspace(2,16,8)\n",
+    "\n",
+    "# Update objective function\n",
+    "nstate_opt = 2*nfreq\n",
+    "\n",
+    "# Solve\n",
+    "scale_x_wec = 1e1\n",
+    "scale_x_opt = 1e-1\n",
+    "scale_obj = 1e-1\n",
+    "\n",
+    "options = {'maxiter': 400}\n",
+    "\n",
+    "nsubsteps = 4\n",
+    "num_runs = len(cg_vals)*len(rms_vals)\n",
+    "results_data = xr.Dataset(data_vars=dict(elec_power=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals)))), \n",
+    "                                         capacity_factor=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals)))), \n",
+    "                                         max_pitch_flap=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals)))), \n",
+    "                                         max_torque_pto=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals)))), \n",
+    "                                         max_power=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals)))),\n",
+    "                                         cg_recorded=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals)))),\n",
+    "                                         rms_recorded=([\"cg\",\"rms\"], np.zeros((len(cg_vals),len(rms_vals),)))),  \n",
+    "                                         coords=dict(cgs=(\"cg\",cg_vals), rmss=(\"rms\",rms_vals)))\n",
+    "\n",
+    "for cg_ind, cg in enumerate(cg_vals):\n",
+    "    for rms_ind, rms in enumerate(rms_vals):\n",
+    "        wec, pto = one_flap_FOSWEC(0.53,-coefficients[0], cg,rms)\n",
+    "        obj_fun = pto.average_power\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",
+    "        results_data['cg_recorded'][cg_ind,rms_ind] = cg\n",
+    "        results_data['rms_recorded'][cg_ind,rms_ind] = rms\n",
+    "        results_data['elec_power'][cg_ind,rms_ind] = results[0].fun\n",
+    "        results_data['capacity_factor'][cg_ind,rms_ind] = -results[0].fun/rms\n",
+    "        \n",
+    "        wec_fdom, wec_tdom = wec.post_process(wec, results, waves, nsubsteps=nsubsteps)\n",
+    "        pto_fdom, pto_tdom = pto.post_process(wec, results, waves, nsubsteps=nsubsteps)\n",
+    "\n",
+    "        results_data['max_pitch_flap'][cg_ind,rms_ind] = max(wec_tdom[0]['pos'][0]).values\n",
+    "        results_data['max_torque_pto'][cg_ind,rms_ind] = max(pto_tdom[0]['force']).values.squeeze()\n",
+    "        results_data['max_power'][cg_ind,rms_ind] = max(pto_tdom[0]['power'].loc['elec',:,:]).values.squeeze()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ""
+      ]
+     },
+     "execution_count": 107,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "colors = plt.cm.Reds(np.linspace(0.3,1,len(results_data['cgs'])))\n",
+    "\n",
+    "plt.figure()\n",
+    "for ind, cg in enumerate(results_data['cgs']):\n",
+    "    results_cg = results_data.where(results_data.cgs == cg, drop=True)\n",
+    "\n",
+    "    plt.plot(results_cg['rmss'], results_cg['elec_power'].squeeze(),'x',label=f'cg = {np.round(cg.values,2)} m',alpha=0.8,color=colors[ind])\n",
+    "    plt.xlabel('RMS power (W)')\n",
+    "    plt.ylabel('Electrical power (W)')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.figure()\n",
+    "for ind, cg in enumerate(results_data['cgs']):\n",
+    "    results_cg = results_data.where(results_data.cgs == cg, drop=True)\n",
+    "\n",
+    "    plt.plot(results_cg['capacity_factor'].squeeze(), -results_cg['elec_power'].squeeze(),'x',label=f'cg = {np.round(cg.values,2)} m',alpha=0.8,color=colors[ind])\n",
+    "    plt.xlabel('Capacity Factor ()')\n",
+    "    plt.ylabel('Electrical power converted (W)')\n",
+    "plt.legend()"
+   ]
+  }
+ ],
+ "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}