artificial_storage_optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Artificial storage optimization\n",
    "This notebook also implements the optimization of the storage system, but it does not start with the boundary case of individual batteries at each household. Instead we only consider a fixed number of batteries in the neighborhood (smaller than number of houses)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from src.grid import Grid\n",
    "import random\n",
    "import multiprocessing\n",
    "from ipywidgets import IntProgress\n",
    "from IPython.display import display\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As input data we use consumption/production of specific houses, that were found to have reasonable consumption/production quantities. Also we set the timeframe to a short one of two weeks, such that the genetic algorithm runs faster than for a whole year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Consumption data\n",
    "df_cons = pd.read_csv('data/consumption_ausgrid.csv')\n",
    "df_cons['Unnamed: 0'] = pd.to_datetime(df_cons['Unnamed: 0'])\n",
    "df_cons = df_cons.set_index('Unnamed: 0')\n",
    "df_cons_red = df_cons.iloc[:,0]\n",
    "# Production data\n",
    "df_prod = pd.read_csv('data/generation_ausgrid.csv')\n",
    "df_prod['Unnamed: 0'] = pd.to_datetime(df_prod['Unnamed: 0'])\n",
    "df_prod = df_prod.set_index('Unnamed: 0')\n",
    "\n",
    "# Choose specific houses and time frame\n",
    "used_houses = [24, 30, 28, 8, 3, 33, 5, 21, 39, 11, 15, 17, 2, 36, 38, 6, 25, 16, 1, 32, 13, 10, 29, 20, 19, 22, 26, 18, 27, 14, 9, 31, 12, 0, 23, 37, 34, 4, 7, 35]\n",
    "\n",
    "week_start = 37\n",
    "week_end = 39\n",
    "df_cons = df_cons.iloc[7*48*week_start:7*48*week_end,used_houses]\n",
    "df_prod = df_prod.iloc[7*48*week_start:7*48*week_end,used_houses]\n",
    "\n",
    "data_cons = df_cons.values\n",
    "data_prod = df_prod.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can build the grid model. Since we only simulate 2 weeks, we need to set the costs accordingly. Therfore we define the timeframe after which the storages should pay off (i.e. 10 years) and calculate its investition cost for two weeks. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create grid model\n",
    "g = Grid(num_houses=df_cons.shape[1],\n",
    "         num_storages=df_cons.shape[1],\n",
    "         max_capacity=0,\n",
    "         num_pvtypes=df_prod.shape[1],\n",
    "         pv_peakpower=0)\n",
    "# Add each pv type to each house\n",
    "for i in range(df_cons.shape[1]):\n",
    "    g.change_pvtype(num_house=i,pv_type=i)\n",
    "\n",
    "# Set the costs for 2 weeks\n",
    "amortization_timeframe = 7*365 # in days\n",
    "storage_cost_per_kWh = 500\n",
    "storage_cost_per_kWh_per_day = storage_cost_per_kWh / amortization_timeframe\n",
    "cost_per_wire = 0 # Assume wires are already there\n",
    "loss_per_unit = 0.05 # 5% of power lost, when transferring to direct neighbor\n",
    "g.set_costs(cost_storage_kwh=14*storage_cost_per_kWh_per_day,loss_per_unit=loss_per_unit)\n",
    "g_initial = g.get_copy()\n",
    "# Simulate the grid\n",
    "res_dict_wo_storage = g.simulate(data_cons=data_cons,data_prod=data_prod)\n",
    "print(res_dict_wo_storage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see there is something going on with pv production and export. We still need an objective function that returns the cost for running this kind of grid for the specific timeframe. In this case the objective function is really easy, since we already defined the cost for setting up the storages in this two week interval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def objective_function(res_dict):\n",
    "    return res_dict['cost_import_grid'] + res_dict['setup_cost_storage'] - res_dict['reward_export_grid']\n",
    "\n",
    "# Calculate the cost of the above simulation\n",
    "cost_wo_storage = objective_function(res_dict_wo_storage)\n",
    "print('Cost without storage: ' + str(cost_wo_storage))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create an artificial grid with a specific number of storages and sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Capacities to simulate\n",
    "caps = np.linspace(0,5,20,dtype=float)\n",
    "\n",
    "population_size = 100\n",
    "population = []\n",
    "\n",
    "# Create grid model\n",
    "g = Grid(num_houses=df_cons.shape[1],\n",
    "         num_storages=5,\n",
    "         max_capacity=5,\n",
    "         num_pvtypes=df_prod.shape[1],\n",
    "         pv_peakpower=0)\n",
    "# Add each pv type to each house\n",
    "for i in range(df_cons.shape[1]):\n",
    "    g.change_pvtype(num_house=i,pv_type=i)\n",
    "g.set_costs(cost_storage_kwh=14*storage_cost_per_kWh_per_day,loss_per_unit=loss_per_unit)\n",
    "\n",
    "# Initialize population\n",
    "for i in range(population_size):\n",
    "    g_copy = g.get_copy()\n",
    "    g_copy.randomize(pv_types=False)\n",
    "    population.append(g_copy)\n",
    "\n",
    "# Calculate the objective function for each individual \n",
    "def get_cost(individual):\n",
    "    return objective_function(individual.simulate(data_cons,data_prod))\n",
    "# Calculate costs of all individuals\n",
    "pool = multiprocessing.Pool(100)\n",
    "costs_population = pool.map(get_cost,population)\n",
    "\n",
    "print('Initialized population')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We implement a genetic algorithm, to search for this optimal solution within the large state space. The parameters we can change are the number of storages, their sizes and the connection of the houses to the storages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The genetic algorithm needs no certain probabilities that will change the setup of the grid system. We give mutation and crossover probabilities to two different properties:\n",
    "\n",
    "    storage connections\n",
    "    storage capacity\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Probabilities\n",
    "prob_mut_connection = 0.25\n",
    "prob_mut_capacity = 0.25\n",
    "prob_cross_connection = 0.25\n",
    "prob_cross_capacity = 0.25\n",
    "perc_clone_best = 0\n",
    "\n",
    "# possible capacities\n",
    "possible_caps = np.linspace(0,5,20)\n",
    "\n",
    "# Other properties of the GA\n",
    "num_generations = 300\n",
    "\n",
    "# Mean, min and total number of connections\n",
    "mean_costs = np.zeros(num_generations)\n",
    "min_costs = np.zeros(num_generations)\n",
    "total_connections = np.zeros(num_generations)\n",
    "# Progressbar print\n",
    "print('|{}|'.format(' ' * (num_generations - 2)))\n",
    "# Loop through generations\n",
    "for i in range(num_generations):\n",
    "    # Update progress bar\n",
    "    print('*',end='',flush=True)\n",
    "    # Create mutations for connections\n",
    "    idx = random.sample(list(np.arange(population_size)),int(prob_mut_connection*population_size))\n",
    "    for k in idx:\n",
    "        g_copy = population[k].get_copy()\n",
    "        g_copy.mutate(num_house=-1,storage_connection=True)\n",
    "        population.append(g_copy)\n",
    "    # Create mutations for capacities\n",
    "    idx = random.sample(list(np.arange(population_size)),int(prob_mut_capacity*population_size))\n",
    "    for k in idx:\n",
    "        g_copy = population[k].get_copy()\n",
    "        g_copy.mutate(num_house=-1,storage_sizes=True,storage_cap_list=possible_caps)\n",
    "        population.append(g_copy)\n",
    "    # Create crossovers for connection\n",
    "    idx1 = random.sample(list(np.arange(population_size)),int(prob_cross_connection/2*population_size))\n",
    "    idx2 = random.sample(list(np.arange(population_size)),int(prob_cross_connection/2*population_size))\n",
    "    for j,k in zip(idx1,idx2):\n",
    "        g_copy = population[j].get_copy()\n",
    "        g_copy2 = population[k].get_copy()\n",
    "        g_copy2 = g_copy.crossover(g_copy2,storage_connection=True)\n",
    "        population.append(g_copy)\n",
    "        population.append(g_copy2)\n",
    "    # Create crossovers for capacity\n",
    "    idx1 = random.sample(list(np.arange(population_size)),int(prob_cross_capacity/2*population_size))\n",
    "    idx2 = random.sample(list(np.arange(population_size)),int(prob_cross_capacity/2*population_size))\n",
    "    for j,k in zip(idx1,idx2):\n",
    "        g_copy = population[j].get_copy()\n",
    "        g_copy2 = g_copy.crossover(population[k],storage_sizes=True)\n",
    "        population.append(g_copy)\n",
    "        population.append(g_copy2)\n",
    "    \n",
    "    # Calculate objective functions of the new populations\n",
    "    new_costs = pool.map(get_cost,population[population_size:])\n",
    "    costs_population = np.append(costs_population,new_costs)\n",
    "    \n",
    "    # Cloning the best ones\n",
    "    sort_idx = np.argsort(costs_population)\n",
    "    clone_idx = sort_idx[:int(perc_clone_best)*population_size]\n",
    "    for k in clone_idx:\n",
    "        g_copy = population[k].get_copy()\n",
    "        population.append(g_copy)\n",
    "        costs_population = np.append(costs_population,[costs_population[k]])\n",
    "\n",
    "    # Get the sorting indices\n",
    "    sort_idx = np.argsort(costs_population)\n",
    "    del_idx = sort_idx[population_size:]\n",
    "    # Remove the individuals with too high costs\n",
    "    for index in sorted(del_idx, reverse=True):\n",
    "        del population[index]\n",
    "    # Remove their costs from the population costs\n",
    "    costs_population = np.delete(costs_population,del_idx)\n",
    "    \n",
    "    \n",
    "    mean_costs[i] = np.mean(costs_population)\n",
    "    min_costs[i] = np.min(costs_population)\n",
    "    total_connections[i] = population[np.argmin(costs_population)].get_total_distance()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now plot the evoultion of the costs and compare to the boundary cases (taken from the storage_optimization.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.axhline(cost_wo_storage,label='Min - no storages',linestyle='dashed',c='r')\n",
    "plt.axhline(1411.420079560202,label='Min - individual storages',linestyle='dashed',c='g')\n",
    "plt.plot(mean_costs,label='Mean - Genetic')\n",
    "plt.plot(min_costs,label='Min - Genetic')\n",
    "plt.xlabel('Number of generation')\n",
    "plt.ylabel('Costs')\n",
    "plt.title('Cost optimization')\n",
    "plt.legend(loc=1)\n",
    "plt.savefig('plots/artificial_ga.png',dpi=200)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(total_connections)\n",
    "plt.xlabel('Number of generation')\n",
    "plt.title('Total connection length')\n",
    "plt.savefig('plots/genetic_optimization_distance.png',dpi=200)\n",
    "plt.show()"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}