results/plotting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting for Airfoil Parameterizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "from scipy.interpolate import interp1d, splev, splrep, UnivariateSpline\n",
    "from scipy.stats import norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PARSEC Parameterized Airfoil (Truncation optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parameters(object):\n",
    "    '''Parameters defining a PARSEC airfoil'''   \n",
    "    def __init__(self, x):\n",
    "\n",
    "        if x.size > 6:\n",
    "            print(\"5d np array expected\")\n",
    "\n",
    "        front_radius        = x[0]\n",
    "        x_cross_section     = x[1]\n",
    "        cross_section_width = x[2]\n",
    "        sides_curve         = x[3]\n",
    "        rear_angle          = x[4]\n",
    "        trunc               = 1\n",
    "        if x.size > 5:\n",
    "            trunc               = x[5]\n",
    "            \n",
    "\n",
    "        self.r_le       = front_radius              # Leading edge radius\n",
    "        self.X_up       = x_cross_section           # Upper crest location X coordinate\n",
    "        self.Z_up       = cross_section_width       # Upper crest location Z coordinate\n",
    "        self.Z_XX_up    = -sides_curve              # Upper crest location curvature\n",
    "        self.X_lo       = x_cross_section           # Lower crest location X coordinate\n",
    "        self.Z_lo       = -cross_section_width      # Lower crest location Z coordinate\n",
    "        self.Z_XX_lo    = sides_curve               # Lower crest location curvature\n",
    "        self.Z_te       = 0 # static                # Trailing edge Z coordinate\n",
    "        self.dZ_te      = 0 # static                # Trailing edge thickness\n",
    "        self.alpha_te   = 0 # static                # Trailing edge direction angle\n",
    "        self.beta_te    = rear_angle #(radians)     # Trailing edge wedge angle\n",
    "        self.P_mix      = 1.0                       # Blending parameter\n",
    "        self.trunc      = min(trunc,1)              # Where we truncate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coefficients(object):\n",
    "    '''\n",
    "    Credit for this class goes to\n",
    "    https://github.com/mbodmer/libairfoil\n",
    "    This class calculates the equation systems which define the coefficients\n",
    "    for the polynomials given by the parsec airfoil parameters.\n",
    "    '''\n",
    "    def __init__(self, parsec_params):\n",
    "        self.params = Parameters(parsec_params)\n",
    "        self._a_up = self._calc_a_up(self.params)\n",
    "        self._a_lo = self._calc_a_lo(self.params)\n",
    "    \n",
    "    def a_up(self):\n",
    "        '''Returns coefficient vector for upper surface'''\n",
    "        return self._a_up\n",
    "    \n",
    "    def a_lo(self):\n",
    "        '''Returns coefficient vector for lower surface'''\n",
    "        return self._a_lo\n",
    "    \n",
    "    def _calc_a_up(self, parsec_params):\n",
    "        Amat = self._prepare_linsys_Amat(parsec_params.X_up)\n",
    "        Bvec = np.array([parsec_params.Z_te, parsec_params.Z_up,\n",
    "                            math.tan(parsec_params.alpha_te - parsec_params.beta_te/2),\n",
    "                            0.0, parsec_params.Z_XX_up, math.sqrt(2*parsec_params.r_le)]) \n",
    "        return np.linalg.solve(Amat, Bvec)\n",
    "    \n",
    "    def _calc_a_lo(self, parsec_params):\n",
    "        Amat = self._prepare_linsys_Amat(parsec_params.X_lo)\n",
    "        Bvec = np.array([parsec_params.Z_te, parsec_params.Z_lo,\n",
    "                            math.tan(parsec_params.alpha_te + parsec_params.beta_te/2),\n",
    "                            0.0, parsec_params.Z_XX_lo, -math.sqrt(2*parsec_params.r_le)])\n",
    "        return np.linalg.solve(Amat, Bvec)\n",
    "    \n",
    "    def _prepare_linsys_Amat(self, X):\n",
    "        return np.array(\n",
    "            [[1.0,           1.0,          1.0,         1.0,          1.0,          1.0        ],\n",
    "             [X**0.5,        X**1.5,       X**2.5,      X**3.5,       X**4.5,       X**5.5     ],\n",
    "             [0.5,           1.5,          2.5,         3.5,          4.5,          5.5        ],\n",
    "             [0.5*X**-0.5,   1.5*X**0.5,   2.5*X**1.5,  3.5*X**2.5,   4.5*X**3.5,   5.5*X**4.5 ],\n",
    "             [-0.25*X**-1.5, 0.75*X**-0.5, 3.75*X**0.5, 8.75*X**1.5, 15.75*X**2.5, 24.75*X**3.5],\n",
    "             [1.0,           0.0,          0.0,         0.0,          0.0,          0.0        ]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PARSECAirfoil(object):\n",
    "    '''\n",
    "    Credit for this class goes to\n",
    "    https://github.com/mbodmer/libairfoil\n",
    "    Airfoil defined by PARSEC Parameters\n",
    "    '''\n",
    "    def __init__(self, parsec_params):\n",
    "        self._coeff = Coefficients(parsec_params)\n",
    "        \n",
    "    def Z_up(self, X):\n",
    "        '''Returns Z(X) on upper surface, calculates PARSEC polynomial'''\n",
    "        a = self._coeff.a_up()\n",
    "        X = X * self._coeff.params.trunc\n",
    "        foil = a[0]*X**0.5 + a[1]*X**1.5 + a[2]*X**2.5 + a[3]*X**3.5 + a[4]*X**4.5 + a[5]*X**5.5\n",
    "        foil[-1] = 0\n",
    "        return foil    \n",
    "    \n",
    "    def Z_lo(self, X):\n",
    "        '''Returns Z(X) on lower surface, calculates PARSEC polynomial'''\n",
    "        a = self._coeff.a_lo()\n",
    "        X = X * self._coeff.params.trunc\n",
    "        foil = a[0]*X**0.5 + a[1]*X**1.5 + a[2]*X**2.5 + a[3]*X**3.5 + a[4]*X**4.5 + a[5]*X**5.5\n",
    "        foil[-1] = 0\n",
    "        return foil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NACA Parameterized Airfoil (Truncation optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NACAAirfoil(object):\n",
    "    '''\n",
    "    Credit for this class goes to\n",
    "    https://github.com/mbodmer/libairfoil\n",
    "    Airfoil defined by PARSEC Parameters\n",
    "    '''\n",
    "    def __init__(self, params):\n",
    "        self.thickness = 1\n",
    "        self.truncation = params[0]\n",
    "\n",
    "    def Z_up(self, X):\n",
    "        X = X * self.truncation\n",
    "        t = self.thickness\n",
    "        foil = 5*t * (.2969*np.sqrt(X) - .1260*X - .3516*X**2 + .2843*X**3 - .102*X**4)\n",
    "        foil[-1] = 0\n",
    "        return foil\n",
    "\n",
    "    def Z_lo(self, X):\n",
    "        '''Returns Z(X) on lower surface, calculates PARSEC polynomial'''\n",
    "        X = X * self.truncation\n",
    "        t = self.thickness\n",
    "        foil = -5*t * (.2969*np.sqrt(X) - .1260*X - .3516*X**2 + .2843*X**3 - .102*X**4)\n",
    "        foil[-1] = 0\n",
    "        return foil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convex Combo of NACA and PARSEC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MixAirfoil(object):\n",
    "    def __init__(self, params):\n",
    "        self.naca_params = params[0:1]\n",
    "        self.parsec_params = params[1:7]\n",
    "        self.mix = params[7]\n",
    "        self.naca = NACAAirfoil(self.naca_params)\n",
    "        self.parsec = PARSECAirfoil(self.parsec_params)\n",
    "\n",
    "    def Z_up(self, X):\n",
    "        naca_coords = self.naca.Z_up(X)\n",
    "        parsec_coords = self.parsec.Z_up(X)\n",
    "        naca_coords = naca_coords * 1/(6*np.max(naca_coords))\n",
    "        parsec_coords = parsec_coords * 1/(6*np.max(parsec_coords))\n",
    "\n",
    "        foil = self.mix * naca_coords + (1-self.mix) * parsec_coords\n",
    "        # foil[-1] = 0\n",
    "        return foil\n",
    "\n",
    "    def Z_lo(self, X):\n",
    "        return -self.Z_up(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interpolated Airfoil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InterAirfoil(object):\n",
    "    def __init__(self, params):\n",
    "        params = np.array(params)        \n",
    "        self.x = params[0]\n",
    "\n",
    "        self.y = np.zeros(params.shape[1])\n",
    "        for i in range(1,self.y.size):\n",
    "            self.y[i] = self.y[i-1] + params[1][i-1]\n",
    "        \n",
    "        self.f = interp1d(self.x, self.y, kind=1)\n",
    "\n",
    "    def Z_up(self, X):\n",
    "        foil = self.f(X)\n",
    "        foil[-1] = 0\n",
    "        return foil\n",
    "\n",
    "    def Z_lo(self, X):\n",
    "        return -self.Z_up(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot Airfoil Designs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_airfoil(airfoil, f=None, l=None, t=None, grid=True, sc=False):\n",
    "    x = np.linspace(0.0, 1.0, 150)\n",
    "    foil_up = airfoil.Z_up(x)\n",
    "    foil_lo = airfoil.Z_lo(x)\n",
    "    topmax = np.max(foil_up)\n",
    "\n",
    "    foil_up = foil_up * 1/(6*topmax)\n",
    "    foil_lo = foil_lo * 1/(6*topmax)\n",
    "    \n",
    "    if not sc:\n",
    "        plt.plot(x, foil_up, 'r--', x,foil_lo, 'b--')\n",
    "    else:\n",
    "        plt.plot(x, foil_up, 'k--', linewidth=2)\n",
    "        plt.plot(x, foil_lo, 'k--', linewidth=2)\n",
    "    \n",
    "    \n",
    "    plt.xlim(-.1, 1.1)\n",
    "    plt.ylim(-.3, .3)\n",
    "    if l is not None:\n",
    "        plt.xlabel(l)\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    if grid:\n",
    "        plt.grid(True)\n",
    "    if t is not None:\n",
    "        plt.title(t)\n",
    "    if f is None:\n",
    "        plt.show()\n",
    "    else:\n",
    "        plt.savefig(f)\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example optimization history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "designs = [\n",
    "[0.4, 0.26, 0.26, 2.2, 0.628, 0.9],\n",
    "[0.395, 0.27, 0.27, 2.14, 0.629, 0.873],\n",
    "[0.385, 0.24, 0.303, 2.256, 0.656, 0.743],\n",
    "[0.399, 0.252, 0.287, 2.205, 0.629, 0.835],\n",
    "[0.397, 0.247, 0.291, 2.255, 0.62, 0.826],\n",
    "[0.399, 0.245, 0.29, 2.282, 0.615, 0.825],\n",
    "[0.396, 0.247, 0.292, 2.266, 0.613, 0.826],\n",
    "[0.397, 0.247, 0.293, 2.277, 0.61, 0.822],\n",
    "[0.397, 0.246, 0.293, 2.28, 0.612, 0.823],\n",
    "[0.397, 0.246, 0.293, 2.282, 0.611, 0.822],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.821],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.61, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.61, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.284, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "[0.397, 0.246, 0.294, 2.283, 0.611, 0.82],\n",
    "]\n",
    "\n",
    "objs = [\n",
    "    1.0577, 0.964, 0.7568, 0.678, 0.6294, 0.6307,\n",
    "    0.6289, 0.6296, 0.7706, 0.6306, 0.6307, 0.6318,\n",
    "    0.631, 0.6397, 0.6312, 0.7581, 0.6314, 0.6304,\n",
    "    0.6312, 0.6312, 0.6318, 0.6319, 0.6319, 0.6319,\n",
    "    0.6335, 0.6226\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot succession of images for animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_anim(designs, objs, basef=\"./myopt/anim/iter\", Airfoil=None):\n",
    "    for i in range(len(designs)):\n",
    "        params = designs[i]\n",
    "        params = Parameters(np.array(params))\n",
    "        airfoil = Airfoil(params)\n",
    "        iter = str(i+1)\n",
    "        iter = '0'*(4-len(iter)) + iter\n",
    "        filename = basef + iter + \".png\"\n",
    "        label = \"Iter: \" + iter + \"    Obj: {:.4f}\".format(objs[i])\n",
    "        plot_airfoil(airfoil, f=filename, l=label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot_anim(designs, objs, Airfoil=PARSECAirfoil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Construct ticks for Interpolated Airfoil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xticks = np.linspace(0,np.pi/2,10)\n",
    "xticks = np.array([(0.5*(1.0-np.cos(tick))) for tick in xticks])\n",
    "xticks = np.hstack([xticks, np.linspace(0.5,1,7)[1:]])\n",
    "\n",
    "plt.scatter(xticks, [np.log(1+i*.01)**.7/2 for i in range(len(xticks))], s=8)\n",
    "plt.gca().set_aspect('equal', adjustable='box')\n",
    "plt.xlim(-.1,1.1)\n",
    "plt.ylim(-.02,.2)\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of how to get init params for interpolated airfoil from mixed airfoil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.031, 0.03, 0.028, 0.024, 0.02, 0.015, 0.01, 0.006, 0.002, 0.0, -0.001, -0.001, -0.002, -0.002, -0.002]\n"
     ]
    }
   ],
   "source": [
    "params = np.array([0.441, 0.425, 0.234, 0.293, 2.222, 0.661, 0.496, 0.307])\n",
    "airfoil = MixAirfoil(params)\n",
    "\n",
    "ys = airfoil.Z_up(xticks)\n",
    "ys[-1] = 2*ys[-2]-ys[-3]\n",
    "ys_rel = [ ys[i+1] - ys[i] for i in range(len(ys)-1)]\n",
    "\n",
    "rec = np.zeros(len(ys))\n",
    "for i in range(1,len(ys)):\n",
    "    rec[i] = rec[i-1] + ys_rel[i-1]\n",
    "\n",
    "params = np.zeros((2,len(xticks)))\n",
    "params[0] = xticks\n",
    "params[1,:-1] = ys_rel\n",
    "\n",
    "airfoil = InterAirfoil(params)\n",
    "plot_airfoil(airfoil)\n",
    "\n",
    "print(list(np.around(ys_rel,decimals=3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of plotting with interpolated points marked"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ys_rel = [0.036, 0.042, 0.024, 0.03, 0.035, 0.021,\n",
    "          0.012, 0.004, 0.003, -0.0, -0.001, -0.002,\n",
    "          -0.003, -0.003, -0.003]\n",
    "params = np.zeros((2,len(xticks)))\n",
    "params[0] = xticks\n",
    "params[1,:-1] = ys_rel\n",
    "airfoil = InterAirfoil(params)\n",
    "\n",
    "xs_plt = np.hstack([params[0],np.ones(1)])\n",
    "\n",
    "ys_air = airfoil.Z_up(xs_plt)\n",
    "ys_air = ys_air / (ys_air.max()*6)\n",
    "plt.scatter(xs_plt,ys_air, s=20, c=\"black\")\n",
    "plt.scatter(xs_plt,-1*ys_air, s=20, c=\"black\")\n",
    "\n",
    "plot_airfoil(airfoil)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wind speeds experienced usually roughly ~Normal(0,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6.641, 6.55, 6.283, 5.863, 5.321, 4.697, 4.033, 3.368, 2.736, 2.162, 1.661]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rv = norm(loc=0, scale=6)\n",
    "weights = np.array([rv.cdf(i+.5)-rv.cdf(i-.5) for i in range(11)])\n",
    "weights *= 100\n",
    "print(list(np.around(weights,decimals=3)))\n",
    "plt.bar(range(11),weights)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting Final Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.671495388386187\n"
     ]
    }
   ],
   "source": [
    "# NACA #\n",
    "params = [1]\n",
    "\n",
    "NACA_airfoil = NACAAirfoil(params)\n",
    "plot_airfoil(NACA_airfoil, sc=True, grid=True)\n",
    "\n",
    "NACA_drags = [.1614,.17196,.1726,.1549,.1890,.1877,.1896,.1888,.1784,.1814,.1882]\n",
    "NACA_obj = np.dot(weights, NACA_drags)\n",
    "\n",
    "print(NACA_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4682574720337005\n"
     ]
    }
   ],
   "source": [
    "# Truncated NACA #\n",
    "params = [0.405]\n",
    "\n",
    "T_NACA_airfoil = NACAAirfoil(params)\n",
    "plot_airfoil(T_NACA_airfoil, sc=True, grid=True)\n",
    "\n",
    "T_NACA_drags = [0.05762, 0.05822, 0.06011, 0.06368, 0.07056, 0.08613, 0.10899, 0.08041, 0.06907, 0.06685, 0.07789]\n",
    "T_NACA_obj = np.dot(weights, T_NACA_drags)\n",
    "\n",
    "print(T_NACA_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.411919901807162\n"
     ]
    }
   ],
   "source": [
    "# PARSEC #\n",
    "params = np.array([0.409, 0.217, 0.293, 2.334, 0.683])\n",
    "\n",
    "PARSEC_airfoil = PARSECAirfoil(params)\n",
    "plot_airfoil(PARSEC_airfoil, sc=True, grid=True)\n",
    "\n",
    "PARSEC_drags = [0.08049, 0.08301, 0.08778, 0.08862, 0.08862, 0.0949, 0.1101, 0.18464, 0.18998, 0.19663, 0.20138]\n",
    "\n",
    "PARSEC_obj = np.dot(weights, PARSEC_drags)\n",
    "\n",
    "print(PARSEC_obj)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.672644688767201\n"
     ]
    }
   ],
   "source": [
    "# Truncated PARSEC #\n",
    "params = np.array([0.3997, 0.2453, 0.3009, 2.3359, 0.618, 0.7968])\n",
    "\n",
    "T_PARSEC_airfoil = PARSECAirfoil(params)\n",
    "plot_airfoil(T_PARSEC_airfoil, sc=True, grid=True)\n",
    "\n",
    "T_PARSEC_drags = [0.0563, 0.06555, 0.07176, 0.07381, 0.07902, 0.08963, 0.108, 0.16884, 0.16884, 0.17409, 0.1817]\n",
    "T_PARSEC_obj = np.dot(weights, T_PARSEC_drags)\n",
    "\n",
    "print(T_PARSEC_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.473527948748136\n"
     ]
    }
   ],
   "source": [
    "# Mixed #\n",
    "params = np.array([0.4388, 0.4285, 0.2319, 0.2924, 2.2184, 0.6653, 0.4959, 0.3065])\n",
    "\n",
    "Mix_airfoil = MixAirfoil(params)\n",
    "plot_airfoil(Mix_airfoil, sc=True, grid=True)\n",
    "\n",
    "Mix_drags = [0.0588735, 0.0588735, 0.05607, 0.08192, 0.07034, 0.07065, 0.07377, 0.07822, 0.08443, 0.0926, 0.09999]\n",
    "Mix_obj = np.dot(weights, Mix_drags)\n",
    "\n",
    "print(Mix_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.9630834688780094\n"
     ]
    }
   ],
   "source": [
    "# Interpolated #\n",
    "x = [0.0372, 0.0374, 0.0204, 0.0301, 0.0367, 0.0206, 0.0114, 0.0038, 0.003, 0.0001, -0.001, -0.0021, -0.0031, -0.003, -0.003]\n",
    "\n",
    "ticks = np.linspace(0,np.pi/2,10)\n",
    "ticks = np.array([(0.5*(1.0-np.cos(e))) for e in ticks])\n",
    "ticks = np.hstack([ticks, np.linspace(0.5,1,7)[1:]])\n",
    "params = np.zeros((2,len(ticks)))\n",
    "params[0] = ticks\n",
    "params[1,:-1] = x\n",
    "\n",
    "Inter_airfoil = InterAirfoil(params)\n",
    "plot_airfoil(Inter_airfoil, sc=True, grid=True)\n",
    "\n",
    "Inter_drags = [0.05307, 0.05478, 0.06334, 0.0615, 0.06088, 0.06085, 0.06132, 0.06208, 0.06323, 0.06509, 0.0683]\n",
    "Inter_obj = np.dot(weights, Inter_drags)\n",
    "\n",
    "print(Inter_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4526324763027545\n"
     ]
    }
   ],
   "source": [
    "# Interpolated From NACA #\n",
    "x = [0.0312, 0.0304, 0.0284, 0.0243, 0.0198, 0.0145, 0.0099, 0.0061, 0.002, 0.0001, -0.001, -0.001, -0.002, -0.002, -0.002]\n",
    "\n",
    "ticks = np.linspace(0,np.pi/2,10)\n",
    "ticks = np.array([(0.5*(1.0-np.cos(e))) for e in ticks])\n",
    "ticks = np.hstack([ticks, np.linspace(0.5,1,7)[1:]])\n",
    "params = np.zeros((2,len(ticks)))\n",
    "params[0] = ticks\n",
    "params[1,:-1] = x\n",
    "\n",
    "Inter2_airfoil = InterAirfoil(params)\n",
    "plot_airfoil(Inter2_airfoil, sc=True, grid=True)\n",
    "\n",
    "Inter2_drags = [0.060648, 0.060648, 0.05776, 0.076755, 0.0731, 0.07078, 0.07279, 0.07595, 0.08126, 0.08869, 0.09324]\n",
    "Inter2_obj = np.dot(weights, Inter2_drags)\n",
    "\n",
    "print(Inter2_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save a plot of each airfoil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NACA \n",
      "Obj: 8.671495388386187\n",
      "PARSEC \n",
      "Obj: 5.411919901807162\n",
      "Truncated NACA \n",
      "Obj: 3.4682574720337005\n",
      "Truncated PARSEC \n",
      "Obj: 4.672644688767201\n",
      "Convex Combination \n",
      "Obj: 3.473527948748136\n",
      "Interpolated from Mixed \n",
      "Obj: 2.9630834688780094\n",
      "Interpolated from NACA \n",
      "Obj: 3.4526324763027545\n"
     ]
    }
   ],
   "source": [
    "airfoils = [NACA_airfoil, PARSEC_airfoil, T_NACA_airfoil, T_PARSEC_airfoil, Mix_airfoil, Inter_airfoil, Inter2_airfoil]\n",
    "names = [\"NACA\", \"PARSEC\", \"Truncated NACA\", \"Truncated PARSEC\", \"Convex Combination\", \"Interpolated from Mixed\", \"Interpolated from NACA\"]\n",
    "objs = [NACA_obj, PARSEC_obj, T_NACA_obj, T_PARSEC_obj, Mix_obj, Inter_obj, Inter2_obj]\n",
    "drags = [NACA_drags, PARSEC_drags, T_NACA_drags, T_PARSEC_drags, Mix_drags, Inter_drags, Inter2_drags]\n",
    "\n",
    "plt.rc('font', size=6)          # controls default text sizes\n",
    "plt.rc('axes', titlesize=10)     # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=6)    # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=7)    # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=7)    # fontsize of the tick labels\n",
    "plt.rc('figure', titlesize=12)  # fontsize of the figure title\n",
    "\n",
    "for i in range(len(airfoils)):\n",
    "    print(names[i], \"\\nObj:\", objs[i])\n",
    "    # a_drag = np.hstack([drags[i][::-1],drags[i][1:]])\n",
    "    # yaws = len(drags[i])\n",
    "    # yaws = list(range(-yaws+1,yaws))\n",
    "    # plt.ylim(0, a_drag.max()+.02)\n",
    "    # plt.plot(yaws,a_drag)\n",
    "    # plt.show()\n",
    "    t = names[i] + \"        Obj: \" + str(np.around(objs[i],decimals=3))\n",
    "    plot_airfoil(airfoils[i], sc=True, grid=True, f=names[i], t=t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drag vs Yaw plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbEAAADOCAYAAACw0zwRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd3wcxfmHn72iUz3dSTrpVN07tuSCC5hiO6GXHxBMMGDTQk+jB0JJAwIJCSYkBIIdm44DJIEYSLANuOMiybbcbVnF6jpJpzvp+vz+mNNJsiVbtsrJ8j76zGdXe3u77+7OzXfemXdmFSEEKioqKioqpyKacBugoqKioqJysqgipqKioqJyyqKKmIqKiorKKYsqYioqKioqpyyqiKmoqKionLKoIqaioqKicsqiipjKaY+iKDcrivK8oij3K4rycDeO8ZCiKA8rijLhOPtmKYryJ0VRximK8jdFUXIURbmug/2O2tbBPn88GXuD3x2kKMqvFEXRKIqyUFGUqJM9lopKuNCF2wAVlX7CO0KIPEVR7lYUZSzwB2ApsAX4LjAeeBi4FXADVwHfE0LUK4oSA4wQQjzecjBFUZ4CaoAE4HngWaACqAdigAAwGogG6oAZiqLkATcDpcDi4LYVwOPBY+0CJgTXJwC/AsYqivJ9wAOMAQ4IId4L2vAIsATIQVZYrwDygf8JIfYLIYoURdkCvAv8AohUFOUHwKjg9d8FvAK8CtwLnCuEWNQD91pFpcdQPTEVlfYogAAOCiHepvU30owUslFCiFeAnR18py3pwf0ygt8zA1VAEpALrEQK5LdCiKLgd64AXhZCvCKEaApuOx/wAYeDxwJ4D/gMGALsDIrWDsALmNrYsBRYAFwIfA5sCtqhbdlBCPFPoEIIsROICl5vJTAjeM6bgS+Dy8+PdeNUVMKBKmIqKpJ5iqLcD8QKIXYhvS2AsUgBU5CF/15FUe4FxiHFBSGEAzioKMqDbZoTDwf3K0UKTAMQh/SEOuMT4D5FUe5SFCU6uO1rwID03nKD23xI0dQADYqi3AIkAw7gjJaDCSHKgUykGAkgNngNI484b4sAD6ZV4LRI0ToLKZpzhBBlx7BdRSUsKOq0UyoqXUdRlInAmcBwIcRJ9Z+pqKj0HKqIqaioqKicsqjNiSoqKioqpyyqiKmoqKionLKoIqaioqKicsrSr8aJJSUlicGDB4fbDBUVFRWVfsSWLVtqhBCWjj7rVyI2ePBgNm/eHG4zVFRUVFT6EYqiFHX2mdqcqKKioqJyyqKKmIqKiorKKYsqYioqKioqpywDTsQ2l21mbfFa6prrwm2KioqKymmJP+DngO0A/97zbxrdjb16rn4V2NETPLvmWT7a9REAqbGpjEsex9iksXJpGcs4yzjMUeYwW6mioqJy6uMP+CmsL2Rn9U4KqgrYWSOXu2t20+xrBmD1LauZmTWz12zo8WmnFEWZi5wp+33gXCALyAPSgRIhxLoj9r8DuAMgKytrclFRp0EoXaKkoYRtldvkTa0uYGf1TnZW78TpdYb2scZaGWcZxzhLUNiCApcQldCtc6uoqKgMRFrEqqCqIFS2FlRLsXL5XKH9Mo2ZIWehpWydkDKBaH30MY5+fBRF2SKEmNLhZ70gYvOB9chXTmwD5gNOIcRSRVHmCyGWdvbdKVOmiN4IsQ+IACUNJfLGt6ktdCZuLQ9hctpkslOy0Wv1PW6TioqKSn+kpqmG9SXr2V61PeQIHClWWfFZ7cXKMo4xljEYDcZesamvRWwu8kWAucAtwMfIV1lYgTIhxJrOvttbItYZLeLW1mtrWTo8DgCi9dFMz5jO2ZlnMzNrJtMzpvfag1JRUVHpS4QQ7LftZ23JWtYUr2FtyVp21+wOfT4oftBRntWYpDHEGeL61M4+FbHu0Nci1hlCCIobitl4eCNri9eypmQNeRV5BEQAjaJhQsoEZmbO5OwsKWwZxozjH1RFRUUlzHj9XnIrckOCtaZ4DVXOKgASohI4K/OsUNmWnZLd52LVGaqI9QCN7kY2Ht4YevjrS9aHmiKz4rOYmTUz9PDHWcah1WiPc0QVFRWV3qXB1cD60vWhcmtj6cZQwMVQ89B25dbopNFolP4ZsK6KWC/gC/jIr8gP1WbWFK+h3FEOQLwhnhmZM0KZY1LqJLUJUkVFpVcRQlBYX8iG0g2hFqTtldsRCLSKlompE0PdImdnnk1qXGq4Te4yp5WIVVSA0QjR3QuGOWGEEByqP9TOTS+oLgh9PtQ8lBxrDjkpOXJpzSHDmIGiKMc5LuTnw5dfgtMJbrdMLlfr+olsUxQwm088mUygO8aADCHkuZxOcDhkOt661wt33QUjR/bUU1A5HVi0CLZtg9hYmWJiWteP/L9lPSbm+Pm3uRnq6rqebDa5dDhArweDQabIyNb1E9mWmQlXXil/a8fD7XNTUF1AXkVeKOVX5mN32wGIjYhlRsYM6WllzWRq+lRiI2J76Al0naIiSE8/9r3vCqeViN14I3zwAUyeDOecAzNnypQQhuh5W7ONDaUbyC3PJb8yn7yKPPbZ9oU+T4hKIDslOyRqOdYcxiSNQa/Vc/gwvPMOLF0KO3a0HlOn6/qPoqN9hOj8R9ncfOzriYtrFTWN5mhRCgS6fm8MBrl/aip8+y2kpJzgzVU5LXn1Vbj7bllJdblOPM+1FbfoaJlvW/K/x9P5dxUF4uOPrtwlJMjjeb0nXqFs+39LMWwwwBVXwE03wUUXSXGsaaohv0KWH3mVeeRX5LOrZhe+gA+AGH0M2dZsclJyyLZmMyVtChNSJqDT9O0w4EAAdu2C1atbU0kJbNoEUzqUn65zWonYV1/B55/LG7hpk8xcAOPGSVFrSZmZ3bf3ZGh0N7K9anu72tO2ym2h8FUdEUQ6xuLYlwMVOYxNyOGWS7KZP9dEUpIUj97C7e56LTQQOHbN91g15JZa8datsoKRkwMrV0rRVVHpjC+/lAX7hRfCv/8tfwsn6v23XW9qkvmxKy0R8fG999sTAnw+2LI1wCvvHORfG/NojMkjIiuPiMx8HNrS0L7pcenkWHPaVX6HJQwLS1+W1wtbtsiyds0amWw2+ZnV2lrWXnut/L87nFYi1pbmZlnLb6kVrFsnMy/AoEHtRW30aFnb6mv8fvjvlz7+/N4+/rs9D485j6gheWjS8nAqVaH9Jlon8r+b/kdidGLfG9mLfPQRXHMN3HADvPlmeJ6BSv9nzx6YPh0yMmDtWtllMJB4M/9N7ll+T2hojwYtsa4xOPZnEyjLIUOXw03fzebOmywMGhQeGx0O2LChtTzdsKG19Wb48Pbl6bBhPftbPq1ErMbjIV6nQ99Btcnnk23pbd3dqqBOJCVJr6ClCXLiROnK9xb5+bLQfucdKC+X7eBz58pmhLPPlhmgwlFBXkUeG0s38vTXT/PiBS/y0xk/7T2jwsQzz8Djj8NvfgOPPRZua1T6GzabFLD6elkpHWjvzQ2IAENfGorRYOTH035MjjWHccnjiNRFUl8Py5bJsmL1arn/eefJcuJ735MeYm9RXS0rDC1l5datstKt0UB2dqtgzZzZuadV6fFg0evRdFPRTisRW7BrFx/V1HC+ycR3zGa+YzYzNjq6wwAKIWDfvvaidvCg/CwmBkaNkp2SLSktrf3/JtOJ1TbKylr7ubZvl01ql1wC8+fDpZceuzlt+t+m4/A42H739uMGg5xqCCHvwVtvwT/+IT0zFRWQTVYXXSSbqlaulBW8gcaKgyv4zpvf4d1r3uX7Z3y/0/0KC+Htt6Wg7d0ry4uW/rMLLzyxSrfPJyvPhw/Lcunw4fapuBgOHJD7GgwwdWqraM2Y0bl4Ov1+vqmv58u6Or6sq2Ob08nWyZOZGNe98WanlYh9YbPxr5oavqyrY1/Q17VGRPAds5nvms3MMZtJNxg6/X5ZWWsb74EDrQ+1tvbofaOi2otaR0JnNMKnn8qMt2KF7EuaNk1mvOuukx5gV3hty2vc+emdbLx9I1PTp57MrenXuFwwezbk5cl7P2lSuC1SCTdCyOjV116DJUtkRWcgMu/DeXy2/zPKHygnUnf8jmEhpEf65pvw3nuybLJY4PrrZbkyfHjn4tSSKitbg0la0Ovbl18TJ0rRmjKl8wq2LxBgc2NjSLTW2e14hcCgKMyMj+c7ZjM3Wa3HLHO7wmklYm0pcrlCN3dFXR3VwSiPMdHRIS/tfJMJYxfiP10umSk6yxgt293ujr8/eLDMYDfeeHIh5Q2uBlJ/n8r87Pm8etmrJ36AU4DKSlnj8/lkUE5aWrgtUgknL70EP/kJPPooPPtsuK3pHeqa60j9fSq3T7qdP13ypxP+vscjA9nefFMGu3QWYZmQcHSF+8hKd1cCx4QQ7G1u5n82G1/W1bGqvh67348CTIyNDZWrZ8fHE63tuQkfTlsRa0tACLY7nSFR+7q+nuZAAC0wzWgM3fxpRiMRJxmGJIRsv28rbtXVss347LO7H900/+P5/GvPvyh/oLzbs0L3V7Ztk/dq1Cj45pu+H++n0j/47DO47DLZXPbhh70blRtO/rzpz9y7/F623LGFSanda36oq5OBUvX1RwtVdyJ/K9xuVrRpIiwN1tQHR0by3WAL1yyTiaSIiG7ZfyxUEesAdyDA+oaG0IPZ1NhIAIjRaDgv2J92Vnw842NierRG0R2+PvQ15y85nzevepMbJ9wYbnN6jU8+kYM+r7kG3n9/4BZgKh1TUCD7XYYNk037sX0/RrfPmPLaFPzCT+6dueE2BZCe1mG3m1yHg1VB4drulNPrJeh0zAlW9r9jNjM0KqrP7FJFrAvUe72hh/ZlXR17g/1pCjAiKors2FiZYmLIjo0lw2Do8wALIQQjXh5BVnwWKxes7NNz9zW//z08+CA88QT88pe9f77Dh+F//wOtFiIiWpNef+L/97e4G79fNjN5PDJQomX9RP43meDyy3u/QlFdLfuMW4bHhGs8Z1+QX5FPzl9zWHjRQn447Yd9fn53IMBOp5N8h4P8lqXDgc0nB1EbFIVz2gTI5cTGog1T5j6WiA24NzufLCa9nqssFq6yWAAocbnY3NgYesCbGxtZVl0d2j9Bp2NCUNRyggI3NiYGQy/+yhVF4ZacW/j5qp9zsO4gQ81De+1c4eb++2HnTvjVr+QYvnnzeuc8Ph+8/DI8+WTrGMLuMny47P+cPz884eA+nxwYvGSJ7CdpauqZ406bJmfMyMnpmeMdidsNV18to+a+/npgCxjA4rzFRGgjmDe+lzJ3Gyo9npBItZRpu5ua8AWdmCiNhvExMVxjsYQq65Pj4ojqJ61Qx0L1xE4Au8/HtiNqLdudTpqDc9/oFIXR0dEhby07NpbxMTHE9kBGiNBoMGg0lNpLyfpDFj8/9+f8clYfuChhxOOB734XNm6UM7FMn96zx//2W7jzThkRecklcrxaTMzJeysejyyIV6+GVavkOc49FxYskGN6enuA7vbtcvjGW2/JOUQTEuR5MzJO3qtsWV+zRnrGtbXw4x/DL37Rs818QsAtt0jhfe89Gbk7kHH73KS/mM6coXN4/3vvI4TA4fd3+7gCKHa52pVR+Q4HlS1TFwEZBkO7Mio7NpbhUVFh87K6gtqc2Iv4hWB/c/NRtZzSzsIUT5JojYa8KVMYER3NxW9fTEFVAYU/Lhzwr3ypqZEegNMpRScrq/vHrK+Xg6v/8hc5d+PChdID6MnfcFGRFJMlS+RYxKgouOoqKWhz5shmy56gqqp17GFurhx7eOml8jyXXCLH+PQUdXXws5/BX/8qhfHll+H//q9njv388/DII/DUU/D00z1zzP7MP3b+g2uXXcvnN3zOhcMv5OEDB3ihpKRHzxGhKIyNiTlKsBJ7cxaHXkIVsTBQ6/WyzeGgwOnE3c17HBCCJw8d4qaUFF4bNYplBcuY+4+5oR/AQGfXLumFDRkiPYKT9QCEkIEiP/2pLPx/+EPZ39abHpIQ0pNs8TDq62W02I03SqEZO/bEj+l2y+CXpUtlFJ/PJye8XrAAvv99OWaoN1m/Xnqw27fL6MGFC+nWVEj//KesRMydC+++2//6FHuDi9++mB1VOzj040PU+vwM2rCBmfHxXNQDM5Wn6PVkx8YyOjq6w5mLTkWOJWIIIfpNmjx5slDpmHv27BERX30lDrtcwuV1iYTfJoi5y+aG26w+4/PPhdBohLjiCiH8/hP//r59QlxwgRAgxJQpQmzZ0vM2Hg+XS4hly4S4/HIhtFppy+TJQixcKER19bG/GwgIsX69EHfdJYTZLL+blibEww8LsWNH39jfFo9HiBdeECI6WqYXXpDbTpTcXCFiYoQ480whmpp63s7+SHF9sVCeVsTPV/xcCCHEzw8eFMqqVWKXwxFmy/ovwGbRiW6EXbjaJlXEOudgU5PQrlolHtq/XwghxI+W/0hE/CpC1DhrwmxZ3/HyyzLHPvxw17/jcgnxq18JYTAIERcnj+Hz9Z6NXaWyUog//EGIiRPlNel0Qlx5pRAffSSE2926X1GREL/+tRAjR8r9oqKEmDdPiC++6B/XceiQFGUQYsIEIdat6/p3y8uFyMwUIj1diLKy3rOxv/Hrr38teBpxwHZA2L1eYVq9Wly9fXu4zerXqCI2QJhXUCBiv/lG2DwekVeeJ3gasXDDwnCb1WcEAkLcfbfMtYsXH3//VauEGDVK7j93rhCHD/e2hSfHtm1CPPigEFartDUhQYg77hBi1iz5Pwhx7rlCvPGGEA0N4ba2Yz7+WIiMDCEURYg77xTCZjv2/k1NQkybJr24rVv7xsb+gD/gF0NfGipm/X2WEEKIF4qKBKtWiY399cH2E1QRGyDkNzYKVq0Svz50SAghxOS/ThY5r+aE2aq+xeMR4jvfEUKvF+Kbbzrep6pKiPnzZe4eMkSIzz7rWxtPFq9XiOXLhfj+94WIjBRi2DAhfvELIQ4eDLdlXaOxUYj775dNpcnJQrz1lqx4HEkgIMT118vn89FHfW9nOPmq8CvB04g3898ULr9fpK5dK2bn5obbrH6PKmIDiEvz84VlzRrh9PnEK9++IngasbXsNKrKClnLHzlSiMREIQ4caN3u9wvx+uuyz0ivF+Kxx4RwOsNnZ3fweDoWgFOB3Fwhpk6VpcucOULs2dP+81/+Un72zDPhsS+czP94vjA+axROj1O8fviwYNUq8b/a2nCb1e85logNjNCV04hHs7Ko9npZXFHB9Wdcj0FrYFHuonCb1aeYzfLNAIGAnEWioQF27JBjsn7wAxg/Xo79+s1vTt25F/vjzB9dJSdHvoD2z3+GzZvl8/jFL+Qk2h98IAeW33STnNj3dMLutrOsYJn83eqieL6khMmxscwxm8Nt2imNKmKnGDNNJs42GnmhuJhYQzxXj7mat7e/jcvnCrdpfcqIEXJi2L175Tx7EyfC7t2waJEcGH0yoesqPYdWC3ffLZ/JNdfIsV/jx8thAGedBa+/fuqK9Mny/o73afY1c+vEW/m4upp9zc08mpU14N4P2NeoInYK8mhWFkVuN+9XVXHrxFupc9Xxr93/CrdZfc6sWXLA8p49sma/e7ec9UEtE/oPVqscjP3FFzJEJS0NPv64ZwdhnyosylvEOMs4pqRO4dniYkZERYWmuVM5eVQROwW5JDGRM2JieK64mPMHzyIrPos3ct8It1lh4fbbwW6XHlhXXzCq0vdccIGsbBQUQHJyuK3pe3ZW72RD6QZunXgrK+rr2epw8HBmZr+e6ulUQRWxUxCNovBoVhYFTU18bqvjlpxb+PLglxTVF4XbtLAQExNuC1S6glbbvfdancosyl2ETqPjxgk38lxxMWkREdxktYbbrAFBj4uYoihzFUW5U1EUk6IotymKcr6iKDcpinKZoihHFTeKotyhKMpmRVE2V7eZJV7l2FxnsTA4MpJni4tZkL0AgCX5S8JslYqKypF4/V6W5i/l8pGXc8gfycr6eu7PzOzVN16cTvTGXYwEVgJjgBXBbYcBLRB/5M5CiNeEEFOEEFMsavtwl9FpNDyYmck6u51SxcycoXNYnLeYgAiE2zQVFZU2/Gfff6huqua2ibfxXHExJp2OO1JTw23WgKE3RMwFzAECQA4wESgDDMDgXjjfacstVisWvZ7niou5NedWDtUf4qtDX4XbLBUVlTYsyl1EamwqWWnn8HFNDfelpxOnU1/l2FP0+J0UQnzQyUe7e/pcpzvRWi0/ycjg8cJCnsq5AFOkiUW5i5g9ZHa4TVNRUQHKG8tZvm85D531EH8oLSNKo+FH6enhNmtAoTbKnuLck5ZGnFbLH8sqmXfGPD7c9SH1rvpwm6WiogK8ue1N/MLPRePm81ZlJbenpmKJiAi3WQMKVcROcUx6PXelpfF+VRUXjLsZl8/FezveC7dZKiqnPUIIFuUuYmbWTP7l1BMQggcyM8Nt1oBDFbEBwE8yMtApCp974pmQMuG0HTOmotKfWFeyjj21e5g74XZeKytjXkoKg07XMQa9iCpiA4A0g4EFViuLy8u5NvsONpdtZlvltnCbpaJyWrModxEx+hgqTDNwBgI8kpUVbpMGJKqIDRAezszEKwTVCeeh1+hZnLs43CapqJy2ODwO3i94n6vH3cCr5VVckZjIOHVUfq+gitgAYXh0NN+zWPh7VR2XjpnLm9vexOP3hNssFZXTkmUFy3B6nSQMvRGbz8ejqhfWa6giNoB4JCsLu9+PeegCaptr+WTPJ+E2SUXltGRR3iJGJo3lI4eOc+PjmRF/1DwPKj2EKmIDiElxcVxgNrO8OZo042AW5Z1e7xlTUekP7K3dy5riNWRPeIASt1v1wnoZVcQGGD/LyqLS62VC9sN8vv9zDtsPh9skFZXTisW5i9EoOnL1o8mOieGihIRwmzSgUUVsgHGeycS0uDgKIs8gIGBp/tJwm6SictrgC/hYkr+ESWfcx36XR33pZR+gitgAQwm+pqXE42fM2LtZlLcIIUS4zVJROS34Yv8XlDvKaUi5lKGRkXxPndS811FFbAByRVISo6OjcVqvYL9tP6uLV4fbJBWV04I3ct/AZJ3FPq+OhzIz0amvW+l11Ds8ANEoCo9kZlLsjyAq+TwW5aoBHioqvU2Vs4pP9n5C/Ii7SNHruVl96WWfoIrYAGVeSgqZBgPxI+5m2c5l2N32cJukojKgeWvbW/iih1CkSeanmZlEarXhNum0QBWxAUqERsMDmZlU6FJoihrCBwWdvSFHRUWluwgheCP3DRJG3YdRq+WutLRwm3TaoIrYAOb21FQSdDpih9+hNimqqPQim8o2sdPRQF3seO5JTydefelln6GK2AAmRqvlRxkZOOImsN5Wzq7qXeE2SUVlQLIodxHarBuIUDT8WH3pZZ9yTBFTFGVucLmgb8xR6WnuS08nWqOgZM1jcZ46KbCKSk/T5G3i7T1fIFIu4NbUVKwGQ7hNOq3oVMQURfkDcJuiKC8Cg/vMIpUeJVGv5860dEiew+Jdy/H6veE2SUVlQPHRro9wJF8IipYH1Zde9jmdipgQ4qfAbcDHwKo+s0ilx7k/IwOtolCTMJvl+5aH2xwVlQHFq/lvo6T9H9clJzM0Kirc5px2HK9P7OdAAmDqA1tUeomMyEhuSEmBtEt5ccsiXD5XuE1SURkQbCnbwlpfIkIbqb70MkwcT8S2A6uBr3rfFJXe5NGsQShKBJb8RM56ZhiLcxfjC/jCbZaKyilJSUMJt//7dn7z0ExMidcwWwfZsbHhNuu05HgilgTcB/ykD2xR6UVGL1zI1d98w7+/ez2zyi/iT3+9kwl/mcA/d/9TnVtRRaWL1DbV8uB/H2TUS8OJX7KSihkvUG808/RTv4J9+8Jt3mnJ8URsG1AHrOgDW1R6i2efhcce47WiIuZGRfHidTfhmvEaUw4kcdX7VzHjjRl8deircFupotJvcXgc/PqbXzN04VAWr1rIzU138PJdf2XviBG8HRnJOdu2waxZqpCFgeOJ2GigAZjQB7ao9AZBAWPePBJef523Zs5k+aBBNJrMvHXZ08xL+C3l9hpmLZnFRW9dRG55brgtVlHpN3j8Hl759hWGLxzOE6ue4ELjlVjHLeIvF13Dtc3N7Jo1i3nTp8PKleB2q0IWBo4nYhbgDGBUH9ii0tO0ETCWLoXgXG4XDxlCwYUXcl9REe+Om4IY+jvumfoSm8o2Mem1SVz/4fXst+0Ps/EqKuEjIAK8ve1tRv9pNPd9dh8jLBO4afzb/GP0zTRGRvKpTsfbV1yBJSJCfmH8eFXIwoRyrP4QRVESgfOAr4UQtb1tzJQpU8TmzZu7dQzHDgcavYaokVGn98voOhGwI1m/bBm3NTezKyuLuYogzf8Nr214Ho/fw+0Tb+fJ854kNS61j41XUQkPQgg+2/8ZP1vxM7ZVbiPHmsP3pj/La2WCEoOBezdu5JmbbiIuI6PjA2zfDrNng8EAq1bBiBF9ewH9CH+Tn4Z1DZjONaGJ6N7kUIqibBFCTOnws85ELDhbx4zgv0IIcX8XTzYXMAPvA9cABwAfkA6UCCHWdfbdnhCxHVfvoObjGiLSIzDPNmOabcI820xkVmS3jntK0UUBa8Gdm8uzS5bwzKWXYtRoeHp4BrsKXua1LX9Fr9Hzk+k/4eGzH8YUqY60UBm4rCtZx6NfPsrq4tUMMw/j4fN/w9eBUbxTX8+YQ4f42759nPXkk1KgjsVpKmQBT4DGTY3UrayjbkUd9vV2hEeQ83UOpnO7V3aclIgFvxglhGhuWXbxZPOB9cjIxnLkbB9ZQoiliqLMF0IsPWL/O4A7ALKysiYXFRV15TSd0nygmboVddStrKN+ZT3eajlDReSwSMyzzZjnmDHNMhGRHNGt8/RbTlDAQtTUUHDffdx+zjlsGDeOi81mfmaN4q9rf8k729/BFGni0ZmPct/U+4jWR/fuNaio9CE7qnbw+MrH+feef2ONtfLkuU8Rk3EFD+zdR4PXy8/efZfHpk/H8IMfdP2gp4GQCb/AkecIlbX1q+sJOAOgQGxOrCxrZ5swnWtCG9O919J0R8TuFkL8RVGUO4QQr3XxZHORA6RzgVRgCLAFsAJlQog1nX23JzyxtoiAwFngpH5lvbzRX9Xjt2OXE28AACAASURBVPsBiDkjJuSlxZ8Xj96k77Hzho2TFbAWfD78jzzCK4cO8dgdd0BkJM8MG8ZMbQ1PrHqc5fuWkxaXxlPnPcUtObeg1w6Ae6Zy2nKo/hBPffUUb+a/idFg5JGzH+GqnDt5oLCU5TYb03bv5m+LFnHGSy/BjBnHP+CRDDAhE0LQtKupVbS+qsdXJ8eaRo+JDpWnpvNM6BN7tmzojog9AywEfiiEeLxHreqAnhAxu91OTEwM2g4K8IAvgGNra82hYU0DgeYAaCBuclyrqJ0d3+2aQ5/z3HPws5+dvIC15Z13KHrsMe766U/5PDub6UYjfxs1itqaLfxsxc9YV7KO2IhYpqZPZXr6dKZnyGSJsfTc9aio9CD+gJ+d1TvZULqB9aXr2VC6gV01u4jURfKjqT/iobMf5j1bMz8rLES43Tzzl79wb0UF2mXLoDvvBmsrZF99BcOH99g19QXNhc2tTsDKejwVHgAMgwyY55ilaM0yYUjruInVbrcTHR2NrpuvpumOiI0ELgc+EULs7ZYVXaAnRGz+/Pl88MEHjBw5kjFjxjB69GjGjBnDmDFjGDlyJFFt5jYLuAPYN9hDD8i+wY7wCRS9gnG6EfN3zSRekkjsxFgUTT8OEulJAWshNxdx1VW8PXYsP3ngAew6HY9lZfFoVharDv6X5fuWs750PfmV+aGZP4aZh4UEbXrGdLJTslVvTSUsVDur2Xh4I+tL1rPh8Aa+PfwtDo8DgKToJJlH06ezIGcBdq2Z2/fsYb3dzoUHD/LqY48x+MorYeHC4/d/dYVTSMh8DT7qvqyj9rNa6lfU4zokp6jTp+hbYwzmmIka0lqOCiGorKxk165dobR792527drF4cOH2bJlC5MmTeqWXX0a2NEdekLEPvnkE1avXh26mYWFhQQCAQAURWHw4MEhUWsrcAkJCfgcPuxr7bJPbUUdjq0y0+uT9SRclEDCxQkkXJCAPqEfFcy9IWAt1NTAdddRvWULP1m4kHeyshgbHc3fRo1iRnw8IF9DsbV8a6iwWF+ynnJHOQCRukimpE1p562lG9V3Lan0LF6/l22V20Ie1obSDRyoOwCAVtGSY81pV7kaZh6Goih4AgGeKy7mN0VFxAF/fP11bvjgA5Q//QnuuKNnjdy2DebM6XdCJoTAuc1J7We12D6zYV8nK/LaeC3mWa2iFT0mmkAgQGFhYTuRalmvr68PHTM2NrZdGXvjjTeS2c3Z/U9WxCYAdUKIkm6d/QTo6T4xAJfLxd69e9vd9F27drFnzx7cbndov+Tk5HaiNmbMGMZnjUfZpGBbbsP2Xxs+mw80YJxuJOHiBBIvDrOX1psC1oLPB488Ai++yH9uu427b76ZUp+PecnJ3JKayiyTCU2boQxCCErtpe0KlC3lW/D4ZTNEhjGDGRkzmJ4xnWnp00iISugRMw06AwatgUhdJJG6SAw6AzqN+nbdcCGEwOP34PK5cPvdculz98h8nQERYE/tnlDFaXPZ5tCk1tZYKzMyZoTy2OS0yUcFItV6vbxbWckrZWXsbmriepeLP952G8mBAHz4IZx1Vrdt7JB+ImRtvS3b5zY8h+VvMyY7hsRLEjFdaOJw/GEKdhe0E6q9e/e2KzOtVutRZebo0aNJT0/v8eFNJytirwNRwLcAQoiFPWpVB/SGiHWG3++nqKjoKPd3165d1NXVAdJzy8nJYfbs2cw+fzbZUdl4vvZQu7wWx5agl5YivbTEixMxX2BGb+4jL60vBKwtb78Nt99OY0YGTy9ezBtC0OD3k2kwMD8lhflWKyOjO45adPvc5FXkSVELemtFDd2LQu0KWkWLQSeFrUXgjvW/OdLMGMsYxlrGMs4yjrS4tNN2rKHb52ZP7R52Vu+koKqAwvpCmn3NuH3uo4TJ5XMdtc3tdx//JN0kQhvBpNRJTE+fzoxMKVqZxswOn5k3EGC5zcaSigo+ra3FKwQ5MTH8evVqLn3gAZg+XQpYd/q/ukIYhEwIgXO7E9tnNmqX17bzthK+m4D5IjP1o+tZU7CGFStWsGrVKqqrqwHQaDQMGTLkqNar0aNHYzabe932Fk5WxMYip53aAiCE6PVSpy9FrDOEEFRVVbFz507Wrl3LihUrWLduHR6PB51Ox7Rp05gzZw7n5JzDCNsInF86sX1hk1E6bb20SxKJzeklL62vBayF3Fy46iqoqKD5d7/jX1dfzZKaGv5rsxEAZhiNLLBauc5iwaQ/tpiXN5azuWwzTd6mbpsVEAE8fs9RBWvL/6Ft/qM/a1sI1zTVUNvcOqY/3hDPuORxjE0ay7jkcYyzjGOsZeyAEje3z83e2r0UVBdQUFVAQXUBO6t3st+2H7+QkbxaRUtmfCYx+phOKwHtth3js57yjgeZBjHROhGDrvM+KyEEuQ4HSyoqeKeqihqvlxS9nhtSUljg9zPhxz+GL76AH/wAXn65Z/q/ukIfCJnPHvS2lnfgbV2ciPtMN5vsm1j19SpWrlxJcXExAGlpacyZM4fZs2czadIkRo4cSWRk+MfYnqyIvQz4gZUAQoh/95qFQfqDiHVEU1MT69atY8WKFaxYsYItW7YQCASIiopi5syZzJ41m2nJ08g8mEn9F/VHeWmmc0wYpxuJHhPdfVELl4C1UFMDN9wA//0vjBwJzz5L2SWX8HZVFUsqKihoasKgKFyZlMQCq5ULzGZ0mu6N1u9LqpxVIe+jpUAvqC6gpqkmtI8p0hTy1lqW45LHkRqb2m/Fra1YtVxTQVXBUWI1PGF4u2saaxnLqMRRxxSL/ka5283blZUsqaxkh9NJRJv8eGEggO6ZZ+CVV0Cngz/8Ae68s++N7GEh89l9NG5qxL7Bju1/Nuxrg96WUYv5u2Y052jYHr2db/K+YeXKlezevRuAhIQEZs2axezZs5kzZw4jR47sl3n4ZEUsEznjxlYAIcQ3vWZhkP4qYkdSX1/P119/zcqVK1mxYgUFBQUAmEwmzj//fM6dci6TNJNIyk+i7n91si8N0Bq1xJ0Zh3G6UaZpRiIsJzDoOtwC1oIQ8Omn8OijsHOnHEPz/POIs89ma0vNt7KSWp8Pa0QENyQns8BqZfwp/L6lKmcVBVVtBCAoAm09txZxG2YeRkpMCskxyaTEBpcxKaTEpmCJtvRoxKYQgkZPI1XOKiodlXLprAytlznK2F2zm321+0JipVE0DE8YLoWqRYiTx51yYtUWl9/Pv2tr+XtFBV8EWwamG40sSEnhuuRkzD4fvPSSHEvpcMBtt8HTT/d+8+GxOEkhE36Bc6cT+wY79o127BvsNO1sgmBRHjMhhsg5kexJ3cPGio2s/Golubm5CCGIjo7m3HPPDXlbOTk5aE6BSmZ3Qux/ACQC+UKIz3rJvhCniogdSUVFBatWrQp5aocOHQJkx+es82eRMySH4YHhZFZlouQpOLY5pI8LRA6NDAmacbqR2JzYjucZ6y8C1hafD/7+d3jySSgvhyuvlHaOHo0nEOA/tbUsqajgPzYbPiGYGBvLAquVecnJrROnniRCCOq/qqfs1TLqV9Yz4pURJM9N7pnrOgEbqpuqj/LaiuqLqHRWdvoG7YSohJCwtRW4ttuSY5Jp9jW3E6aQUDXJZcu2Y53HGmtlVOKodt5VOMTK7/Sz84adOLc5Sb0tFeutVgyp3bNBCMEGu50lFRW8X11Nvc9HhsHATSkpLLBaGRUdDX6//L088QQcPgyXXy7z6NixPXRl3aQLQuap9ITEyr7BTuOmRvwOWYDoEnTETo3FNsJGUVwRe1x7WPvtWjZu3IjX60Wv1zNjxoyQpzV16lQiuvnbCwfdEbGHgEogTgjxSi/ZF+JUFbEjKSwsZMWKFaxcuZJVq1ZRUVER+iwrK4sJZ0xgjGUMQwNDGVQ5iLjtcfjKpbemRCjETZLeWtzESIy1q4n8+FWU1d/0LwFri9MJf/wj/Pa30NTUWstNlRMHV3s8vBtsbtzqcKBTFC5NSGC+1cpsk+m4/Wdt8dq8VCypoOzVMpr3NqMz64hIi6BpZxPDXxpOxg87mZi1jxFC4PA42otPWy+pqf22elf9cY+p0+jai19sCsnRR3t7yTHJPe7xdQdvrZdtl26jcVMjxmlG7OvtKDqFxCsTSbsrDfNsc5eb2QNCsL+5mWXV1SytqGBvczNRGg3XWCwsSElhltmMVlFka8Fnn8nI2h07YOpUeOEFOPfcXr7ak6BFyDweAtfPp/Hsm7HXJkvB2tgYGqul6BQ0Z2goH1ZOYVwh+9372VG4g+3bt+N0OgHQarXk5OSEPK2ZM2cSExMTzqvrEbojYr9HTuZbf6qME+Pjj8Fmg7lzIS6uZwzrJhUVFeTn55OXlxda7tmzJzR+LS4ujjNGn8GYhDEMFUMZVJRMyv409H6Z+fTaBoyjBNGXnkH02BiiR0cTPSq67yIhu0p1NfzqV/CXv0BEBDzwADz0ULvnsMPhYEllJW9VVlLhkZ3NgwwGJsTGkh0bS3ZMDBNiYxkWFSULI6Qg2NfbKXu1jKoPqhBugfEsI2l3pWH5npwlZOf1O6n9Vy1Zj2Ux5NdD+mW7/rFw+9xUN1WHhK3KWUWUPqqdYJkiTWiU/t/00xZXsYttF26jubCZse+NxfJ/Fpr2NVH+Wjnli8vx1fqIGh5F6p2pWG+2EpHU6iU0+nxsdzrJdzjIdzjY5nSy3enE4ZdeyHnx8SywWvmexUJc2xkhNm2Chx9u9WyefRauuQb6UZ4QfoGryEXT7iaZNpThWFmEo9aMQI9A0Giq5PCYGg6ZStjn3kdBSQH79u8LvYndaDSSk5NDdnZ2aDlu3Lh+EYgBQEEBLFkiK7SdRC53le6IWATyfWI7hBCeblnRBXpExObOhWXLICYGrrtOegUzZvSrDAwyWKSgoKBV2LZuZVtuLo0uWevSACNizIxOn8iwmGwyajIxl5ux+CzEEBS3ZL0UtCNSZFYkijaM17t/Pzz+OHzwAVgs8NRTcvBoG4/LFwjwdUMDm+x28p1Otjkc7GlqamllJVqjYYqI5rIVGsYvcxG524M31of/ch/N5zRTQQWHDh2isLAQu93Ogw88SOayTMpfL8d6q5WRfx2JRndqFfgDDccOB9su3Ibf6Wf4suH86as/8e233zJo0CCGDBnCoPRBmApN6L+IIGKjHiI0VF0Uxeqr9Xw20sXBNmOS4rVaWcmJjWVCTAxzzGaGtJl9B4ADB2S+e//9TvNdX+Nz+Gje09wqVnuCy71NCLfAjx8bNuri66iyVnEoej/7Kjexs3IvNf7WMXVD0tPJPvPMdqI1aNCg/ldZs9vhvffgjTfg22/lvf/vf+H887t12O6I2M+BDOQrVH7TLSu6QI+ImBCwYYO8ie+9J5u6Ro+WYnbTTZCS0jPG9hT5+fD66/DWWwQaGigcMoT8c88lLymJ/H37yMvLC4W/thAbFYs1zkqKPoUkbxJmu5kkVxKW4F+KIYWkEUnEjIlpJ25RI6PQxfbhAOBvv5U14q+/lpOfPvPMMWvEjS4Xq/btY8PybVT8Yxeu3CKq/RUURpZTqq3A7Wz/SjtdRAQZWVn4XC5KS0u56667uMd4D7XP15J4eSJj3xuLNrqfNb2eJtSvrmfHFTvQRGto/m0z9/76Xvbs2cOE7GxKy8uxVVW121/RR2AyWBnSbCXDbyU+IZ2Y2cMYccMZzDnzDManpnYegFBT09oCoNfD/ffLFgCjsQ+uVLYUuA+7adrd1E6wGnc1Un64nOrgX5VSRV18HbYoG1VKFZWuSiobKvH7/aFjGQwGzjjjDHKys8k2GsnZs4cJq1YR73LBpElyOMC8eX12bV1CCFizRpa5y5bJLoVx42SZe+ONskLRTXpiFvt7hBB/7rYlx6HH+8QcDukNvPEGrFsnQ2ovu0ze3Isukv+HA4dDCuzrr8uC3mCAa6+VGfScc44q5Ovq6igoKKC0tJTS0lJKSkrarVdUVHDkc4zWRmPRWLB4LSTRKnBWs5VEayJJGUkkD0rGMsxC7KBYDBkGmdIMaAw96MEIge+TT6h9+GGq9+yheswYqq+7jhqLhaqqKoqLiyksLKTwYCGlpaX4A60/aI2iIcOaQfqIwcRkZIDVSmNSEuWJiZSYzYjERNBoMHg86BcvxvH++0Rarcyd/XNufmcs9RMjKPp7GvFJBhL1ehJ0OhL0ehL1esw6HRGnQFRWf0UIgcPvx+bzUev1YvN6qfX5sHm9sLyBkT+sotbq46kpS9n90VvorFZiHn6YhpwceQCXi5jqagbX15NYU4OhshJvWRl1xaUU7Sukvql9H2FcdByDhw1myJAhDBkyhLS0NCxGI0lr12L56CMszc1YFiwg7je/QenBiEMhBL46H+5SN+5SN65SF3WFdVQdrKK6uJra8lqqKqqocleFxKpGU0ONtoYaX00oIrSFqKgoMjMzycjIICMjo936kCFDGDVq1NGT5dbXwzvvwGuvyUpvdDR8//vSy5w6NXytTBUVsrlw0SLYu1d2G3z/+7J87WG7uiNiTwJpwGEhxK96zKJO6NXAjl275M1euhSqqmRo7YIFcOutfTf9y5YtUrjeflsK2bhxMiPeeCMknPz0S16vl/Ly8pC4tRO54hJKikqoqD5a6FqIJpo44jBiJI444g3xmGPNJJgTSLQkkpiaiCXTQvLgZJJHJJMyKgURIaipqaG6urpd6mhbywwoHZGanIpVYyWpNgmr18qg9EGMv3o8E2+byOCxg9F30hTU7PdT4HSS73Sy0+mk1utl3+bNbH3iCVxFRWSdeQV/zL2DhvQYHn4eqjsIXIzTatsJW1pEBFONRqbFxTEhNva0F7lqj4eNdjsb7HZ2OJ3UthEsm8+Ht4P8dOmn8NM/wOdZ21nofQHP4RLSv/c9pjz0ENb4eNINhlCT4KDIyE6bwxoaGij4rIDcxbns+moXZZ4yaow1VMdWU9JQEgpkOJKIiAiSkpKwWCztUkfbzCYzDaUNVO6tpOpAFdVF1dQcrqGmsgZbrY26+jrqnfXYA3Za/hppxEfHU2dFGaLISM8ga0jWUSLVsjSbzSffBCgEbN4sxezdd2Ur04QJsvJ7441g6oOX1nq9sHy5LEv/8x8Z/TlzphSua6+V3Ti9wMmOEztDCLEjuD5eCLG9V6xrQ59EJ3q9cozTokXyYQQCcN558iFcc023OyCPwm6XGe6112DrVoiKkn11P/hBn/bVtQhdeXk5dXV12Gw2bDYbNeU1VJdUU1Neg63Khq3ORp29jvrmeuweO378xz94EC1a4pV4TFoTJo0Js9aMSWfCpDVh1psx6+X/CU6ByebBKIx4GIai9ZN8HqQ9Ohbjd6zdaudvbm7miSee4MUXXyTdks5PHD9lqnk6ho+HUz9MFyqAa4NLm9cbWi90uULBJpEaDZNjY5lmNDLdaGSa0UimwdD/+iB6CE8gQJ7DwQa7PSRcB4P9s1pgdHQ0yRERJOh00qsNerYtHq5ZpyPqxRpsvz7AW4Pe5p3it8nKyuKNN95gzpw53bLN1+Cl8qUCyl6vxFlqQEMTsB9bZID6BAN1Whd13jrqvfXU+eqo89VR76+XKSCTU3Qsep0RpYkiPjIeU4yJhPgEEhITSExJJCk9CUumhURLIgkJCSQkJJCYmEhGRgYmk6nv8kdjY2u5smWLLFeuvVZWis86q+fLlb17ZYvW0qXSA7NaW52AkSN79lwdcLIi9qAQ4ndHrvcmPSFilZXv0tx8gMjITAyGDAwGudRqOxCnsjLpDr/xhuwUNhple/Ntt8HkyUdnBCGgoUG2wbdNtbVHb2tJNpsUygkT5MwA8+b1TY2pBxBC0NjYSPXhair2VFC1v4rqQ9VUl1ajeBQSIhNIiEzAbDBjjjATp4tDEQrCLxB+AX4ZhSUCbdZbPmv2IA4exOzZiLV0EfpAHWg0MHGiDIM+5xyZkpJOyvZ169Zxyy23sHfvXq6IuoJ7DPcwffl04mfEH/N6S9zuUCG+wW5nq8OBKxhFmhoRERK06UYjU+LiiOlvwx26gBCCIpeLjY2NoevMbWzEHSwL0oPX2XKtk+PiiD7GdQq/YN+P9vHFn7/gd3G/o7ixmHvuuYfnnnuOuJOJEA4EZFj8N9/A6tVyWVGBAOzxM6gwzcOdOBIlI1UGMGlA0SqhhBYUTZt1rYIXL3XuOuo8ddS56rC5bTR4GohLjMOSZSF5aDIpI1JIGZ5CQlIChr6agqon2Lq1tYWnsVEKWlLS0SkxsfPtHUU0Op2yj+uNN2Sfl1YLl14qy8eLLz4qYEYIgddbjdtdittdgstVgttdQkbGjzEYutfE2xMi9oAQ4vfdsqIL9ISI7dx5A1VV7xy1XadLxGDICIpbZkjcDIZMIg0ZGL4tRLPoTfjHP6C5WYrO8OFHi5W/E89Er+84g1gs8sGfeWa/i5DsNzgcMhinpdDasAGCXgBjx0oxaxG2E3ilQ3NzM08++SQvvvgiFo2FhzQPseDDBSRd1nVh9AQCbGvxUIKF/v7mZkB6KGfExLQr8EdFR7eb1b8/0OjzsTloe4tAV3q9AERpNEyJi2v1OOPiyDiBEG2/y0/u9bk898/n+IiPGDR4EIsWLWLWrFldN9DrlQXxN9/ItGaN7AcCyMiQLSUteWD0aPV31BkOhyy/Cgo6rlDXH2MsYkxM+3IrOhq+/FKK4siRiFtvwXfD5bjivSGRak2lQcEqRYj2Ez8rip6cnFXEx5/drUs7WRFbAIwAAsBBIcTfu2VFF+ip5kS/33XEjW5fM3C7S/D5ju6n0estGHRpGKogckcl+ho/Oq0Rnc6M3pCELsqCLi4VnTEDnTkDbVJ660OPi1N/XD2F2y3b/ltq4WvWyB8TwODBsjBrEbURI45739evX8/N829m7/69XKpcyu9f/j2j7h110ubVeDx820YUNtrtNAQrN/FaLeeZTFxtsXBFYiLmMIR3CyHIdzj4sKaGT2pq2O50Egh+NjIqqp3ojo+JQX+SfX++Bh9Lz1/KE3lPUEYZ9957L8899xyxx5terKkJNm5sfb7r18ttIJum2j7fQYPU31VP4fPJlqGaGkR1FT5bCb66EnyNZficFfiaq/F5bHj99fgUJ+5RCbiHx+OOcuB2lxAINB9xQC0GQ7p0BNq1fLU6CRERySg9MLaxO4Ed0cF9TqxB+STp21exONvUIEraiV7LNr/ffsxjKIoBvd6MTmdGpzMFl3K97XatNhaNJhqtNgatNjq4Ho1G0/q/Rn33Vef4/XJWg5aa+urVcmA1yCETZ58tC7/Bg1tTVpZsVgnS3NzMk489yYt/fJFExcxvf/Ao17xwHj5fAz5fHT5fPYqiJyHhghNu+ggIwZ6mJjba7ay32/nMZqPE7UanKMw2mbjGYuH/kpJI7sXpfgJC8K3dzkc1NXxYXc1BlwsNcK7JxHnx8Uw3GplqNJJwgqIqhB+7fSMORy5abVwonzeWKTz43edZVvYpmZZMlnywhPPbjgUSQtb+Dx1qn/Ly5GBkr1eKU3Z2e0+7vw2B6UcIIQgE3AQCTfj9zuCy/Xog4MTns4fytM9Xh9fbut66vQFCVZuO0BARkdqm5apVoFoEKyLCiqL0TXP6SYtYX9Pfpp0KBDztCrnOM4Rcys9attVz7EzSHkWJaCNwMSGha1nXaKLQaAyhpCgt6xFt1tt+FnHEfgYUpWWb7oik72CbDkXR9nkggxB+AgEPQngIBLwI4UEIb/ttATei6ACB/C2IgjwCB3bhc1Thi/bjiyWUvEkGfIkR+OK1+KID+CI8bN/j4vnnoagILrkE7r4bjnQcYmMnk5R0OYmJlxEbO+mE74EQgk2NjXxYXc2H1dUcCArKzPh4rrFYuDop6YSa7DrDLwRrGhr4sLqaj6qrOezxoFcU5pjNXJOUxJVJSSc1R6XPZ8dm+4La2k+x2Zbj9da0+zw/H55/XnYpX3UV3HG7hjh9FDqXDp0DdHU+dDUudPV+dA7QN4LOCToRgzYxE2XsBDTjJ6FMmIjGmBjMfxFoNC3LiCO26XukNn8iCCEQwocQ3uDyyNS6XeZTN4GAh0DAHVx3B9c9ofXWz47er+V/v98ZFKOOhSo0y28X0Ggi21WsO6pgH13xltu02rh+FcTUHU+sZUSdTwjR/Rc/HYf+JmLdQYgAfn8jPl99m4zZPoMenVmPnYE7+lFwAtGDJ0PH4qYHjszgR+ajo/PV0XmtpaBoFawT+ZF2hjYQic5jQNesQWcX6GwedDXN6BoEOgf4GuC5/EH8vbAYS0QMr8wezaXTzsSXYaI2+QC1Mduxa3cDggidlcTEy0i0XInZPButNhqv10tlZSVlZWXtUnl5OWVlZTgcjnb2OP1+aoJRkE0tU41ptSTq9STp9USeQHOeAOp9vtDxfEKgAGadjqRg1KCuTeGj0WiwWCykpaWRlpZGampqaD0tLS0UUdfcfJDamk+orfoX9Y1rEHjREUeCZyJJ9WOJP5yAvegAj/7nWxbtLyQtMp7fTdRw9qC61kpDoh5fUiQ+k05ui/Ti0zYjlO7n0dbKlhQ22SN55D5H5smOCuH224TwdyhWJ1IBPRlaKpTtK52RbSqwR1dkj2y9ad+y03Z/Y7AFqJ9MP9UDdEfE/gfsBMYCW4QQj/aOiZKBJGJ9RYvnciI1QPC3qUF2VMs8Xg3U24k1J16ItNa0W2viiqIP1sY72tb6Wdt1WYOUqcOmWb9fzrQfbNYShYf45N0afrTrnxRRxAJFz++FFzdQBhRFw/7BcMgCpZFQXQ+1NWCrUqhrFEdJrVbRkGQwYYlIIloT01qgHrH0AW4hcAsRGmelVxQMGg0GjaadAIWeMTLAxB0I4BaCQFC4DBoNBkXBELqrorUOEDx2QPixeW1UeWpp7OAFpAYdJCWAOVkGqVkjYJAdhh6GYYchXciBornALUokh4SLubrL+NN1Y7FMTW9tvh00COKPjvyUTWBNoZYKv98RykPSu/YGCQ8otQAAEDNJREFU86qng23tP2vvnR8pMsevRB25TQjRrnIm81pHlbZjtVbog99tbek4fouIvl95OacC3RGxe4QQf1YU5R7AI4T4W28ZCaqIqfQ9h/52iMfveJz3xHsEOqh9KygkRRhJiookIclPwmAHCRkuGa3sTiWxaDJJO88h/uBEtGiIwIaWZpQueJQerQ5HdDT26CiaDbLWHOHzYmxuJtblxqvV0hgViSMykoCiQRvwE9vcTFxTEzHNLjRdOIdAgwczfmJpjqrFNv5rakeup8ZaQG1TM7XVCrUHjdjKIqlrCFDtbsTh7/jVLmmk8eTQJ7l5zc3dfo2KisqJcCwRO140gUFRlL8Ae4G1PW6ZikqYGXz7YBamLeT8a85nnXsdZmEmkUSSSCIh+KdDR4QpAoPFgN6oR5NajHfUN7isK3EZ/gPKp+g1KSQZziXRPxWjazA6rwGNVwGPRwYxtCzbrrfZVqYofJyUxIcpKXydlERAI1vyLS4X/1dRzDWVlcxqbCRCp5PDOSIi2i+P2Cb0Wvx6Hx59I7aob6jxr0XxbCIKL1kBM9ENFxNRdD4azzR8iQY8Hg8erwdvk5cmmqgN/tVQgw0bCgo3zLyBqZ9ORRevBiGp9B+O54nFA+MBjfpmZ5WBTOOWRqreq0KfpCciNSKUDGkGdGZdp80/Hk8NNttyams/wWb7Ar+/MfSZohiCTZzxbZIJrbZ1vaPtdhHN141+0vQKk2NA+O2hiDKZ5Lrf33CM7Q20bT6Ljh5DYuLlJCZejtE4vdNo2IAngKfCg6fcg7vcjadcrmsiNWTcn4H2/9u79+CoyjSP498nF3IFcjOZ4mZMSCCoA2GDWoJrLDFeuHgpBLUG5J9ltkp2jC7WzP6zbs261qpVsymZrXVxrI1x0TDrFFpABlkhVYuKLqwwME4IoagecMpBMEHEhJCk3/2jL4ZbLtidPif8PlVdOd19+j3POZA89Z5+3vdN99/gbvG/73M78RWgK7xfbZzii1ISEz8LBs9x6tT/0NXVel5SiWxHkkvkeaja7EolXSYxfpcck5PHk5qaT07OX5KRURqz8xQZad/nduLvwz/jXpko4ndJSWPIy5sPzB/S/sFgD30D9LK+K1i5OFklJ2erOECEwZPYfxNan3HGUBs0s6WEVoPeADxCqFa1C+gAmkdq4LSI1yUlpZKUlE9qan6iQxHxrcEGqMx2zrU4534zjDbTgR1ABaEe3FngT4QGdlxUg2tmq8xsj5ntORGZhUFERGQIBktij5vZv5rZL4bR5lngTkI9sCwgg9DQmzSg+MKdnXPrnHNVzrmqa2KwAqiIiFw9Brud+BTgnHMHh9qgc+7X/Z5+0m97yG2IiIgMxWWTmJmtAb4Bksxs4UisJyYiIjIcA91O7HPO/btz7t+I9wR9IiIiV2Cg24k/MLMfEpqWTesjiIiI5wyUxP4AVIa3W0YgFhERkWG5bBJzzr0+koGIiIgM18iuNCciIhJDSmIiIuJbSmIiIuJbSmIiIuJbSmIiIuJbSmIiIuJbSmIiIuJbSmIiIuJbSmIiIuJbgy3FIiIiCXT48GF6enoSHUZCpKamMnXq1AH3URITEfGwnp4eKioqEh1GQrS0DD5tr5KYiIjH1dbCvn0D7zNrFtTVhbafeeYZli9fzvvvv8+mTZtobm6moaGB/Px8brzxRl5++WVqamqoqamJf/Bxpu/ERERGmeuvv54PPviA9PR0Jk+ezKFDhwBYsGABEydOpKOjg6ampgRHGRvqiYmIeFykhzUc8+bNY+3atSxYsIB3332XwsJCtmzZQnt7O9OnT6etrY3Tp08zbty42Ac8gpTERERGmZUrVwLw6quvJjaQEaDbiSIi4ltKYiIi4lu6nSgi4nG1W2vZ9+eByxNn/WAWdfeEvjx76aWXyMzM5O233+aVV15hx44djBs3jrKyMj7++GOmTJnC+PHjOXz4MLfccgutra1kZmZSUlLC9OnTR+KUYkY9MRGRUcbMKCgooLCwkMbGRgCOHj3K2LFjo9WKvb29pKSkkJaWRmdnJ/fdd5/vEhioJyYi4nmRHtZQ5eTkcObMGWpqavjoo4+YPHkya9as4fXXX2fSpEkAdHR00NvbS1dXFxkZGTQ1NVFaWsq0adPicQpxY865RMcQVVVV5fbs2ZPoMEREPKOlpeWqnrGjoqICM/s/51zVpfbR7UQREfGtmN9ONLOlQC6wAXgECAJ/ACYCx5xzH8X6mCIicnWKR08sHdgBVACdwFmgxDm3AbhoOmIzW2Vme8xsz4kTJ+IQjoiIz9XWQnX1wI/a2ujuwWCQzZs389RTTxEIBIZ8mH2XmaCxvr4eCM3JuH//furr62lvb+eOO+4AoKGhgS1btnD06FHWrFnDtm3bhn2KVyoehR1ngTuBvUAWoZ5YS7iHduTCnZ1z64B1EPpOLA7xiIhcVZKSkli4cCEnT57kvffeIzk5mfnz5xMIBNi4cSPl5eWUlpZy7tw55syZw9q1a5k9ezYHDhwgLS2NhoYGiouLKSoqoru7O9puZE7GzMxMGhsbL5qXsa+vLzov40hNLhzzJOac+3W/p5/Eun0RkavOlUyeGHb33Xeza9cutm/fTmlpKZWVlQBEivr6+vooKSmhpaWFqVOnEgwGo2PKvv7664vamzdvHm+88QanT5/2xLyMqk4UEfEwVSeqOlFEREYpJTEREfEtzdghIuJxtW1t7DtzZsB9ZmVnU1dWBoSqE5uamti+fTtPPvkkxcXFQzrOvn37mDVr1kWv19fXs3LlyuicjIsXL+bpp5/mueeeS/i8jEpiIiKjTLyqEyNzMqakpJCVlUVjYyOFhYUcPXqU2bNnR6sVKysrz5uXccmSJXE7VyUxERGPi/SwrkQsqxNzcnJYtmwZr732Grfddpsn5mVUdaKIiIepOlHViSIiMkopiYmIiG/pOzEREY9rq23jzL6BqxOzZ2VTVhf67mzr1q309vYyYcIEZs+ePezjffHFF2zbto3c3FwWL158yX0CgQCBQIDq6mpaW1sv+X1XIBAgJyeH48ePx22dMiUxEZFR5ssvv2TFihUAvPjiiwAUFhaSm5uLmdHe3k5qaioFBQXs3r2b+fPns3//fsaMGcPKlSvZuXMny5YtIz09ncbGRrq7u6moqODNN98kOzub/Px87rrrLnbs2MHBgwdJT09n165d57V/5MgRKisrMTNOnTrF3r17o+2sX7+e8vJynnjiie99rkpiIiIeF+lhDVVBQQGbN29m4sSJmFn09fvvv5/6+noyMzPp6uqit7eXGTNmkJubS29vL8nJyQDMnTuXDRs2kJeXh5mRlBT65ikyhqy4uJjs7OyLjhtpv7u7mxMnTlBWVhadILh/O5EKyVhQdaKIiIepOlHViSIiMkopiYmIiG8piYmIeFxbWy1791YP+Ghr+25l58hKzBGXW7H5Uvp/drCVnpubm/n000+H1O6KFSv45ptveOihh2htbR1yDINRYYeIyCi0du1aJk2aREFBAVu2bKGvr4+mpiZuuukmPvzwQx599FHeeustJkyYQE5OTrRyEKCuro5gMBgtCmlububbb79l0aJFHDhwgM8//xyA3bt388ADD7B69WrmzJlDeno62dnZ7Ny5k5SUFEpKSrj99tspLS1l7ty5PP/881RVVbFr1y4yMjJYv3499957Lxs3biQrK4vKykrOnDlDR0fHkM9TSUxExOPKyoa/svPYsWN58MEHqa+vZ8KECQSDQSZPnkxRURElJSVkZGRE9+1fORh5fuzYMWpqaujp6QFg5syZdHd3n1ftWFhYSHl5OVVVVRQUFNDZ2QkQna2+urqaQCBAaWkpaWlpLFq0KFqt2NnZyZgxY+jp6SEtLY0bbrgh2u5wCg5VnSgi4mHxqk7sP1jZq4ZSnaiemIjIVai4uHjI64x5mQo7RETEt5TEREQ8rra2lurq6gEftbXer048fvw49fX1fPbZZzz22GM451i3bh2bNm3iq6++4uGHHx60cvFCup0oIjIKea06sbq6mnfeeYe0tDQaGxtJS0vj2LFjTJkyhXvuuYeOjo7oatHPPvvskM9TSUxExOPq6vxfnZiUlMR1110XTYJz586lubmZ7u5uNm3axKFDh6KrRQeDwfPiGYiqE0VEPEzViapOFBHxtb6+vugM87Hi9erEvr6+Ie2nJCYi4mF5eXnRAcJXm7y8vEH3iWkSM7NpwM3ACefcb81sAZAHfAz8GPiVc+5gLI8pIjKaFRUVUVRUlOgwPCsmSczMfgTcAtwNVACPhd/KB94ClgDHgGuAgxd8dhWwKvz0jJkNr77y0gqAkzFoZyT5LWbFG39+i9lv8YL/Yr5a4732cm/EtLDDzKYDc4CvgD8Bk4FcYD8wBShwzv1HzA54+Tj2XO5LQK/yW8yKN/78FrPf4gX/xax4LxbT24nhW4X9e1q/u8y2iIjI96YZO0RExLdGaxJbl+gAroDfYla88ee3mP0WL/gvZsV7AU8NdhYRERmO0doTExGRq4CSmIiI+NaoSGJmlm9mdeHtx81stZklhx9/Y2bLEx3jpYTjvt/Mngk/X2VmC83Ms/8uZlYdvsbXhJ8vMLPlZlaW6Nguxcwmha/x4vBzT19jM1tqZj82sxwz++vwOErPMrO5Zva3ZpZtZv9oZpWJjmkwZlZrZvPD2364xjPN7AUzu9YP19jMbjazvw9f2yXh1+aZ2TIzuzXWx/PkL/JQmdmPzOyXwE+AyMI3DmgFCoEioAWwS7eQGBfEfQ74r/BbnwMZQFaiYrucfjE/CXQSGsQIoQHtjYCnxq70i/evCA22PBF+y7PXOCwd2EFo0oBO4GxiwxmYc+5DoI9QnJEJDbzuGJBrZsn44xr/Dgg45/6ID66xc+4ToBd4H8gMv1zinNsATI318XydxJxz/+mcWw28AMwMD7ZOAqYBwfD2jASGeEmRuJ1zzwLXOucCZjYT+DOQw3cJwjP6XetaQr/0U8MxtwOPAENbGW+E9Iv3TWAp0O71axx2FriT0P/fLEIJ17PMrJbQH6wZwHHi8EcqDiJxXo8/rnEO0Glm5fjgGoenHywjNINTZ/j3LmBmS4EjMT+eqhNFRMSvfN0TExGRq5uSmIiI+JaSmIiI+JaSmIiI+JaSmEgcmVmdmeWZ2Qozqx7G535iZn831GNccYAiPhfTpVhE5CL/APwL8HvgXHhgeyfwdfi1nwM/BR53zv0MwMxSgDTgtJmNBx4ErgPGAb8iNCYvH7gJ+OfIgczsnwgNeUhxzr0wEicnkmjqiYnEkXPuFPBH4DVCSegkoSS0ldD4tZ3hn+39PvYAoSSVDzwafm0T0AD8BXCrc+4XwP9GPmBmBcAPCS1IOz5+ZyTiLUpiIiNnGqEZWpKdcyeBW4GNhFZD39Zvv9udcz9zzv0cmE5oxpleQrPRJAG7zOxp4Obw64Tb+4zQQO79I3M6Iomnwc4iPmNmU4E7CM048VPnXHeCQxJJGCUxERHxLd1OFBER31ISExER31ISExER31ISExER31ISExER3/p/EDn4KIVuWQYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "colors = [\"b\", \"g\", \"r\", \"c\", \"m\", \"y\", \"k\"]\n",
    "\n",
    "plt.rc('font', size=6)          # controls default text sizes\n",
    "plt.rc('axes', titlesize=6)     # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=6)    # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=4)    # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=4)    # fontsize of the tick labels\n",
    "plt.rc('figure', titlesize=10)  # fontsize of the figure title\n",
    "\n",
    "plt.ylim(0,np.max(drags))\n",
    "plt.title(\"Drag Coefficients vs Yaw\")\n",
    "plt.xlabel(\"Yaw Angle\")\n",
    "plt.ylabel(\"Drag Coefficient\")\n",
    "for i in range(len(airfoils)):\n",
    "    a_drag = np.hstack([drags[i][::-1],drags[i][1:]])\n",
    "    yaws = len(drags[i])\n",
    "    yaws = list(range(-yaws+1,yaws))\n",
    "    plt.plot(yaws,a_drag, label=names[i], c=colors[i])\n",
    "\n",
    "plt.gca().set_aspect(35, adjustable='box')\n",
    "plt.ylim(-.05, np.max(drags)+.01)\n",
    "plt.legend(loc=4, prop={'size': 4})\n",
    "plt.tight_layout()\n",
    "plt.savefig('dragyaw', dpi=1200)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3",
   "language": "python",
   "name": "py3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}