LearningPySwarm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Particle Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import modules\n",
    "import numpy as np\n",
    "# Import PySwarms\n",
    "import pyswarms as ps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cost Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n# Driven Code \\nx = [ -1, 1, 3, 2 ] \\ny = [ 5, 6, 5, 3 ] \\nn = len(x) \\nprint(totaldistancesum(x, y, n) ) \\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python3 code to find sum of Manhattan \n",
    "# distances between all the pairs of \n",
    "# given points \n",
    "\n",
    "# Return the sum of distance of one axis. \n",
    "def distancesum (arr, n): \n",
    "\t\n",
    "\t# sorting the array. \n",
    "\tarr.sort() \n",
    "\t\n",
    "\t# for each point, finding \n",
    "\t# the distance. \n",
    "\tres = 0\n",
    "\tsum = 0\n",
    "\tfor i in range(n): \n",
    "\t\tres += (arr[i] * i - sum) \n",
    "\t\tsum += arr[i] \n",
    "\t\n",
    "\treturn res \n",
    "\t\n",
    "def totaldistancesum( x , y , n ): \n",
    "\treturn distancesum(x, n) + distancesum(y, n) \n",
    "'''\n",
    "# Driven Code \n",
    "x = [ -1, 1, 3, 2 ] \n",
    "y = [ 5, 6, 5, 3 ] \n",
    "n = len(x) \n",
    "print(totaldistancesum(x, y, n) ) \n",
    "'''\n",
    "# This code is contributed by \"Sharad_Bhardwaj\". \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\"\"\"\n",
    "Created on: xxxx\n",
    "@author   : Anon\n",
    "\n",
    "NAME\n",
    "    Farm_Evalautor.py\n",
    "    \n",
    "PYTHON VERSION   \n",
    "    3.7.3 \n",
    "    \n",
    "DESCRIPTION\n",
    "    Calculates Annual Energy Production (AEP) of a Wind Farm\n",
    "    ============================================================    \n",
    "    \n",
    "    This is vectorzied version of Farm_Evalautor.py. \n",
    "    Farm_Evalautor_Vec.py is a python file that calculates AEP (GWh)\n",
    "    of a certain arrangement of wind turbines in a farm, under \n",
    "    given annual wind conditions. \n",
    "    \n",
    "    The code in this script for wake-effect modeling is based on\n",
    "    standard Jensen (PARK) model. \n",
    "    I. Katic, J. Hojstrup and N. Jensen, \"A simple model for cluster \n",
    "    efficiency,\" in European Wind Energy Association Conference and \n",
    "    Exhibition, 1986.\n",
    "    \n",
    "    As its inputs, the code takes three data files containing info \n",
    "    about:\n",
    "    - Turbine Locations\n",
    "    - Turbine Power Curve\n",
    "    - Annual Wind Conditions\n",
    "    \n",
    "PACKAGE LIST\n",
    "    You may need to install the package Shapely in your\n",
    "    python distribution. These are not pre-installed. \n",
    "    =============================================================\n",
    "    Packages Used:\n",
    "    Numpy\n",
    "    Pandas\n",
    "    Shapely\n",
    "    math (built-in)\n",
    "    \n",
    "OPTIMIZATION USAGE\n",
    "    This vectorized version is faster than unvectorized version\n",
    "    Farm_Evalautor.py. Due to speed benefits, we advise you to use \n",
    "    the function getAEP in this script while developing the optimizer. \n",
    "    =============================================================\n",
    "    \n",
    "    One way to use getAEP function as AEP evaluator while optimizing is:\n",
    "    - STEP 1. Import the relevant function from Farm_Evalautor_Vec. \n",
    "              from Farm_Evalautor_Vec import getTurbLoc, loadPowerCurve, \n",
    "              binWindResourceData, preProcessing, getAEP\n",
    "    - STEP 2. Set Turbine Radius to 50.0. First arg of getAEP\n",
    "    - STEP 3. Load Turbine Locations. Using function getTurbLoc\n",
    "    - STEP 4. Load Power Curve. Using function loadPowerCurve\n",
    "    - STEP 5. Load wind instance probabilities. \n",
    "              Using function binWindResourceData\n",
    "    - STEP 6. Perform Preprocessing by calling function preProcessing.\n",
    "              We do preprocessing to avoid same repeating calculations.\n",
    "              Do them once. \n",
    "    - STEP 7. Finally, call function getAEP\n",
    "    \n",
    "    This makes it easy to control the reloading of data and hence achieve\n",
    "    better performance.      \n",
    "\"\"\"\n",
    "\n",
    "# Module List\n",
    "import numpy  as np\n",
    "import pandas as pd                     \n",
    "from   math   import radians as DegToRad       # Degrees to radians Conversion\n",
    "\n",
    "from shapely.geometry import Point             # Imported for constraint checking\n",
    "from shapely.geometry.polygon import Polygon\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "def getTurbLoc(turb_loc_file_name):\n",
    "    \"\"\" \n",
    "    -**-THIS FUNCTION SHOULD NOT BE MODIFIED-**-\n",
    "    \n",
    "    Returns x,y turbine coordinates\n",
    "    \n",
    "    :Called from\n",
    "        main function\n",
    "    \n",
    "    :param\n",
    "        turb_loc_file_name - Turbine Loc csv file location\n",
    "        \n",
    "    :return\n",
    "        2D array\n",
    "    \"\"\"\n",
    "    \n",
    "    df = pd.read_csv(turb_loc_file_name, sep=',', dtype = np.float32)\n",
    "    turb_coords = df.to_numpy(dtype = np.float32)\n",
    "    return(turb_coords)\n",
    "\n",
    "\n",
    "def loadPowerCurve(power_curve_file_name):\n",
    "    \"\"\"\n",
    "    -**-THIS FUNCTION SHOULD NOT BE MODIFIED-**-\n",
    "    \n",
    "    Returns a 2D numpy array with information about\n",
    "    turbine thrust coeffecient and power curve of the \n",
    "    turbine for given wind speed\n",
    "    \n",
    "    :called_from\n",
    "        main function\n",
    "    \n",
    "    :param\n",
    "        power_curve_file_name - power curve csv file location\n",
    "        \n",
    "    :return\n",
    "        Returns a 2D numpy array with cols Wind Speed (m/s), \n",
    "        Thrust Coeffecient (non dimensional), Power (MW)\n",
    "    \"\"\"\n",
    "    powerCurve = pd.read_csv(power_curve_file_name, sep=',', dtype = np.float32)\n",
    "    powerCurve = powerCurve.to_numpy(dtype = np.float32)\n",
    "    return(powerCurve)\n",
    "    \n",
    "\n",
    "def binWindResourceData(wind_data_file_name):\n",
    "    r\"\"\"\n",
    "    -**-THIS FUNCTION SHOULD NOT BE MODIFIED-**-\n",
    "    \n",
    "    Loads the wind data. Returns a 2D array with shape (36,15). \n",
    "    Each cell in  array is a wind direction and speed 'instance'. \n",
    "    Values in a cell correspond to probability of instance\n",
    "    occurence.  \n",
    "    \n",
    "    :Called from\n",
    "        main function\n",
    "        \n",
    "    :param\n",
    "        wind_data_file_name - Wind Resource csv file  \n",
    "        \n",
    "    :return\n",
    "        1-D flattened array of the 2-D array shown below. Values \n",
    "        inside cells, rough probabilities of wind instance occurence. \n",
    "        Along: Row-direction (drct), Column-Speed (s). Array flattened\n",
    "        for vectorization purpose. \n",
    "        \n",
    "                      |0<=s<2|2<=s<4| ...  |26<=s<28|28<=s<30|\n",
    "        |_____________|______|______|______|________|________|\n",
    "        | drct = 360  |  --  |  --  |  --  |   --   |   --   |\n",
    "        | drct = 10   |  --  |  --  |  --  |   --   |   --   |\n",
    "        | drct = 20   |  --  |  --  |  --  |   --   |   --   |\n",
    "        |   ....      |  --  |  --  |  --  |   --   |   --   |\n",
    "        | drct = 340  |  --  |  --  |  --  |   --   |   --   |\n",
    "        | drct = 350  |  --  |  --  |  --  |   --   |   --   |        \n",
    "    \"\"\"\n",
    "    \n",
    "    # Load wind data. Then, extracts the 'drct', 'sped' columns\n",
    "    df = pd.read_csv(wind_data_file_name)\n",
    "    wind_resource = df[['drct', 'sped']].to_numpy(dtype = np.float32)\n",
    "    \n",
    "    # direction 'slices' in degrees\n",
    "    slices_drct   = np.roll(np.arange(10, 361, 10, dtype=np.float32), 1)\n",
    "    ## slices_drct   = [360, 10.0, 20.0.......340, 350]\n",
    "    n_slices_drct = slices_drct.shape[0]\n",
    "    \n",
    "    # speed 'slices'\n",
    "    slices_sped   = [0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, \n",
    "                        18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0]\n",
    "    n_slices_sped = len(slices_sped)-1\n",
    "\n",
    "    \n",
    "    # placeholder for binned wind\n",
    "    binned_wind = np.zeros((n_slices_drct, n_slices_sped), \n",
    "                           dtype = np.float32)\n",
    "    \n",
    "    # 'trap' data points inside the bins. \n",
    "    for i in range(n_slices_drct):\n",
    "        for j in range(n_slices_sped):     \n",
    "            \n",
    "            # because we already have drct in the multiples of 10\n",
    "            foo = wind_resource[(wind_resource[:,0] == slices_drct[i])] \n",
    "\n",
    "            foo = foo[(foo[:,1] >= slices_sped[j]) \n",
    "                          & (foo[:,1] <  slices_sped[j+1])]\n",
    "            \n",
    "            binned_wind[i,j] = foo.shape[0]  \n",
    "    \n",
    "    wind_inst_freq   = binned_wind/np.sum(binned_wind)\n",
    "    wind_inst_freq   = wind_inst_freq.ravel()\n",
    "    \n",
    "    return(wind_inst_freq)\n",
    "\n",
    "\n",
    "def searchSorted(lookup, sample_array):\n",
    "    \"\"\"\n",
    "    -**-THIS FUNCTION SHOULD NOT BE MODIFIED-**-\n",
    "    \n",
    "    Returns lookup indices for closest values w.r.t sample_array elements\n",
    "    \n",
    "    :called_from\n",
    "        preProcessing, getAEP\n",
    "    \n",
    "    :param\n",
    "        lookup       - The lookup array\n",
    "        sample_array - Array, whose elements need to be matched\n",
    "                       against lookup elements. \n",
    "        \n",
    "    :return\n",
    "        lookup indices for closest values w.r.t sample_array elements \n",
    "    \"\"\"\n",
    "    lookup_middles = lookup[1:] - np.diff(lookup.astype('f'))/2\n",
    "    idx1 = np.searchsorted(lookup_middles, sample_array)\n",
    "    indices = np.arange(lookup.shape[0])[idx1]\n",
    "    return indices\n",
    "\n",
    "   \n",
    "\n",
    "def preProcessing(power_curve):\n",
    "    \"\"\"\n",
    "    -**-THIS FUNCTION SHOULD NOT BE MODIFIED-**-\n",
    "    \n",
    "    Doing preprocessing to avoid the same repeating calculations.\n",
    "    Record the required data for calculations. Do that once.\n",
    "    Data are set up (shaped) to assist vectorization. Used later in\n",
    "    function totalAEP. \n",
    "    \n",
    "    :called_from\n",
    "        main function\n",
    "    \n",
    "    :param\n",
    "        power_curve - 2D numpy array with cols Wind Speed (m/s), \n",
    "                      Thrust Coeffecient (non dimensional), Power (MW)\n",
    "        \n",
    "    :return\n",
    "        n_wind_instances  - number of wind instances (int)\n",
    "        cos_dir           - For coordinate transformation \n",
    "                            2D Array. Shape (n_wind_instances,1)\n",
    "        sin_dir           - For coordinate transformation \n",
    "                            2D Array. Shape (n_wind_instances,1)\n",
    "        wind_sped_stacked - column staked all speed instances n_turb times. \n",
    "        C_t               - 3D array with shape (n_wind_instances, n_turbs, n_turbs)\n",
    "                            Value changing only along axis=0. C_t, thrust coeff.\n",
    "                            values for all speed instances. \n",
    "    \"\"\"\n",
    "    # number of turbines\n",
    "    n_turbs       =   50\n",
    "    \n",
    "    # direction 'slices' in degrees\n",
    "    slices_drct   = np.roll(np.arange(10, 361, 10, dtype=np.float32), 1)\n",
    "    ## slices_drct   = [360, 10.0, 20.0.......340, 350]\n",
    "    n_slices_drct = slices_drct.shape[0]\n",
    "    \n",
    "    # speed 'slices'\n",
    "    slices_sped   = [0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, \n",
    "                        18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0]\n",
    "    n_slices_sped = len(slices_sped)-1\n",
    "    \n",
    "    # number of wind instances\n",
    "    n_wind_instances = (n_slices_drct)*(n_slices_sped)\n",
    "    \n",
    "    # Create wind instances. There are two columns in the wind instance array\n",
    "    # First Column - Wind Speed. Second Column - Wind Direction\n",
    "    # Shape of wind_instances (n_wind_instances,2). \n",
    "    # Values [1.,360.],[3.,360.],[5.,360.]...[25.,350.],[27.,350.],29.,350.]\n",
    "    wind_instances = np.zeros((n_wind_instances,2), dtype=np.float32)\n",
    "    counter = 0\n",
    "    for i in range(n_slices_drct):\n",
    "        for j in range(n_slices_sped): \n",
    "            \n",
    "            wind_drct =  slices_drct[i]\n",
    "            wind_sped = (slices_sped[j] + slices_sped[j+1])/2\n",
    "            \n",
    "            wind_instances[counter,0] = wind_sped\n",
    "            wind_instances[counter,1] = wind_drct\n",
    "            counter += 1\n",
    "\n",
    "\t# So that the wind flow direction aligns with the +ve x-axis.\t\t\t\n",
    "    # Convert inflow wind direction from degrees to radians\n",
    "    wind_drcts =  np.radians(wind_instances[:,1] - 90)\n",
    "    # For coordinate transformation \n",
    "    cos_dir = np.cos(wind_drcts).reshape(n_wind_instances,1)\n",
    "    sin_dir = np.sin(wind_drcts).reshape(n_wind_instances,1)\n",
    "    \n",
    "    # create copies of n_wind_instances wind speeds from wind_instances\n",
    "    wind_sped_stacked = np.column_stack([wind_instances[:,0]]*n_turbs)\n",
    "   \n",
    "    # Pre-prepare matrix with stored thrust coeffecient C_t values for \n",
    "    # n_wind_instances shape (n_wind_instances, n_turbs, n_turbs). \n",
    "    # Value changing only along axis=0. C_t, thrust coeff. values for all \n",
    "    # speed instances.\n",
    "    # we use power_curve data as look up to estimate the thrust coeff.\n",
    "    # of the turbine for the corresponding closest matching wind speed\n",
    "    indices = searchSorted(power_curve[:,0], wind_instances[:,0])\n",
    "    C_t     = power_curve[indices,1]\n",
    "    # stacking and reshaping to assist vectorization\n",
    "    C_t     = np.column_stack([C_t]*(n_turbs*n_turbs))\n",
    "    C_t     = C_t.reshape(n_wind_instances, n_turbs, n_turbs)\n",
    "    \n",
    "    return(n_wind_instances, cos_dir, sin_dir, wind_sped_stacked, C_t)\n",
    "\n",
    "\n",
    "def getAEP(turb_coords):#turb_rad, turb_coords, power_curve, wind_inst_freq, \n",
    "            #n_wind_instances, cos_dir, sin_dir, wind_sped_stacked, C_t):\n",
    "    coordinates=[]\n",
    "    coordinates_particles=[]\n",
    "    for j in range(50):\n",
    "        coordinates=[]\n",
    "        for i in range(0,100,2):\n",
    "            coordinates.append([turb_coords[j][i],turb_coords[j][i+1]])\n",
    "        coordinates_particles.append(coordinates)\n",
    "    coordinates_particles=np.asarray(coordinates_particles)\n",
    "#################################################################################333\n",
    "    turb_specs    =  {   \n",
    "                         'Name': 'Anon Name',\n",
    "                         'Vendor': 'Anon Vendor',\n",
    "                         'Type': 'Anon Type',\n",
    "                         'Dia (m)': 100,\n",
    "                         'Rotor Area (m2)': 7853,\n",
    "                         'Hub Height (m)': 100,\n",
    "                         'Cut-in Wind Speed (m/s)': 3.5,\n",
    "                         'Cut-out Wind Speed (m/s)': 25,\n",
    "                         'Rated Wind Speed (m/s)': 15,\n",
    "                         'Rated Power (MW)': 3\n",
    "                     }\n",
    "    turb_diam      =  turb_specs['Dia (m)']\n",
    "    turb_rad       =  turb_diam/2 \n",
    "    \n",
    "    # Turbine x,y coordinatesfrom pyswarms.utils.plotters.formatters import Mesher\n",
    "    ##turb_coords   =  getTurbLoc(r'turbine_loc_test.csv')\n",
    "    \n",
    "    # Load the power curve\n",
    "    power_curve   =  loadPowerCurve('power_curve.csv')\n",
    "    \n",
    "    # Pass wind data csv file location to function binWindResourceData.\n",
    "    # Retrieve probabilities of wind instance occurence.\n",
    "    wind_inst_freq =  binWindResourceData(r'wind_data_2007.csv')   \n",
    "    \n",
    "    # Doing preprocessing to avoid the same repeating calculations. Record \n",
    "    # the required data for calculations. Do that once. Data are set up (shaped)\n",
    "    # to assist vectorization. Used later in function totalAEP.\n",
    "    n_wind_instances, cos_dir, sin_dir, wind_sped_stacked, C_t = preProcessing(power_curve)\n",
    "####################################################################    \n",
    "    \"\"\"\n",
    "    -**-THIS FUNCTION SHOULD NOT BE MODIFIED-**-\n",
    "    \n",
    "    Calculates AEP of the wind farm. Vectorised version.\n",
    "    \n",
    "    :called from\n",
    "        main\n",
    "        \n",
    "    :param\n",
    "        turb_diam         - Radius of the turbine (m)\n",
    "        turb_coords       - 2D array turbine euclidean x,y coordinates\n",
    "        power_curve       - For estimating power. \n",
    "        wind_inst_freq    - 1-D flattened with rough probabilities of \n",
    "                            wind instance occurence.\n",
    "                            n_wind_instances  - number of wind instances (int)\n",
    "        cos_dir           - For coordinate transformation \n",
    "                            2D Array. Shape (n_wind_instances,1)\n",
    "        sin_dir           - For coordinate transformation \n",
    "                            2D Array. Shape (n_wind_instances,1)\n",
    "        wind_sped_stacked - column staked all speed instances n_turb times. \n",
    "        C_t               - 3D array with shape (n_wind_instances, n_turbs, n_turbs)\n",
    "                            Value changing only along axis=0. C_t, thrust coeff.\n",
    "                            values for all speed instances. \n",
    "    \n",
    "    :return\n",
    "        wind farm AEP in Gigawatt Hours, GWh (float)\n",
    "    \"\"\"\n",
    "    cost=[]\n",
    "    \n",
    "    for i in coordinates_particles:\n",
    "        #print(len(i))\n",
    "        jasper=np.transpose(i)\n",
    "        t=turb_coords=i\n",
    "    # number of turbines\n",
    "        n_turbs        =   turb_coords.shape[0]\n",
    "        assert n_turbs ==  50, \"Error! Number of turbines is not 50.\"\n",
    "\n",
    "        # Prepare the rotated coordinates wrt the wind direction i.e downwind(x) & crosswind(y) \n",
    "        # coordinates wrt to the wind direction for each direction in wind_instances array\n",
    "        rotate_coords   =  np.zeros((n_wind_instances, n_turbs, 2), dtype=np.float32)\n",
    "        # Coordinate Transformation. Rotate coordinates to downwind, crosswind coordinates\n",
    "        rotate_coords[:,:,0] =  np.matmul(cos_dir, np.transpose(turb_coords[:,0].reshape(n_turbs,1))) - \\\n",
    "                               np.matmul(sin_dir, np.transpose(turb_coords[:,1].reshape(n_turbs,1)))\n",
    "        rotate_coords[:,:,1] =  np.matmul(sin_dir, np.transpose(turb_coords[:,0].reshape(n_turbs,1))) +\\\n",
    "                               np.matmul(cos_dir, np.transpose(turb_coords[:,1].reshape(n_turbs,1)))\n",
    "\n",
    "\n",
    "        # x_dist - x dist between turbine pairs wrt downwind/crosswind coordinates)\n",
    "        # for each wind instance\n",
    "        x_dist = np.zeros((n_wind_instances,n_turbs,n_turbs), dtype=np.float32)\n",
    "        for i in range(n_wind_instances):\n",
    "            tmp = rotate_coords[i,:,0].repeat(n_turbs).reshape(n_turbs, n_turbs)\n",
    "            x_dist[i] = tmp - tmp.transpose()\n",
    "\n",
    "\n",
    "        # y_dist - y dist between turbine pairs wrt downwind/crosswind coordinates)\n",
    "        # for each wind instance    \n",
    "        y_dist = np.zeros((n_wind_instances,n_turbs,n_turbs), dtype=np.float32)\n",
    "        for i in range(n_wind_instances):\n",
    "            tmp = rotate_coords[i,:,1].repeat(n_turbs).reshape(n_turbs, n_turbs)\n",
    "            y_dist[i] = tmp - tmp.transpose()\n",
    "        y_dist = np.abs(y_dist) \n",
    "\n",
    "\n",
    "        # Now use element wise operations to calculate speed deficit.\n",
    "        # kw, wake decay constant presetted to 0.05\n",
    "        # use the jensen's model formula. \n",
    "        # no wake effect of turbine on itself. either j not an upstream or wake \n",
    "        # not happening on i because its outside of the wake region of j\n",
    "        # For some values of x_dist here RuntimeWarning: divide by zero may occur\n",
    "        # That occurs for negative x_dist. Those we anyway mark as zeros. \n",
    "        sped_deficit = (1-np.sqrt(1-C_t))*((turb_rad/(turb_rad + 0.05*x_dist))**2) \n",
    "        sped_deficit[((x_dist <= 0) | ((x_dist > 0) & (y_dist > (turb_rad + 0.05*x_dist))))] = 0.0\n",
    "\n",
    "\n",
    "        # Calculate Total speed deficit from all upstream turbs, using sqrt of sum of sqrs\n",
    "        sped_deficit_eff  = np.sqrt(np.sum(np.square(sped_deficit), axis = 2))\n",
    "\n",
    "\n",
    "        # Element wise multiply the above with (1- sped_deficit_eff) to get\n",
    "        # effective windspeed due to the happening wake\n",
    "        wind_sped_eff     = wind_sped_stacked*(1.0-sped_deficit_eff)\n",
    "\n",
    "\n",
    "        # Estimate power from power_curve look up for wind_sped_eff\n",
    "        indices = searchSorted(power_curve[:,0], wind_sped_eff.ravel())\n",
    "        power   = power_curve[indices,2]\n",
    "        power   = power.reshape(n_wind_instances,n_turbs)\n",
    "\n",
    "        # Farm power for single wind instance \n",
    "        power   = np.sum(power, axis=1)\n",
    "\n",
    "        # multiply the respective values with the wind instance probabilities \n",
    "        # year_hours = 8760.0\n",
    "        AEP = 8760.0*np.sum(power*wind_inst_freq)\n",
    "\n",
    "        # Convert MWh to GWh\n",
    "        AEP = AEP/1e3\n",
    "        cost.append(-AEP-totaldistancesum(jasper[0], jasper[1], len(jasper[0])))\n",
    "    return(cost)\n",
    "    \n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "turb_coords   =  getTurbLoc(r'Result1322.csv')\n",
    "t=np.transpose(turb_coords)\n",
    "len(t[0])\n",
    "tur=[]\n",
    "caleb=[]\n",
    "for kal in range(len(t[0])):\n",
    "    #caleb=np.zeros(kal*2).tolist()\n",
    "    caleb.append(t[0][kal])\n",
    "    caleb.append(t[1][kal])\n",
    "    #caleb=caleb+np.zeros(np.abs(len(t[0])-i-1)*2).tolist()\n",
    "    #tur.append(caleb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizer Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost_function(x):\n",
    "    print(len(x))\n",
    "    return x.sum()\n",
    "x_max = 3950 * np.ones(100)\n",
    "x_min = 50 * np.ones(100)\n",
    "bounds = (x_min, x_max)\n",
    "#bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = {'c1': 0.5, 'c2': 0.3, 'w':0.9}\n",
    "#turb_coords   =  getTurbLoc(r'turbine_loc_test.csv')\n",
    "optimizer = ps.single.GlobalBestPSO(n_particles=50, dimensions=100, options=options,bounds = (x_min, x_max),init_pos=np.asarray([caleb]*50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Start Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-09-30 21:37:11,101 - pyswarms.single.global_best - INFO - Optimize for 50000 iters with {'c1': 0.5, 'c2': 0.3, 'w': 0.9}\n",
      "pyswarms.single.global_best: 100%|██████████|50000/50000, best_cost=-2.86e+6\n",
      "2020-10-01 20:17:57,308 - pyswarms.single.global_best - INFO - Optimization finished | best cost: -2856134.3934602356, best pos: [ 665.9102   803.4095  2430.4604  2027.8027  1188.3585  2345.9167\n",
      " 2256.8755  1716.8341  2250.582   3949.999   1017.6831  2643.8906\n",
      " 2252.0537  1720.4246  1191.2251  2339.5273  3312.6309  1725.5068\n",
      " 1555.1681  3559.5881  3132.6238   783.986    667.09436  801.86743\n",
      " 3503.866   2636.5405  2609.5808   504.46335  491.52008 1724.3265\n",
      " 3153.9468  2642.7002  2082.213   2633.7559  2005.6324  1998.2802\n",
      " 3141.89    3283.1738   486.4337  2938.0442   640.8381  1431.4202\n",
      " 3314.7874  1114.4419   672.95245  806.90485 2090.9934   199.27576\n",
      " 3513.0579  2628.6826  1892.9861  1100.5488  1198.4952  2336.2336\n",
      " 3128.567   3260.3943  2607.0903   502.97278 2614.9656  3563.6794\n",
      "  836.8301  1109.5973  1020.14044  804.18176 3310.6963  1113.7642\n",
      " 3478.7039  2662.5522  1535.87    1717.4219  1912.9128  1139.2545\n",
      " 2770.5713  1415.1865  1375.5736  3276.175   3499.6267  2648.6094\n",
      "  311.1319  2045.6466  2424.265   3257.117   3344.7808  1120.634\n",
      " 2613.4287   497.66333 2617.429   3572.0256  1567.389   1118.9905\n",
      " 1894.2189  1111.82     850.54236 2950.1814  2067.0369   196.15157\n",
      "  665.5271   806.18365 2004.5924  2029.4811 ]\n"
     ]
    }
   ],
   "source": [
    "cost, pos = optimizer.optimize(getAEP, iters=50000)#,kwargs={})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2856134.3934602356\n"
     ]
    }
   ],
   "source": [
    "print(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[665.9102, 803.4095],\n",
       " [2430.4604, 2027.8027],\n",
       " [1188.3585, 2345.9167],\n",
       " [2256.8755, 1716.8341],\n",
       " [2250.582, 3949.999],\n",
       " [1017.6831, 2643.8906],\n",
       " [2252.0537, 1720.4246],\n",
       " [1191.2251, 2339.5273],\n",
       " [3312.6309, 1725.5068],\n",
       " [1555.1681, 3559.5881],\n",
       " [3132.6238, 783.986],\n",
       " [667.09436, 801.86743],\n",
       " [3503.866, 2636.5405],\n",
       " [2609.5808, 504.46335],\n",
       " [491.52008, 1724.3265],\n",
       " [3153.9468, 2642.7002],\n",
       " [2082.213, 2633.7559],\n",
       " [2005.6324, 1998.2802],\n",
       " [3141.89, 3283.1738],\n",
       " [486.4337, 2938.0442],\n",
       " [640.8381, 1431.4202],\n",
       " [3314.7874, 1114.4419],\n",
       " [672.95245, 806.90485],\n",
       " [2090.9934, 199.27576],\n",
       " [3513.0579, 2628.6826],\n",
       " [1892.9861, 1100.5488],\n",
       " [1198.4952, 2336.2336],\n",
       " [3128.567, 3260.3943],\n",
       " [2607.0903, 502.97278],\n",
       " [2614.9656, 3563.6794],\n",
       " [836.8301, 1109.5973],\n",
       " [1020.14044, 804.18176],\n",
       " [3310.6963, 1113.7642],\n",
       " [3478.7039, 2662.5522],\n",
       " [1535.87, 1717.4219],\n",
       " [1912.9128, 1139.2545],\n",
       " [2770.5713, 1415.1865],\n",
       " [1375.5736, 3276.175],\n",
       " [3499.6267, 2648.6094],\n",
       " [311.1319, 2045.6466],\n",
       " [2424.265, 3257.117],\n",
       " [3344.7808, 1120.634],\n",
       " [2613.4287, 497.66333],\n",
       " [2617.429, 3572.0256],\n",
       " [1567.389, 1118.9905],\n",
       " [1894.2189, 1111.82],\n",
       " [850.54236, 2950.1814],\n",
       " [2067.0369, 196.15157],\n",
       " [665.5271, 806.18365],\n",
       " [2004.5924, 2029.4811]]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coordinates=[]\n",
    "for i in range(0,100,2):\n",
    "    coordinates.append([pos[i],pos[i+1]])\n",
    "coordinates    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "a = coordinates \n",
    "numpy.savetxt(\"Result1323.csv\", a, delimiter=\",\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}