Berka-base-design.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "VdFECQhlb5cU",
    "outputId": "73f957e7-6c87-4ff8-aeaa-98c9f42375d6"
   },
   "outputs": [],
   "source": [
    "import csv\n",
    "import random\n",
    "import pandas as pd\n",
    "import math\n",
    "load_data = pd.read_csv(\"Load_Data_Villages.csv\")\n",
    "solar_data = pd.read_csv('Solar.csv')\n",
    "s1_kw = list(solar_data['s1_kw'])\n",
    "\n",
    "#PV_Size=[16,19,20,23,26,28,31,33,36,38,41,44,46,48,51,53,55,55,55,55]\n",
    "#PV_Size=[13,16,18,20,22,24,27,29,31,33,35,38,40,42,43,46,47,47,47,47]\n",
    "PV_Size=[15,17,19,22,24,26,29,31,34,36,38,41,43,45,48,50,52,52,52,51]\n",
    "solar_1 = []\n",
    "solar_2 = []\n",
    "solar_3 = []\n",
    "solar_4 = []\n",
    "solar_5 = []\n",
    "solar_6 = []\n",
    "solar_7 = []\n",
    "solar_8 = []\n",
    "solar_9 = []\n",
    "solar_10 = []\n",
    "solar_11 = []\n",
    "solar_12 = []\n",
    "solar_13 = []\n",
    "solar_14 = []\n",
    "solar_15= []\n",
    "solar_16= []\n",
    "solar_17= []\n",
    "solar_18= []\n",
    "solar_19= []\n",
    "solar_20= []\n",
    "\n",
    "for i in range(8760):\n",
    "    solar_1.append(s1_kw[i]*PV_Size[0])\n",
    "    solar_2.append(s1_kw[i]*PV_Size[1])\n",
    "    solar_3.append(s1_kw[i]*PV_Size[2])\n",
    "    solar_4.append(s1_kw[i]*PV_Size[3])\n",
    "    solar_5.append(s1_kw[i]*PV_Size[4])\n",
    "    solar_6.append(s1_kw[i]*PV_Size[5])\n",
    "    solar_7.append(s1_kw[i]*PV_Size[6])\n",
    "    solar_8.append(s1_kw[i]*PV_Size[7])\n",
    "    solar_9.append(s1_kw[i]*PV_Size[8])\n",
    "    solar_10.append(s1_kw[i]*PV_Size[9])\n",
    "    solar_11.append(s1_kw[i]*PV_Size[10])\n",
    "    solar_12.append(s1_kw[i]*PV_Size[11])\n",
    "    solar_13.append(s1_kw[i]*PV_Size[12])\n",
    "    solar_14.append(s1_kw[i]*PV_Size[13])\n",
    "    solar_15.append(s1_kw[i]*PV_Size[14])\n",
    "    solar_16.append(s1_kw[i]*PV_Size[15])\n",
    "    solar_17.append(s1_kw[i]*PV_Size[16])\n",
    "    solar_18.append(s1_kw[i]*PV_Size[17])\n",
    "    solar_19.append(s1_kw[i]*PV_Size[18])\n",
    "    solar_20.append(s1_kw[i]*PV_Size[19])\n",
    "solar=solar_3*3+solar_6*3+solar_9*3+solar_12*3+solar_15*3+solar_18*3+solar_20*2\n",
    "#irrigation = load_data['irrigation'].values\n",
    "load = load_data['Berka_t'].values\n",
    "cl = load_data['Berka_i'].values\n",
    "ncl = load_data['Berka_d'].values\n",
    "print(len(solar))\n",
    "#print(len(irrigation))\n",
    "print(len(load))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KBM_nWA7b7Tq"
   },
   "outputs": [],
   "source": [
    "tot_eff =[]\n",
    "x_arr = []\n",
    "z_arr =[]\n",
    "tot_cost =[]\n",
    "excess_arr=[]\n",
    "rep_arr =[]\n",
    "for x in range (0,1):\n",
    "    for z in range (0,1):\n",
    "        y=20\n",
    "        replacement_year=[]\n",
    "        PV_Year_Size=[]\n",
    "        #PV_Size=[]\n",
    "        Default_Efficiency=[]\n",
    "        Modified_Efficiency=[]\n",
    "        Intelligent_Efficiency=[]\n",
    "        Life_Day=[]\n",
    "        #HOMER_Battery_Life_Year=[3.2730,2.4145,2.4100,2.4356,2.5195,2.4331,2.4022,2.4022] # Battery Life and No of Batteries from HOMER\n",
    "        #HOMER_Battery_Life_Year=[2.0789,2.4091,2.1354,1.8576,1.6836,2.4725,2.4468,2.4963,2.4963,2.4963]\n",
    "        HOMER_Battery_Life_Year=[2.6516,2.7114,2.1472,2.5699,2.3569,2.2402,2.2178,2.2181,2.2181,2.2181]\n",
    "        HOMER_Battery_Total_Capacity=[]\n",
    "        #HOMER_No_of_Batteries_Year=[37,34,53,54,45,52,64,51,63,76,76,82,82,74,70,81,81,81,81,81]\n",
    "        #HOMER_No_of_Batteries_Year=[30,35,58,57,52,61,63,85,74,83,88,93,97,110,110,114,115,116,116,116]\n",
    "        #HOMER_No_of_Batteries_Year=[42,31,31,42,48,53,48,57,60,64,80,74,74,80,78,89,104,104,104,104]\n",
    "        HOMER_No_of_Batteries_Year=[26,48,46,43,53,63,58,78,64,70,92,91,92,104,98,100,100,100,100,120]\n",
    "        HOMER_No_of_Replacement=8\n",
    "        HOMER_No_of_Batteries_Replacement_Year=[]\n",
    "        HOMER_Battery_Life_Day=[]\n",
    "        Capacity_Day=[]\n",
    "        Base_Efficiency_Year=[]\n",
    "        for n in range(HOMER_No_of_Replacement+1):\n",
    "            if n<6:\n",
    "                HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Year[((n+1)*3)-1])\n",
    "            else:\n",
    "                HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Year[19])\n",
    "        for n in range(HOMER_No_of_Replacement+1):\n",
    "            HOMER_Battery_Life_Day.append(round(HOMER_Battery_Life_Year[n]*365))\n",
    "            HOMER_Battery_Total_Capacity.append(round(HOMER_No_of_Batteries_Replacement_Year[n]*2.4))\n",
    "\n",
    "        for n in range(HOMER_No_of_Replacement+1):                                                                       # Capacity_Day Degradation for HOMER Battery Life\n",
    "            theeta=[]\n",
    "            for day in range(int(HOMER_Battery_Life_Day[n])):\n",
    "                theeta.append(((float(day)/HOMER_Battery_Life_Day[n])*90)*3.14159/180)\n",
    "                capacity=(20*math.exp(0.000258*(day))*math.cos(theeta[day]))+80\n",
    "                capacity=(capacity*HOMER_Battery_Total_Capacity[n])/100\n",
    "                if len(Capacity_Day)<=(20*365)-1:\n",
    "                    Capacity_Day.append(capacity)\n",
    "                else:\n",
    "                    break\n",
    "        HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Replacement_Year[len(HOMER_No_of_Batteries_Replacement_Year)-1])\n",
    "\n",
    "        for iteration in range(3):\n",
    "            No_of_batteries=HOMER_No_of_Batteries_Replacement_Year[0]\n",
    "            Bat=[No_of_batteries]                                                                                                        \n",
    "            Battery_Size=[]\n",
    "            battery=[]               \n",
    "            Load_Served=[]\n",
    "            Load_Shortage=[]\n",
    "            SoC_excess=[]\n",
    "            SoC=[]\n",
    "            Efficiency_Month=[]\n",
    "            Load_Served_Month=[]\n",
    "            Excess_Month=[]\n",
    "            Load_Month=[]\n",
    "            Life=[]\n",
    "            Load_Year=[]\n",
    "            Load_Served_Year=[]\n",
    "            Excess_Year=[]\n",
    "            Efficiency_Year=[]\n",
    "            In=[]\n",
    "            Out=[]\n",
    "            #Loss_Year=[3278,3569,3640,4736,4901,5896,6161,6305,7433,7611,8601,8856,8977,9595,9726,9784,9807,9813,9811,9802]\n",
    "            #Loss_Year=[2280,2722,3007,3440,3804,4158,4562,4971,5304,5652,6094,6521,6822,7184,7303,7888,8172,8176,8170,8169]\n",
    "            Loss_Year=[2543,3062,3390,3947,4264,4662,5108,5585,5945,6326,6834,7324,7659,8063,8505,8834,9145,9149,9145,9156]\n",
    "            AT=[]\n",
    "            CaP=[]\n",
    "            Total_Capacity=[]\n",
    "            load_served=0                          \n",
    "            Efficiency=0\n",
    "            soc=100 \n",
    "            l=0\n",
    "            p=0\n",
    "            count=0\n",
    "            No_of_Replacement=0\n",
    "            Lifetime_throughput=905*No_of_batteries\n",
    "            capacity=No_of_batteries*2.4\n",
    "            #print('before',capacity)\n",
    "            battery_current=capacity   \n",
    "            Battery_Size.append(No_of_batteries)\n",
    "            Total_Capacity.append(No_of_batteries*2.4)\n",
    "\n",
    "            for year in range(20):  \n",
    "\n",
    "                for day in range((year*365),(year*365)+365):\n",
    "\n",
    "                    if (day>(year*365)+30 and day<(year*365)+59) or (day>(year*365)+303 and day<(year*365)+365):            # Feb  Nov  Dec\n",
    "                        dod=15\n",
    "                    elif day>(year*365)+150 and day<(year*365)+181:                                                         # June\n",
    "                        dod=15\n",
    "                    elif day>(year*365)+180 and day<(year*365)+273:                                                         # July  Aug  Sep  \n",
    "                        dod=15\n",
    "                    else:\n",
    "                        dod=15\n",
    "\n",
    "                    for hour in range((day*24),(day*24)+24):\n",
    "\n",
    "                        if solar[hour]>=load[hour]:                                                                         # Run-Time Servicing\n",
    "                            energy_in=solar[hour]-load[hour]\n",
    "                            battery_current=energy_in+battery_current\n",
    "                            load_serviced=load[hour]\n",
    "                            Load_Served.append(load_serviced)\n",
    "                            shortage=0\n",
    "                            In.append(energy_in)\n",
    "                            Out.append(0)\n",
    "\n",
    "                        elif solar[hour]<load[hour]:\n",
    "                            if (solar[hour]+battery_current-load[hour])>=(dod*capacity)/100:\n",
    "                                energy_out=load[hour]-solar[hour]\n",
    "                                battery_current=battery_current-energy_out\n",
    "                                load_serviced=load[hour]\n",
    "                                Load_Served.append(load_serviced)\n",
    "                                shortage=0\n",
    "                                Out.append(energy_out)\n",
    "                                In.append(0)\n",
    "                            else:\n",
    "                                energy_out=battery_current-(dod*capacity)/100\n",
    "                                battery_current=battery_current-energy_out\n",
    "                                load_serviced=solar[hour]+energy_out\n",
    "                                Load_Served.append(load_serviced)\n",
    "                                shortage=load[hour]-load_serviced\n",
    "                                Out.append(energy_out)\n",
    "                                In.append(0)\n",
    "                        soc=(battery_current/capacity) * 100\n",
    "                        excess_KW=0\n",
    "                        if soc>(Capacity_Day[day]/capacity)*100:\n",
    "                            excess_percentage=soc-((Capacity_Day[day]/capacity)*100)\n",
    "                            excess_KW=(excess_percentage*capacity)/100\n",
    "                            battery_current=Capacity_Day[day]\n",
    "                            soc=(Capacity_Day[day]/capacity)*100\n",
    "                        SoC_excess.append(excess_KW)    \n",
    "                        Load_Shortage.append(shortage)\n",
    "                        battery.append(battery_current)\n",
    "                        SoC.append(soc)\n",
    "                        #print(soc,Capacity_Day[day],capacity)\n",
    "\n",
    "                AT.append((sum(In)+sum(Out)-Loss_Year[year])/2)\n",
    "                Lifetime_throughput=Lifetime_throughput-AT[year]\n",
    "                                                                          # Battery Replacement\n",
    "                if Lifetime_throughput<0:\n",
    "                    Lifetime_throughput=Lifetime_throughput+AT[year]\n",
    "                    No_of_Replacement=No_of_Replacement+1\n",
    "                    balance=AT[year]-Lifetime_throughput\n",
    "                    rem=Lifetime_throughput/AT[year]\n",
    "                    Life.append(count+rem)\n",
    "                    No_of_batteries=HOMER_No_of_Batteries_Replacement_Year[No_of_Replacement]\n",
    "                    Bat.append(No_of_batteries)\n",
    "                    Lifetime_throughput=905*No_of_batteries\n",
    "                    Lifetime_throughput=Lifetime_throughput-balance\n",
    "                    count=0-rem\n",
    "                    p=p+Life[len(Life)-1]\n",
    "                    replacement_year.append(p)\n",
    "                   # if iteration==0:\n",
    "                    #    print(No_of_batteries)\n",
    "                    Total_Capacity.append(No_of_batteries*2.4)\n",
    "\n",
    "                count=count+1\n",
    "                In=[]\n",
    "                Out=[]\n",
    "                #print(year,capacity)\n",
    "\n",
    "            theeta=[]\n",
    "            Days=[]\n",
    "            Capacity_Day=[]\n",
    "            if (len(Life)) ==0:\n",
    "                Life.append(20)\n",
    "                \n",
    "            for n in range(No_of_Replacement):\n",
    "                Days.append(round(Life[n]*365))\n",
    "            Days.append(round(Life[len(Life)-1]*365))\n",
    "            \n",
    "            if sum(Days)<7300:\n",
    "                Days.append(7300-sum(Days))\n",
    "                No_of_Replacement+=1\n",
    "                No_of_batteries=HOMER_No_of_Batteries_Replacement_Year[No_of_Replacement]\n",
    "                capacity=No_of_batteries*2.4\n",
    "                Total_Capacity.append(capacity)\n",
    "\n",
    "            for n in range(No_of_Replacement+1):\n",
    "                #print(n,Total_Capacity[n])\n",
    "                theeta=[]\n",
    "                for day in range(int(Days[n])):\n",
    "                    theeta.append(((float(day)/Days[n])*90)*3.14159/180)\n",
    "                    capacity=(20*math.exp(0.000258*(day))*math.cos(theeta[day]))+80\n",
    "                    capacity=(capacity*Total_Capacity[n])/100\n",
    "                    if len(Capacity_Day)<=(20*365)-1:\n",
    "                        Capacity_Day.append(capacity)\n",
    "                    else:\n",
    "                        break\n",
    "\n",
    "            if iteration==2:\n",
    "                tote=0\n",
    "                totls=0\n",
    "                totl=0\n",
    "                for n in range(20*8760):                    # Per Year Data Calculation\n",
    "                    if n%8759==0 and n>0:\n",
    "                        Excess_Year.append(tote)\n",
    "                        Load_Served_Year.append(totls)\n",
    "                        Load_Year.append(totl)\n",
    "                        tote=0\n",
    "                        totls=0\n",
    "                        totl=0\n",
    "                    tote=tote+SoC_excess[n]\n",
    "                    totls=totls+Load_Served[n]\n",
    "                    totl=totl+load[n]\n",
    "\n",
    "\n",
    "            b=sum(solar)+HOMER_No_of_Batteries_Year[2]*2.4                              # Energy Balance and Efficiency Calculation\n",
    "            c=sum(Load_Served)+sum(SoC_excess)+battery[(20*8760)-1]\n",
    "            Efficiency=100*(sum(Load_Served)/sum(load))\n",
    "\n",
    "            if iteration==2:\n",
    "                for year in range(20):\n",
    "                    Efficiency_Year.append(100*(Load_Served_Year[year]/Load_Year[year]))\n",
    "                    Base_Efficiency_Year.append(Efficiency_Year[year])\n",
    "        for n in range(len(Life)):\n",
    "            Life_Day.append(int(Life[n]*365))\n",
    "\n",
    "        for n in range(y):\n",
    "            Default_Efficiency.append(round(Efficiency_Year[n],2))\n",
    "        #print('\\t\\t\\t\\t\\t\\t\\t Loop 1')\n",
    "        #print('\\nOverall Efficiency  :',Efficiency,'%')\n",
    "        #print('Yearly Efficiency      :',Default_Efficiency)   \n",
    "        #print('No Of Batteries        :',No_of_batteries)\n",
    "        #print('Replacements           :',No_of_Replacement)\n",
    "        #print('Battery Life Year      :',Life,'yrs',sum(Life))\n",
    "        #print('Battery Life Day       :',Life_Day,sum(Life_Day))\n",
    "        L=(sum(Life)+Life[len(Life)-1]-20)\n",
    "        C=300*Bat[0]\n",
    "        O=0;R=0\n",
    "        rep=300\n",
    "        S=20*(Bat[len(Bat)-1])*L\n",
    "        Life.append(20-sum(Life))\n",
    "        #print(Bat)\n",
    "        for n in range(len(Bat)):\n",
    "            O=O+(20*(Bat[n]*Life[n]))\n",
    "            if n>0:\n",
    "                R=R+(Bat[n]*rep)\n",
    "        T=C+O+R-S\n",
    "        #print(C,' ',O,' ',R,' ',S,' ')\n",
    "       # print(T)\n",
    "\n",
    "        # 3.07949361055 1124 3.08000865799 1124.20316016 4\n",
    "        # 2.35172637448 858 5.43087633826 1982.26986346 6\n",
    "        # 2.55266187112 931 7.98352831245 2913.98783404 9\n",
    "        # 3.00578228112 1097 10.989345568 4011.11113234 12\n",
    "        # 2.39409561328 873 13.383318802 4884.91136274 14\n",
    "        # 2.67369708529 975 16.0563157843 5860.55526126 17\n",
    "        # 2.67224493389 975 18.731177475 6836.87977839 19\n",
    "        #print Load_Served_Year,len(Load_Served_Year)\n",
    "        #print 194099/sum(Load_Served_Year)\n",
    "        PV_Year=[3,6,9,12,15,18,18]\n",
    "        #for n in range(No_of_Replacement):\n",
    "         #   for m in range(2,21):\n",
    "          #      if replacement_year[n]>=(m) and replacement_year[n]<((m+1)):\n",
    "           #         PV_Year.append(m+1)\n",
    "\n",
    "        #Solar=[]\n",
    "        def New_Solar(PV):\n",
    "            Solar=[]\n",
    "            for i in range(8760):\n",
    "                Solar.append(s1_kw[i]*PV)\n",
    "            return Solar\n",
    "  \n",
    "        PV_Year_Size=[]\n",
    "        new_solar=[]\n",
    "        remain=0\n",
    "        #for n in range(No_of_Replacement):\n",
    "        for n in range (len(PV_Year)):\n",
    "            sol=[]\n",
    "            #print(n,PV_Year[n],PV_Size[PV_Year[n]-1]+x)\n",
    "            sol=New_Solar(PV_Size[PV_Year[n]-1]+x)\n",
    "            if (n == len(PV_Year)-1):\n",
    "                sol = sol*2\n",
    "            else:\n",
    "                sol = sol*3\n",
    "            PV_Year_Size.append(PV_Size[PV_Year[n]-1]+x)\n",
    "            #for m in range(int(Life[n]*8760)):\n",
    "             #   new_solar.append(sol[(m+remain)%8760])\n",
    "            #remain=(int(Life[n]*8760)%8760)\n",
    "            new_solar = new_solar + sol      \n",
    "            \n",
    "        #for i in range (5):\n",
    "         #   PV_Year_Size.append(PV_Year_Size[len(PV_Year_Size)-1])\n",
    "        #for n in range((20*8760)-len(new_solar)):\n",
    "         #   new_solar.append(solar_20[n%8760])\n",
    "\n",
    "\n",
    "        y=20\n",
    "        replacement_year=[]\n",
    "        #PV_Year=[]\n",
    "        Life_Day=[]\n",
    "\n",
    "        for m in range(len(HOMER_No_of_Batteries_Year)):\n",
    "            HOMER_No_of_Batteries_Year[m]=HOMER_No_of_Batteries_Year[m]+z\n",
    "        #HOMER_No_of_Replacement=7   \n",
    "        HOMER_No_of_Batteries_Replacement_Year=[]\n",
    "        HOMER_Battery_Life_Day=[]\n",
    "        Capacity_Day=[]\n",
    "        for n in range(HOMER_No_of_Replacement+1):\n",
    "            if n<6:\n",
    "                HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Year[((n+1)*3)-1])\n",
    "            else:\n",
    "                HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Year[19])\n",
    "        for n in range(HOMER_No_of_Replacement+1):\n",
    "            HOMER_Battery_Life_Day.append(round(HOMER_Battery_Life_Year[n]*365))\n",
    "            HOMER_Battery_Total_Capacity.append(round(HOMER_No_of_Batteries_Replacement_Year[n]*2.4))\n",
    "        for n in range(HOMER_No_of_Replacement+1):                                                                       # Capacity_Day Degradation for HOMER Battery Life\n",
    "            theeta=[]\n",
    "            for day in range(int(HOMER_Battery_Life_Day[n])):\n",
    "                theeta.append(((float(day)/HOMER_Battery_Life_Day[n])*90)*3.14159/180)\n",
    "                capacity=(20*math.exp(0.000258*(day))*math.cos(theeta[day]))+80\n",
    "                capacity=(capacity*HOMER_Battery_Total_Capacity[n])/100\n",
    "                if len(Capacity_Day)<=(20*365)-1:\n",
    "                    Capacity_Day.append(capacity)\n",
    "                else:\n",
    "                    break\n",
    "        HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Replacement_Year[len(HOMER_No_of_Batteries_Replacement_Year)-1])\n",
    "        #print(\"before SAO \",HOMER_No_of_Batteries_Replacement_Year)\n",
    "        for iteration in range(3):\n",
    "            No_of_batteries=HOMER_No_of_Batteries_Replacement_Year[0]\n",
    "            Bat=[No_of_batteries]                                                                                                         \n",
    "            Battery_Size=[]\n",
    "            battery=[]               \n",
    "            Load_Served=[]\n",
    "            Load_Shortage=[]\n",
    "            SoC_excess=[]\n",
    "            SoC=[]\n",
    "            Efficiency_Month=[]\n",
    "            Load_Served_Month=[]\n",
    "            Excess_Month=[]\n",
    "            Load_Month=[]\n",
    "            Life=[]\n",
    "            Load_Year=[]\n",
    "            Load_Served_Year=[]\n",
    "            Excess_Year=[]\n",
    "            Efficiency_Year=[]\n",
    "            In=[]\n",
    "            Out=[]\n",
    "            #Loss_Year=[3135,3250,3207,4040,4141,4184,4785,4809,4923,5319,5319,5273,5720,5773,5803,5793,5793,5793,5793,5793]\n",
    "            AT=[]\n",
    "            CaP=[]\n",
    "            Total_Capacity=[]\n",
    "            load_served=0                          \n",
    "            Efficiency=0\n",
    "            soc=100 \n",
    "            l=0\n",
    "            p=0\n",
    "            count=0\n",
    "            No_of_Replacement=0\n",
    "            Lifetime_throughput=905*No_of_batteries\n",
    "            capacity=No_of_batteries*2.4\n",
    "            battery_current=capacity  \n",
    "            Battery_Size.append(No_of_batteries)\n",
    "            Total_Capacity.append(No_of_batteries*2.4)\n",
    "\n",
    "            for year in range(20):  \n",
    "\n",
    "                for day in range((year*365),(year*365)+365):\n",
    "\n",
    "                    if (day>(year*365)+30 and day<(year*365)+59) or (day>(year*365)+303 and day<(year*365)+365):            # Feb  Nov  Dec\n",
    "                        dod=15\n",
    "                    elif day>(year*365)+150 and day<(year*365)+181:                                                         # June\n",
    "                        dod=15\n",
    "                    elif day>(year*365)+180 and day<(year*365)+273:                                                         # July  Aug  Sep  \n",
    "                        dod=15\n",
    "                    else:\n",
    "                        dod=15\n",
    "\n",
    "                    for hour in range((day*24),(day*24)+24):\n",
    "\n",
    "                        if new_solar[hour]>=load[hour]:                                                                         # Run-Time Servicing\n",
    "                            energy_in=new_solar[hour]-load[hour]\n",
    "                            battery_current=energy_in+battery_current\n",
    "                            load_serviced=load[hour]\n",
    "                            Load_Served.append(load_serviced)\n",
    "                            shortage=0\n",
    "                            In.append(energy_in)\n",
    "                            Out.append(0)\n",
    "\n",
    "                        elif new_solar[hour]<load[hour]:\n",
    "                            if (new_solar[hour]+battery_current-load[hour])>=(dod*capacity)/100:\n",
    "                                energy_out=load[hour]-new_solar[hour]\n",
    "                                battery_current=battery_current-energy_out\n",
    "                                load_serviced=load[hour]\n",
    "                                Load_Served.append(load_serviced)\n",
    "                                shortage=0\n",
    "                                Out.append(energy_out)\n",
    "                                In.append(0)\n",
    "                            else:\n",
    "                                energy_out=battery_current-(dod*capacity)/100\n",
    "                                battery_current=battery_current-energy_out\n",
    "                                load_serviced=new_solar[hour]+energy_out\n",
    "                                Load_Served.append(load_serviced)\n",
    "                                shortage=load[hour]-load_serviced\n",
    "                                Out.append(energy_out)\n",
    "                                In.append(0)\n",
    "                        soc=(battery_current/capacity) * 100\n",
    "                        excess_KW=0\n",
    "                        \n",
    "                        if soc>(Capacity_Day[day]/capacity)*100:                            \n",
    "                            excess_percentage=soc-((Capacity_Day[day]/capacity)*100)\n",
    "                            excess_KW=(excess_percentage*capacity)/100\n",
    "                            battery_current=Capacity_Day[day]\n",
    "                            soc=(Capacity_Day[day]/capacity)*100\n",
    "                        SoC_excess.append(excess_KW)    \n",
    "                        Load_Shortage.append(shortage)\n",
    "                        battery.append(battery_current)\n",
    "                        SoC.append(soc)\n",
    "\n",
    "                AT.append((sum(In)+sum(Out)-Loss_Year[year])/2)\n",
    "                Lifetime_throughput=Lifetime_throughput-AT[year]\n",
    "                                                                          # Battery Replacement\n",
    "                if Lifetime_throughput<0:\n",
    "                    Lifetime_throughput=Lifetime_throughput+AT[year]\n",
    "                    No_of_Replacement=No_of_Replacement+1\n",
    "                    balance=AT[year]-Lifetime_throughput\n",
    "                    rem=Lifetime_throughput/AT[year]\n",
    "                    Life.append(count+rem)\n",
    "                    #print 'Rep=',No_of_Replacement,HOMER_No_of_Batteries_Replacement_Year\n",
    "                    if No_of_Replacement>8:\n",
    "                        HOMER_No_of_Batteries_Replacement_Year.append(HOMER_No_of_Batteries_Replacement_Year[len(HOMER_No_of_Batteries_Replacement_Year)-1])\n",
    "                    No_of_batteries=HOMER_No_of_Batteries_Replacement_Year[No_of_Replacement]\n",
    "                    Bat.append(No_of_batteries)\n",
    "                    Lifetime_throughput=905*No_of_batteries\n",
    "                    Lifetime_throughput=Lifetime_throughput-balance\n",
    "                    count=0-rem\n",
    "                    p=p+Life[len(Life)-1]\n",
    "                    replacement_year.append(p)\n",
    "                   # if iteration==2:\n",
    "                      #  print(No_of_batteries)\n",
    "                    Total_Capacity.append(No_of_batteries*2.4)\n",
    "\n",
    "                count=count+1\n",
    "                In=[]\n",
    "                Out=[]\n",
    "\n",
    "            theeta=[]\n",
    "            Days=[]\n",
    "            Capacity_Day=[]\n",
    "            \n",
    "            if (len(Life)) ==0:\n",
    "                Life.append(20)\n",
    "                \n",
    "            for n in range(No_of_Replacement):\n",
    "                Days.append(round(Life[n]*365))\n",
    "            Days.append(round(Life[len(Life)-1]*365))\n",
    "            \n",
    "            if sum(Days)<7300:\n",
    "                Days.append(7300-sum(Days))\n",
    "                No_of_Replacement+=1\n",
    "                No_of_batteries=HOMER_No_of_Batteries_Replacement_Year[No_of_Replacement]\n",
    "                capacity=No_of_batteries*2.4\n",
    "                Total_Capacity.append(capacity)\n",
    "\n",
    "            for n in range(No_of_Replacement+1):\n",
    "                theeta=[]\n",
    "                for day in range(int(Days[n])):\n",
    "                    theeta.append(((float(day)/Days[n])*90)*3.14159/180)\n",
    "                    capacity=(20*math.exp(0.000258*(day))*math.cos(theeta[day]))+80\n",
    "                    capacity=(capacity*Total_Capacity[n])/100\n",
    "                    if len(Capacity_Day)<=(20*365)-1:\n",
    "                        Capacity_Day.append(capacity)\n",
    "                    else:\n",
    "                        break\n",
    "                        \n",
    "            if iteration==2:\n",
    "                tote=0\n",
    "                totls=0\n",
    "                totl=0\n",
    "                for n in range(20*8760):                    # Per Year Data Calculation\n",
    "                    if n%8759==0 and n>0:\n",
    "                        Excess_Year.append(tote)\n",
    "                        Load_Served_Year.append(totls)\n",
    "                        Load_Year.append(totl)\n",
    "                        tote=0\n",
    "                        totls=0\n",
    "                        totl=0\n",
    "                    tote=tote+SoC_excess[n]\n",
    "                    totls=totls+Load_Served[n]\n",
    "                    totl=totl+load[n]\n",
    "            if iteration==2:\n",
    "                for n in range(20):\n",
    "                    Efficiency_Year.append(100*(Load_Served_Year[n]/Load_Year[n]))\n",
    "\n",
    "\n",
    "            b=sum(new_solar)+HOMER_No_of_Batteries_Year[2]*2.4              # Energy Balance and Efficiency Calculation\n",
    "            c=sum(Load_Served)+sum(SoC_excess)+battery[(20*8760)-1]\n",
    "            Efficiency=100*(sum(Load_Served)/sum(load))\n",
    "\n",
    "        for n in range(len(Life)):\n",
    "            Life_Day.append(int(Life[n]*365))\n",
    "\n",
    "        for n in range(y):\n",
    "            Modified_Efficiency.append(round(Efficiency_Year[n],2))\n",
    "        print('\\t\\t\\t\\t\\t\\t\\t Loop 2')\n",
    "        print('\\nOverall Efficiency  :',Efficiency,'%',sum(Load_Served),sum(load))\n",
    "        print('Yearly Efficiency      :',Modified_Efficiency)   \n",
    "        print('No Of Batteries        :',No_of_batteries)\n",
    "        print('Replacements           :',No_of_Replacement)\n",
    "        print('Battery Life Year      :',Life,'yrs',sum(Life))\n",
    "        print('Battery Life Day       :',Life_Day,sum(Life_Day))\n",
    "        print('Excess                 :',sum(SoC_excess))\n",
    "        print(Bat,sum(Bat))\n",
    "\n",
    "        L=(sum(Life)+Life[len(Life)-1]-20)\n",
    "        C=300*Bat[0]\n",
    "        O=0;R=0;PO=0\n",
    "        PV_Cap=0\n",
    "        PV_add=0\n",
    "        rep=300\n",
    "        S=20*(Bat[len(Bat)-1])*L\n",
    "        Life.append(20-sum(Life))\n",
    "        for n in range(len(Bat)):\n",
    "            O=O+(20*(Bat[n]*Life[n]))\n",
    "            if n>0:\n",
    "                R=R+(Bat[n]*rep)\n",
    "        T=C+O+R-S\n",
    "        #print(C,' ',O,' ',R,' ',S,' ')\n",
    "        #print(T)\n",
    "        PV_Cap=PV_Year_Size[2]*1500\n",
    "        PV_add=(PV_Year_Size[len(PV_Year_Size)-1] - PV_Year_Size[2])*1500\n",
    "        for n in range(len(PV_Year)):\n",
    "            if (n == len(PV_Year)-1):\n",
    "                PO=PO+(500*(PV_Year_Size[n]*2))\n",
    "            else:\n",
    "           # print ('pv',PV_Year_Size,Life)\n",
    "                PO=PO+(500*(PV_Year_Size[n]*3))\n",
    "        PT=PO+PV_Cap+PV_add\n",
    "        print ('capital: ',C+PV_Cap)\n",
    "        #print(PT)\n",
    "        print(PT+T)\n",
    "        x_arr.append(x)\n",
    "        z_arr.append(z)\n",
    "        tot_eff.append(Efficiency)\n",
    "        tot_cost.append(PT+T)\n",
    "        rep_arr.append(No_of_Replacement)\n",
    "        excess_arr.append(sum(SoC_excess))\n",
    "        print (x,z,Efficiency,PT+T,No_of_Replacement,sum(SoC_excess))\n",
    "print (Bat,PV_Year_Size)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "paper2_base_loop_code_actual (1).ipynb",
   "provenance": []
  },
  "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": 1
}