Smart-Energy-Routing-Algorithm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dharnai=0 Berka=1 Madanpur=2\n",
    "import math\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "villages = 4\n",
    "y=20\n",
    "\n",
    "solar_data = pd.read_csv('Solar.csv')\n",
    "s1_kw = list(solar_data['s1_kw'])\n",
    "load_data = pd.read_csv('Load_Data_Villages.csv')\n",
    "Dharnai_d = list(load_data['Dharnai_d'])\n",
    "Dharnai_i = list(load_data['Dharnai_i'])\n",
    "Berka_d = list(load_data['Berka_d'])\n",
    "Berka_i = list(load_data['Berka_i'])\n",
    "Madanpur_d = list(load_data['Madan_d'])\n",
    "Madanpur_i = list(load_data['Madan_i'])\n",
    "load = [[] for i in range(villages)]\n",
    "for i in range(y*8760):\n",
    "    load[0].append(Dharnai_d[i]+Dharnai_i[i])\n",
    "    load[1].append(Berka_d[i]+Berka_i[i])\n",
    "    load[2].append(Madanpur_d[i]+Madanpur_i[i])\n",
    "    load[3].append(0)\n",
    "    \n",
    "s1_kw = y*s1_kw\n",
    "PV_Size = [[56,73,75,77,78,82,83,85,88,90,92,95,97,100,102,106,108,108,108,108],\n",
    "           [16,18,21,23,26,28,31,33,36,38,41,44,46,49,52,55,57,57,57,57],\n",
    "           [16,18,19,21,23,24,26,28,29,31,33,35,36,38,39,41,42,42,42,42],\n",
    "          [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]\n",
    "Battery_Size = [[111,143,138,152,174,164,187,186,193,200,203,192,218,217,218,220,227,231,232,231],\n",
    "                [30,56,39,57,52,62,64,86,75,84,89,94,98,95,97,93,95,95,95,95],\n",
    "                [30,43,61,54,51,61,58,57,68,66,64,65,81,70,77,80,77,78,78,78],\n",
    "                [111,143,138,152,174,164,187,186,193,200,203,192,218,217,218,220,227,231,232,231]]\n",
    "\n",
    "Solar_added=[0,0,0,0]\n",
    "Battery_added=[0,0,0,0]\n",
    "\n",
    "solar = [[] for i in range(villages)]\n",
    "eff = [[] for i in range(villages)]\n",
    "tot_eff = []\n",
    "life_arr = [[] for i in range(villages)]\n",
    "rep = [[] for i in range(villages)]\n",
    "cost = [[] for i in range(villages)]\n",
    "solar_add_arr=[[] for i in range(villages)]\n",
    "batt_sub_arr=[[] for i in range(villages)]\n",
    "\n",
    "\n",
    "def Solar_Data(PV, solar_add, num):\n",
    "    for n in range(len(s1_kw)):\n",
    "        solar[num].append((PV[2]+solar_add[num])*s1_kw[n])\n",
    "    return\n",
    "\n",
    "Solar_Data(PV_Size[0],Solar_added,0); \n",
    "Solar_Data(PV_Size[1],Solar_added,1); \n",
    "Solar_Data(PV_Size[2],Solar_added,2);\n",
    "Solar_Data(PV_Size[3],Solar_added,3);\n",
    "\n",
    "Battery_Throughput =905\n",
    "Lifetime_Throughput = [0,0,0,0]\n",
    "Total_capacity = [0,0,0,0]\n",
    "capacity_Kw = [0,0,0,0]\n",
    "Battery_current = [0,0,0,0]\n",
    "Total_capacity_initial=Total_capacity\n",
    "decay_constant = [0,0,0,0]\n",
    "def Battery_Life(Battery, battery_add, num):\n",
    "    Lifetime_Throughput[num]=(Battery[2]+battery_add[num])*Battery_Throughput\n",
    "    Total_capacity[num]=(Battery[2]+battery_add[num])*2.4\n",
    "    Battery_current[num]=(Battery[2]+battery_add[num])*2.4\n",
    "    capacity_Kw[num]=(Battery[2]+battery_add[num])*2.4\n",
    "    return\n",
    "Battery_Life(Battery_Size[0],Battery_added, 0); Battery_Life(Battery_Size[1],Battery_added, 1);\n",
    "Battery_Life(Battery_Size[2],Battery_added, 2); Battery_Life(Battery_Size[3],Battery_added, 3); \n",
    "total_battery = [[] for i in range(villages)]\n",
    "for i in range(villages):\n",
    "    total_battery[i].append(Battery_Size[i][2]+Battery_added[i])\n",
    "soc = [100,100,100,100]\n",
    "SoC = [[] for i in range(villages)]\n",
    "kw_Excess = [[] for i in range(villages)]\n",
    "Percentage_Excess = [[] for i in range(villages)]\n",
    "Shortage = [[] for i in range(villages)]\n",
    "battery = [[] for i in range(villages)]\n",
    "Load_Serve = [[] for i in range(villages)]\n",
    "E_In = [[] for i in range(villages)]\n",
    "E_Out = [[] for i in range(villages)]\n",
    "load_serviced = 0\n",
    "dod = 15\n",
    "capacity_percent=[100,100,100,100]\n",
    "no_of_replacement = [0,0,0,0]\n",
    "replacement_year_list = [[] for i in range(villages)]\n",
    "replacement_hour = [0,0,0,0]\n",
    "replacement_year = [0,0,0,0]\n",
    "Throughput_hour = [0,0,0,0]\n",
    "No_of_Replacement = [0,0,0,0]\n",
    "Replacement_year = [[] for i in range(villages)]\n",
    "energy_balance = []\n",
    "Energy_Balance_Battery = Total_capacity\n",
    "excess=0\n",
    "canbeserved =[0 for i in range(villages)]\n",
    "canbeserved_arr=[[] for i in range(villages)]\n",
    "Battery_Life = [[] for i in range(villages)]\n",
    "\n",
    "for hour in range(y*8760):\n",
    "    b=0;c=0;\n",
    "    battery_current_before = sum(Battery_current)\n",
    "    load_deficit = [0 for i in range(villages)]\n",
    "    ex_signal = [0 for i in range(villages)]\n",
    "    empty = [0 for i in range(villages)]\n",
    "    soc_dummy = [0 for i in range(villages)]\n",
    "    cbs_dummy = [0 for i in range(villages)]\n",
    "    pv_excess_arr = [0 for i in range(villages)]\n",
    "    pv_hour = [solar[i][hour] for i in range(villages)]\n",
    "    Energy_In = [0 for i in range(villages)]\n",
    "    Energy_Out = [0 for i in range(villages)]\n",
    "    Load_Served = [0 for i in range(villages)]\n",
    "    shortage = [0 for i in range(villages)]\n",
    "    Kw_Excess = [0 for i in range(villages)]\n",
    "    signal =0\n",
    "\n",
    "    if (hour%24==7):\n",
    "        pv_pred = [[] for i in range (villages)]\n",
    "        for num in range(villages):\n",
    "            bat_dummy = Battery_current[num]\n",
    "            for h in range (hour,hour+48): \n",
    "                if (h<175200):\n",
    "                    if solar[num][h]>=load[num][h]:\n",
    "                        pv_pred[num].append(1)\n",
    "                        e_In=solar[num][h]-load[num][h]\n",
    "                        e_Out=0\n",
    "                        bat_dummy = e_In+bat_dummy-e_Out\n",
    "                    elif solar[num][h]<load[num][h]:\n",
    "                        pv_pred[num].append(0)\n",
    "                        if (solar[num][h]+bat_dummy-load[num][h])>=(dod*(Total_capacity[num])/100):\n",
    "                            e_Out=load[num][h]-solar[num][h]\n",
    "                            e_In=0\n",
    "                            bat_dummy=bat_dummy+e_In-e_Out\n",
    "                        else:\n",
    "                            e_Out=bat_dummy-(dod*Total_capacity[num])/100\n",
    "                            e_In=0\n",
    "                            bat_dummy=bat_dummy+e_In-e_Out\n",
    "                    if (bat_dummy>capacity_Kw[num]):\n",
    "                        bat_dummy=capacity_Kw[num]\n",
    "            canbeserved[num]=(bat_dummy-(Total_capacity[num])*dod/100)\n",
    "\n",
    "    if (hour<7):\n",
    "        pv_pred_arr = [0 for i in range(villages)]\n",
    "    else:\n",
    "        pv_pred_arr = [pv_pred[i][(hour+17)%24] for i in range(villages)]\n",
    "\n",
    "    for num in range (villages):\n",
    "        canbeserved_arr[num].append(canbeserved[num])\n",
    "\n",
    "    if((all(x == 0 for x in pv_pred_arr) == 1)):\n",
    "        for num in range (villages):\n",
    "            if (solar[num][hour]+Battery_current[num]-load[num][hour])>=(dod*(Total_capacity[num])/100):\n",
    "                Energy_Out[num]=load[num][hour]-solar[num][hour]\n",
    "                Energy_In[num]=0\n",
    "                Battery_current[num]=Battery_current[num]+Energy_In[num]-Energy_Out[num]\n",
    "                load_serviced=load[num][hour]\n",
    "                Load_Served[num]=(load_serviced)\n",
    "                shortage[num]=(0)\n",
    "                load_deficit[num]=0\n",
    "            else:\n",
    "                Energy_Out[num]=Battery_current[num]-(dod*Total_capacity[num])/100\n",
    "                Energy_In[num]=0\n",
    "                Battery_current[num]=Battery_current[num]+Energy_In[num]-Energy_Out[num]\n",
    "                load_serviced=solar[num][hour]+Energy_Out[num]\n",
    "                Load_Served[num]=(load_serviced)\n",
    "                shortage[num]=(load[num][hour]-load_serviced) \n",
    "                load_deficit[num]=(load[num][hour]-load_serviced)        \n",
    "\n",
    "            Kw_Excess[num]=(0)\n",
    "            soc[num]=(Battery_current[num]/Total_capacity[num])*100\n",
    "\n",
    "    elif ((all(x == 1 for x in pv_pred_arr) == 1)):\n",
    "        for num in range (villages):\n",
    "            Energy_In[num]=solar[num][hour]-load[num][hour]\n",
    "            Energy_Out[num]=0\n",
    "            Battery_current[num]=Energy_In[num]+Battery_current[num]-Energy_Out[num]\n",
    "            load_serviced=load[num][hour]\n",
    "            Load_Served[num]=(load_serviced)\n",
    "            shortage[num]=(0)\n",
    "\n",
    "            if (Battery_current[num]>capacity_Kw[num]):\n",
    "                Kw_Excess[num]=(Battery_current[num]- capacity_Kw[num])\n",
    "                Energy_In[num]=Energy_In[num] - Kw_Excess[num]\n",
    "                Battery_current[num]=capacity_Kw[num]\n",
    "                ex_signal[num]=1\n",
    "            else:\n",
    "                Kw_Excess[num]=(0)\n",
    "\n",
    "            soc[num]=(Battery_current[num]/Total_capacity[num])*100\n",
    "\n",
    "    else:\n",
    "        for num in range (villages):\n",
    "            if (solar[num][hour]>load[num][hour]):\n",
    "                load_serviced=load[num][hour]\n",
    "                Load_Served[num]=(load_serviced)\n",
    "                shortage[num]=(0)\n",
    "                pv_excess_arr[num]=solar[num][hour]-load[num][hour]\n",
    "                load_deficit[num]=0\n",
    "            else:\n",
    "                load_serviced=solar[num][hour]\n",
    "                Load_Served[num]=(load_serviced)\n",
    "                shortage[num]=(load[num][hour]-load_serviced)\n",
    "                pv_excess_arr[num]=0\n",
    "                load_deficit[num]=load[num][hour]-load_serviced\n",
    "\n",
    "        for i in range (villages):\n",
    "                soc_dummy[i] = soc[i]\n",
    "\n",
    "        while (sum(pv_excess_arr)!=0):\n",
    "            if ((all(x <= dod for x in soc_dummy) == 1)):\n",
    "                break\n",
    "            for i in range (villages):\n",
    "                soc_dummy[i] = soc[i]\n",
    "            while (1):\n",
    "                soc_max_index=soc_dummy.index(max([v for v in soc_dummy if v > dod]))\n",
    "                if (pv_excess_arr[soc_max_index]>0):\n",
    "                    break\n",
    "                else:\n",
    "                    soc_dummy[soc_max_index]=dod\n",
    "                if ((all(x <= dod for x in soc_dummy) == 1)):\n",
    "                    break\n",
    "            for num in range(villages):\n",
    "                load_deficit[num]=round(load_deficit[num],2)\n",
    "            if (sum(load_deficit)==0):\n",
    "                break\n",
    "            load_index = load_deficit.index(min([v for v in load_deficit if v > 0]))\n",
    "\n",
    "            if (pv_excess_arr[soc_max_index]>=load_deficit[load_index]):\n",
    "                Load_Served[load_index]+=load_deficit[load_index]\n",
    "                shortage[load_index]=0\n",
    "                pv_excess_arr[soc_max_index]-=load_deficit[load_index]\n",
    "                load_deficit[load_index]=0\n",
    "            else:\n",
    "                Load_Served[load_index]+=pv_excess_arr[soc_max_index]\n",
    "                shortage[load_index]-=pv_excess_arr[soc_max_index]\n",
    "                load_deficit[load_index]=shortage[load_index]\n",
    "                pv_excess_arr[soc_max_index]=0\n",
    "\n",
    "        if (sum(load_deficit)==0):\n",
    "            for num in range (villages):\n",
    "                Energy_In[num]=pv_excess_arr[num]\n",
    "                pv_excess_arr[num]=0\n",
    "                Energy_Out[num]=0\n",
    "                Battery_current[num]=Energy_In[num]+Battery_current[num]-Energy_Out[num]\n",
    "\n",
    "                if (Battery_current[num]>capacity_Kw[num]):\n",
    "                    Kw_Excess[num]=(Battery_current[num]- capacity_Kw[num])\n",
    "                    Energy_In[num]=Energy_In[num] - Kw_Excess[num]\n",
    "                    Battery_current[num]=capacity_Kw[num]\n",
    "                    ex_signal[num]=1\n",
    "                else:\n",
    "                    Kw_Excess[num]=(0)\n",
    "\n",
    "                soc[num]=(Battery_current[num]/Total_capacity[num])*100\n",
    "\n",
    "        else:\n",
    "            for num in range (villages):\n",
    "                if (load_deficit[num]>0):\n",
    "                    if (Battery_current[num]-load_deficit[num])>=(dod*(Total_capacity[num])/100):\n",
    "                        Energy_Out[num]=load_deficit[num]\n",
    "                        Energy_In[num]=0\n",
    "                        Battery_current[num]=Battery_current[num]+Energy_In[num]-Energy_Out[num]\n",
    "                        load_serviced=load[num][hour]\n",
    "                        Load_Served[num]+=load_deficit[num]\n",
    "                        shortage[num]=0\n",
    "                        load_deficit[num]=0\n",
    "                    elif (Battery_current[num]>(dod*Total_capacity[num])/100):\n",
    "                        Energy_Out[num]=Battery_current[num]-(dod*Total_capacity[num])/100\n",
    "                        Energy_In[num]=0\n",
    "                        Battery_current[num]=Battery_current[num]+Energy_In[num]-Energy_Out[num]\n",
    "                        load_serviced=Energy_Out[num]\n",
    "                        Load_Served[num]+=(load_serviced)\n",
    "                        shortage[num]-=(load_serviced) \n",
    "                        load_deficit[num]-=Energy_Out[num]\n",
    "                else:\n",
    "                    Energy_In[num]=pv_excess_arr[num]\n",
    "                    pv_excess_arr[num]=0\n",
    "                    Energy_Out[num]=0\n",
    "                    Battery_current[num]=Energy_In[num]+Battery_current[num]-Energy_Out[num]\n",
    "\n",
    "                soc[num]=(Battery_current[num]/Total_capacity[num])*100\n",
    "                Kw_Excess[num]=(0)  \n",
    "\n",
    "    while (sum(Kw_Excess)!=0):\n",
    "        for i in range (villages):\n",
    "            soc_dummy[i] = round(soc[i],2)\n",
    "        if (all(x == 100 for x in soc_dummy) == 1):\n",
    "            break\n",
    "        if (all(x == 1 for x in ex_signal) != 1):\n",
    "            for num in range (villages):\n",
    "                empty[num]=round (capacity_Kw[num]-Battery_current[num],2)\n",
    "            if (all(x == 0 for x in empty) != 1):\n",
    "                while (1):\n",
    "                    soc_min_index=soc_dummy.index(min([v for v in soc_dummy if v >= dod]))\n",
    "                    if (empty[soc_min_index]==0):\n",
    "                        soc_dummy[soc_min_index]=100\n",
    "                    else:\n",
    "                        break\n",
    "                    if (all(x == 100 for x in soc_dummy) == 1):\n",
    "                        break\n",
    "                if (all(x == 100 for x in soc_dummy) == 1):\n",
    "                    break\n",
    "                max_kw_excess=Kw_Excess.index(max([v for v in Kw_Excess if v>0]))\n",
    "                Energy_In[soc_min_index]+=Kw_Excess[max_kw_excess]\n",
    "                Battery_current[soc_min_index]+=Kw_Excess[max_kw_excess]\n",
    "                Kw_Excess[max_kw_excess]=0\n",
    "                soc[soc_min_index]=(Battery_current[soc_min_index]/Total_capacity[soc_min_index])*100\n",
    "\n",
    "                if (Battery_current[soc_min_index]>capacity_Kw[soc_min_index]):\n",
    "                    Kw_Excess[soc_min_index]+=Battery_current[soc_min_index]- capacity_Kw[soc_min_index]\n",
    "                    Energy_In[soc_min_index]-= Kw_Excess[soc_min_index]\n",
    "                    Battery_current[soc_min_index]=capacity_Kw[soc_min_index]\n",
    "                    soc[soc_min_index]=(Battery_current[soc_min_index]/Total_capacity[soc_min_index])*100\n",
    "                    ex_signal[soc_min_index]=1\n",
    "            else:\n",
    "                break\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    for num in range (villages):\n",
    "        cbs_dummy[num]=canbeserved[num]\n",
    "\n",
    "    while (sum(load_deficit)!=0):\n",
    "        if (sum(cbs_dummy)!=0 ):\n",
    "            for num in range(villages):\n",
    "                soc[num]=round(soc[num],2)\n",
    "            if (all(x <=dod for x in soc) == 1):\n",
    "                break\n",
    "            if (all(x ==0 for x in cbs_dummy) == 1):\n",
    "                break\n",
    "            while (1):\n",
    "                max_pred_served = cbs_dummy.index(max([v for v in cbs_dummy]))\n",
    "                if cbs_dummy[max_pred_served]==0:\n",
    "                    signal = 1\n",
    "                    break\n",
    "                if soc[max_pred_served]>dod:\n",
    "                    break\n",
    "                else:\n",
    "                    cbs_dummy[max_pred_served]=0\n",
    "                if (all(x ==0 for x in cbs_dummy) == 1):\n",
    "                    break \n",
    "            if (signal==1):\n",
    "                break\n",
    "            if (all(x ==0 for x in cbs_dummy) == 1):\n",
    "                break\n",
    "            for num in range(villages):\n",
    "                load_deficit[num]=round(load_deficit[num],2)\n",
    "            if sum(load_deficit)==0:\n",
    "                break\n",
    "            min_load_def = load_deficit.index(min([v for v in load_deficit if v>0]))\n",
    "            if (canbeserved[max_pred_served]>=load_deficit[min_load_def]):\n",
    "                if (Battery_current[max_pred_served]-load_deficit[min_load_def]) >= (dod*(Total_capacity[max_pred_served])/100):\n",
    "                    Load_Served[min_load_def]+=load_deficit[min_load_def]\n",
    "                    Energy_Out[max_pred_served]+=load_deficit[min_load_def]\n",
    "                    Battery_current[max_pred_served]-=load_deficit[min_load_def]\n",
    "                    canbeserved[max_pred_served]-=load_deficit[min_load_def]\n",
    "                    load_deficit[min_load_def]=0\n",
    "                    shortage[min_load_def]=0\n",
    "                else:\n",
    "                    dummy=Battery_current[max_pred_served]-(dod*(Total_capacity[max_pred_served])/100)\n",
    "                    Load_Served[min_load_def]+=dummy\n",
    "                    Energy_Out[max_pred_served]+=dummy\n",
    "                    canbeserved[max_pred_served]-=dummy\n",
    "                    load_deficit[min_load_def]-=dummy\n",
    "                    shortage[min_load_def]-=dummy\n",
    "                    Battery_current[max_pred_served]=(dod*(Total_capacity[max_pred_served])/100)\n",
    "            else:\n",
    "                if (Battery_current[max_pred_served]-canbeserved[max_pred_served]) >= (dod*(Total_capacity[max_pred_served])/100):\n",
    "                    Load_Served[min_load_def]+=canbeserved[max_pred_served]\n",
    "                    Energy_Out[max_pred_served]+=canbeserved[max_pred_served]\n",
    "                    Battery_current[max_pred_served]-=canbeserved[max_pred_served]\n",
    "                    load_deficit[min_load_def]-=canbeserved[max_pred_served]\n",
    "                    shortage[min_load_def]-=canbeserved[max_pred_served]\n",
    "                    canbeserved[max_pred_served]=0\n",
    "                else:\n",
    "                    dummy=Battery_current[max_pred_served]-(dod*(Total_capacity[max_pred_served])/100)\n",
    "                    Load_Served[min_load_def]+=dummy\n",
    "                    Energy_Out[max_pred_served]+=dummy\n",
    "                    canbeserved[max_pred_served]-=dummy\n",
    "                    load_deficit[min_load_def]-=dummy\n",
    "                    shortage[min_load_def]-=dummy\n",
    "                    Battery_current[max_pred_served]=(dod*(Total_capacity[max_pred_served])/100)\n",
    "            cbs_dummy[max_pred_served] =  canbeserved[max_pred_served]      \n",
    "            soc[max_pred_served]=(Battery_current[max_pred_served]/Total_capacity[max_pred_served])*100\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    for i in range(villages):\n",
    "        battery[i].append(Battery_current[i])\n",
    "        SoC[i].append(soc[i])\n",
    "        Load_Serve[i].append(Load_Served[i])\n",
    "        Shortage[i].append(shortage[i])\n",
    "        kw_Excess[i].append(Kw_Excess[i])\n",
    "        E_Out[i].append(Energy_Out[i]) \n",
    "        E_In[i].append(Energy_In[i])\n",
    "\n",
    "    excess= excess + sum(Kw_Excess) \n",
    "    e_bal =sum(pv_hour)+battery_current_before-sum(Load_Serve[i][hour] for i in range(villages))-sum(Battery_current)-sum(Kw_Excess)\n",
    "    energy_balance.append(e_bal)\n",
    "\n",
    "    for num in range(villages):\n",
    "        Throughput_hour[num]=round(Throughput_hour[num]+0.39*(Energy_In[num]+Energy_Out[num]),2)\n",
    "        capacity_percent[num]= round(100-(20*Throughput_hour[num]/Lifetime_Throughput[num]),2) \n",
    "        capacity_Kw[num]= round((capacity_percent[num]*Total_capacity[num]/100),2)\n",
    "        if(Battery_current[num]>capacity_Kw[num]):\n",
    "            Battery_current[num]=capacity_Kw[num]\n",
    "\n",
    "        if(Throughput_hour[num]>=Lifetime_Throughput[num]):\n",
    "            Life=((hour-replacement_hour[num])/8760)\n",
    "            Battery_Life[num].append(Life)\n",
    "            replacement_year[num]+=Life\n",
    "            no_of_replacement[num]+=1\n",
    "            dummy=int(hour/8760)+(3-int(hour/8760)%3)\n",
    "            if(dummy>y):\n",
    "                dummy=y\n",
    "            del solar[num][hour+1:y*8760]\n",
    "            for z in range(hour+1,(y*8760)):\n",
    "                solar[num].append((PV_Size[num][dummy-1]+Solar_added[num])*s1_kw[z])\n",
    "            Total_capacity[num]=(Battery_Size[num][dummy-1]+Battery_added[num])*2.4\n",
    "            capacity_Kw[num] = Total_capacity[num]\n",
    "            Lifetime_Throughput[num]=(Battery_Size[num][dummy-1]+Battery_added[num])*Battery_Throughput\n",
    "            total_battery[num].append(Battery_Size[num][dummy-1]+Battery_added[num])\n",
    "            Throughput_hour[num]=0\n",
    "            soc[num]=100\n",
    "            Battery_current[num]=Total_capacity[num]\n",
    "            replacement_hour[num]=hour+1\n",
    "\n",
    "tot_cost = 0\n",
    "print (\"Total efficiency: \",sum(Load_Serve[0]+Load_Serve[1]+Load_Serve[2])/(sum(load[0])+sum(load[1])+sum(load[2]))*100)\n",
    "for i in range(villages):\n",
    "    print (\"Village \",i+1)\n",
    "    T=0; C=0; L=0\n",
    "    PV_cap = 0\n",
    "    PO = 0\n",
    "    PV_add = 0\n",
    "    PV_total = 0\n",
    "    if(len(Battery_Life[i])==0):\n",
    "        L=0\n",
    "    else:\n",
    "        L=(sum(Battery_Life[i])+Battery_Life[i][len(Battery_Life[i])-1]-20)\n",
    "    C=300*(total_battery[i][0])\n",
    "    O=0;R=0\n",
    "    rep_c=300\n",
    "    S=20*(total_battery[i][len(total_battery[i])-1])*L\n",
    "    Battery_Life[i].append(20-sum(Battery_Life[i]))\n",
    "    for n in range(len(Battery_Life[i])):\n",
    "        O=O+(20*((total_battery[i][n])*Battery_Life[i][n]))\n",
    "        if n>0:\n",
    "            R=R+((total_battery[i][n])*rep_c)\n",
    "    T=C+O+R-S\n",
    "    PV_cap = (PV_Size[i][2]+Solar_added[i])*1500\n",
    "    PV_add = (PV_Size[i][len(PV_Size[i])-1] - PV_Size[i][2])*1500\n",
    "    for n in range(len(Battery_Life[i])):\n",
    "        PO=PO+(500*(PV_Year_Size[i][n]*Battery_Life[i][n]))\n",
    "    PV_total = PV_cap+PV_add+PO\n",
    "    tot_cost = tot_cost + PV_total+T\n",
    "    print (\"Total cost: \", PV_total+T)\n",
    "    if i <3:\n",
    "        print (\"Efficiency: \", (sum(Load_Serve[i])/sum(load[i]))*100)\n",
    "    print (\"No of Replacements: \", no_of_replacement[i])\n",
    "    #life_arr[i].append(sum(Battery_Life[i]))\n",
    "print (\"Total cost: \", tot_cost)"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}