# HERE WE ARE CONSIDERING DIFFEREN TIME of arival and depature of EV,

import itertools
import pyomo.environ as py
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import rc

# to ignore the warning for dividing by 0
np.seterr(divide='ignore', invalid='ignore')
m1 = py.ConcreteModel()

# <editor-fold desc="ReadingTHE OPF DATA FROM EXCEL for HOME">
sheet_data = pd.read_excel("input_data.xlsx", sheet_name='data')
sheet_tr = pd.read_excel("input_data.xlsx", sheet_name='Ambient_Temp')
sheet_EV = pd.read_excel("input_data.xlsx", sheet_name='EV_100')
# sheet_EV = pd.read_excel("input_data.xlsx", sheet_name='EV_10')
# sheet_EV = pd.read_excel("input_data.xlsx", sheet_name='EV_50')
# sheet_EV = pd.read_excel("input_data.xlsx", sheet_name='EV_80')
sheet_EWH = pd.read_excel("input_data.xlsx", sheet_name='EWH')
sheet_wateruse = pd.read_excel("input_data.xlsx", sheet_name='Water_Use')
sheet_home = pd.read_excel("input_data.xlsx", sheet_name='Home')
sheet_ESS = pd.read_excel("input_data.xlsx", sheet_name='ESS_100')
# sheet_ESS = pd.read_excel("input_data.xlsx", sheet_name='ESS_10')
# sheet_ESS = pd.read_excel("input_data.xlsx", sheet_name='ESS_50')
# sheet_ESS = pd.read_excel("input_data.xlsx", sheet_name='ESS_80')
sheet_PV = pd.read_excel("input_data.xlsx", sheet_name='PV_100')
# sheet_PV = pd.read_excel("input_data.xlsx", sheet_name='PV_10')
# sheet_PV = pd.read_excel("input_data.xlsx", sheet_name='PV_50')
# sheet_PV = pd.read_excel("input_data.xlsx", sheet_name='PV_80')
sheet_load = pd.read_excel("input_data.xlsx", sheet_name='Base_Load')
sheet_bus = pd.read_excel("input_data.xlsx", sheet_name='Bus')
sheet_bus1 = pd.read_excel("input_data.xlsx", sheet_name='bus1')
# sheet_bus1 = pd.read_excel("input_data.xlsx", sheet_name='bus1')
sheet_sumdict = pd.read_excel("input_data.xlsx", sheet_name='sum_dict')
sheet_ambient = pd.read_excel("input_data.xlsx", sheet_name='Ambient_Temp')

# </editor-fold>


# <editor-fold desc="Home Model for Minimizing Cost">

# <editor-fold desc="Set and Parameters of HOME">
m1.t = py.Set(initialize=sheet_data.time, ordered=True, doc='time period')
m1.b = py.Set(initialize=sheet_bus.bus, doc='bus')
m1.b1 = py.Set(initialize=sheet_bus1.bus1, doc='bus')
# 6:30 = 39
m1.h = py.Set(initialize=sheet_home.home)

m1.cost = py.Param(m1.h, mutable=True)

# </editor-fold>

# <editor-fold desc="base load and other Parameters of Home">
# Base load : uncontrollable loads
m1.base_load = py.Param(m1.h, m1.t,
                        initialize=dict(zip(list(itertools.product(m1.h.data(), m1.t.data())),
                                            [i for x in sheet_load.columns if "load" in x for i in
                                             sheet_load.loc[:, x].values])), doc="Base Load")

m1.PV = py.Param(m1.h, m1.t, initialize=dict(zip(list(itertools.product(m1.h.data(), m1.t.data())),
                                                 [i for x in sheet_PV.columns if "PV" in x for i in
                                                  sheet_PV.loc[:, x].values])), doc="PV Production")
m1.max = py.Param(initialize=1000000, doc='maximum value for selling and buying power')
# m1.Transformer_Limit = py.Param(initialize=75, doc='Power limit of transformer')

m1.UDC = py.Param(m1.t, mutable=True, initialize=80, doc='Uniform Distribution Capacity of transformer')
m1.Buy_Price_p2p = py.Param(m1.h, m1.t, initialize=0, mutable=True)
m1.combine = py.Param(m1.t, initialize=0, mutable=True)
m1.Sell_Price_p2p = py.Param(m1.h, m1.t, initialize=0, mutable=True)
m1.P_Buy_extra = py.Param(m1.h, m1.t, initialize=0)
m1.P_Buy_extra_1 = py.Param(m1.h, m1.t, initialize=0)
m1.P_sell_extra = py.Param(m1.h, m1.t, initialize=0)
m1.P_sell_extra_1 = py.Param(m1.h, m1.t, initialize=0)
m1.Sell_price_p2p = py.Param(m1.h, m1.t, initialize=0)
# Calculating the uniform distribution capacity
# m1.Transformer_Limit = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Transformer_limit)),
#                                 doc='Maximum power limit on transformer')

# for i in m1.t:
#     m1.UDC[i] = m1.Transformer_Limit[i] / m1.h[-1]

# </editor-fold>

# <editor-fold desc="Electric Vehicle Parameters">
# m1.alpha = py.Param(initialize=37, doc='time of arrival ')  # (40 = 7:00 pm) 37 = 6 pm
m1.alpha = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                              [i for x in sheet_EV.columns if "arrival" in x for i
                                               in
                                               sheet_EV.loc[:, x].values])), doc="Arrival time of EV")

m1.beta = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                             [i for x in sheet_EV.columns if "departure" in x for i
                                              in
                                              sheet_EV.loc[:, x].values])), doc="departure time of EV")
# m1.beta = py.Param(initialize=92, doc='time of departure ')  # (92 = 8:00 am)
m1.t_final = py.Param(initialize=96, doc='final time of the day ')  # 96
m1.second = py.Param(initialize=2, doc='second time of the day ')
m1.EV_Dur = py.Set(m1.h, initialize=lambda m, h: range(m.alpha[h], m.beta[h] + 1), doc='time interval for EV')
# m1.EV_Dur = py.Set(m1.h, initialize=py.RangeSet((m1.alpha[h].value, m1.beta[h].value) for h in m1.h),
#                    doc='time interval for EV')
# m1.EV_Dur = py.Set(initialize=((h, t) for h in m1.h for t in range(m1.alpha[h], m1.beta[h]+1)), doc='time interval for EV')

# m1.EV_Dur = py.Set(initialize={(i,j) for i in m1.h for j in range(m1.alpha[i].value, m1.beta[i].value + 1)},
#                    dimen=2,
#                    doc='time interval for EV')


m1.EV_Dur1 = py.Set(m1.h, initialize=lambda m, h: range(m.alpha[h] + 1, m.beta[h] + 1), doc='time interval for EV')
#
#
# def init_EV_Dur1(m, h):
#     return range(m.alpha[h] + 1, m.beta[h] + 1)
#
# m1.EV_Dur1 = py.Set(m1.h, initialize=init_EV_Dur1, ordered=True, dimen=1, within=OrderedSimpleSet, doc='time interval for EV')


# m1.EV_Dur1 = py.Set(m1.h,initialize=py.RangeSet(m1.alpha[h].value + 1, m1.beta[h].value),
#                     doc='time interval for EV after arrival')
m1.t_second = py.Set(initialize=py.RangeSet(m1.second.value, m1.t_final.value),
                     doc='time greater then 1')
m1.t_first = py.Param(initialize=1, doc='first time of the day ')
# m1.ist_interval = py.Set(initialize=py.RangeSet(m1.t_first.value, m1.alpha - 1),
#                          doc='time period before the arrival time')

m1.ist_interval = py.Set(m1.h, initialize=lambda m, h: range(m1.t_first.value, m.alpha[h]), doc='time interval for EV')
# m1.second_interval = py.Set(initialize=py.RangeSet(m1.beta.value + 1, m1.t_final.value),
#                             doc='time interval after departure')

m1.second_interval = py.Set(m1.h, initialize=lambda m, h: range(m.beta[h] + 1, m1.t_final.value + 1),
                            doc='time interval after departure')

m1.ChargeRate_EV = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                                      [i for x in sheet_EV.columns if "charging_rate" in x for i
                                                       in
                                                       sheet_EV.loc[:, x].values])), doc="charging rate of EV")

m1.DischRate_EV = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                                     [i for x in sheet_EV.columns if "rate_of_discharging" in x
                                                      for i in
                                                      sheet_EV.loc[:, x].values])), doc="Discharging rate of EV")

m1.Ch_Effc_EV = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                                   [i for x in sheet_EV.columns if "charging_efficiency" in x for
                                                    i in
                                                    sheet_EV.loc[:, x].values])), doc="charging efficency of EV")

m1.DischEffc_EV = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                                     [i for x in sheet_EV.columns if
                                                      "efficiency_of_discharging" in x for i
                                                      in sheet_EV.loc[:, x].values])),
                           doc="Discharging efficency of EV")

m1.Cap_EV = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                               [i for x in sheet_EV.columns if "capacity" in x for i in
                                                sheet_EV.loc[:, x].values])), doc="Capacity of  EV")
m1.End_percentage_EV = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                          [i for x in sheet_EV.columns if "end" in x
                                                           for i in
                                                           sheet_EV.loc[:, x].values])),
                                doc="Departure energy of EV")

m1.In_Percentage_EV = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                         [i for x in sheet_EV.columns if "initial" in x
                                                          for i in
                                                          sheet_EV.loc[:, x].values])),
                               doc="Initial energy of EV")

m1.Energy_EV_dep = py.Param(m1.h, initialize=dict(
    zip(m1.h.data(), np.array(m1.Cap_EV.values()) * m1.End_percentage_EV.values())),  # just changing np>py
                            doc="Departure temperature of EV")

m1.Energy_EV_In = py.Param(m1.h, initialize=dict(
    zip(m1.h.data(), np.array(m1.Cap_EV.values()) * m1.In_Percentage_EV.values())),
                           doc="Initial energy of EV")

# </editor-fold>

# <editor-fold desc="Energy Storage System Parameter">

m1.ChargeRate_ESS = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                                       [i for x in sheet_ESS.columns if "charging_rate" in x for i
                                                        in
                                                        sheet_ESS.loc[:, x].values])), doc="charging rate of ESS")

m1.DischRate_ESS = py.Param(m1.h, initialize=dict(zip(list(itertools.product(m1.h.data())),
                                                      [i for x in sheet_ESS.columns if "rate_of_discharging" in x
                                                       for
                                                       i in
                                                       sheet_ESS.loc[:, x].values])),
                            doc="Discharging rate of ESS")

# m1.ChargeRate_ESS = py.Param(initialize=float(sheet_ESS.charging_rate1), doc='Charging rate of ESS ')
# m1.DischRate_ESS = py.Param(initialize=float(sheet_ESS.discharging_rate1),
#                                doc='Discharging rate of ESS ')
m1.Cap_ESS = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                [i for x in sheet_ESS.columns if "capacity" in x for i in
                                                 sheet_ESS.loc[:, x].values])), doc="Capacity of  ESS")

m1.End_percentage_ESS = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                           [i for x in sheet_ESS.columns if "end" in x
                                                            for i in
                                                            sheet_ESS.loc[:, x].values])),
                                 doc="Departure energy of ESS")

m1.In_Percentage_ESS = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                          [i for x in sheet_ESS.columns if
                                                           "initial" in x for i in
                                                           sheet_ESS.loc[:, x].values])),
                                doc="Initial energy of ESS")

m1.Ch_Effc_ESS = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                    [i for x in sheet_ESS.columns if "charging_efficiency" in x
                                                     for i in
                                                     sheet_ESS.loc[:, x].values])),
                          doc="charging efficiency of ESS")

m1.DischEffc_ESS = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                      [i for x in sheet_ESS.columns if
                                                       "efficiency_of_dicharging" in x for
                                                       i in
                                                       sheet_ESS.loc[:, x].values])),
                            doc="Discharging efficiency of ESS")

m1.Energy_ESS_In = py.Param(m1.h, initialize=dict(
    zip(m1.h.data(), np.array(m1.Cap_ESS.values()) * m1.In_Percentage_ESS.values())),
                            doc="Initial energy of ESS")

m1.End_En_ESS = py.Param(m1.h, initialize=dict(
    zip(m1.h.data(), np.array(m1.Cap_ESS.values()) * m1.End_percentage_ESS.values())),
                         doc="Departure energy of ESS")

# </editor-fold>

# <editor-fold desc="Electric Water Heater Parameter">

m1.tetta_low = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                  [i for x in sheet_EWH.columns if "tetta_low" in x for i in
                                                   sheet_EWH.loc[:, x].values])),
                        doc="Lower bound of the water temperature")
m1.tetta_up = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                 [i for x in sheet_EWH.columns if "tetta_up" in x for i in
                                                  sheet_EWH.loc[:, x].values])),
                       doc="Upper bound of the water temperature")
m1.tetta_amb_int = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                      [i for x in sheet_EWH.columns if "tetta_amb_init" in x for i
                                                       in
                                                       sheet_EWH.loc[:, x].values])),
                            doc="Initial ambient temperature")

m1.tetta_amb = py.Param(m1.h, m1.t,
                        initialize=dict(zip(list(itertools.product(m1.h.data(), m1.t.data())),
                                            [i for x in sheet_ambient.columns if "celsius" in x for i in
                                             sheet_ambient.loc[:, x].values])), doc="Outdoor temperature")

m1.Q = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                          [i for x in sheet_EWH.columns if "capacity" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Power of the EWH")

m1.R = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                          [i for x in sheet_EWH.columns if "thermal_resistance" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Thermal resistance")
m1.C = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                          [i for x in sheet_EWH.columns if "thermal_capacitance" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Thermal resistance")

m1.M = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                          [i for x in sheet_EWH.columns if "water_cap" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Water Capacity (L)")

m1.tetta_EWH_int = py.Param(m1.h, initialize=dict(zip((m1.h.data()),
                                                      [i for x in sheet_EWH.columns if "tetta_wat_init" in x for i
                                                       in
                                                       sheet_EWH.loc[:, x].values])), doc="Initial temperature")

m1.water_use = py.Param(m1.h, m1.t,
                        initialize=dict(zip(list(itertools.product(m1.h.data(), m1.t.data())),
                                            [i for x in sheet_wateruse.columns if "Litre" in x for i in
                                             sheet_wateruse.loc[:, x].values])), doc="Hot Water usage")

# </editor-fold2

# <editor-fold desc="Price, Base load, and time duration parameters">
# m1.Buy_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_RTP)), doc='Buying Price')
# m1.Buy_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_TOU)), doc='Buying Price')
# m1.Buy_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_TOU_winter)), doc='Buying Price')
# m1.Buy_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_flex_D)), doc='Buying Price')
m1.Buy_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.TOU_PGE)), doc='Buying Price')
# m1.Buy_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.TOU_Texas_RTP)), doc='Buying Price')
# m1.Buy_price_Peer = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_TOU)), doc='Buying Price')
# m1.Buy_price_Peer = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_Peer)),
#                              doc='Buying Price of peer')
# m1.Sell_price_Peer = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.Sell_price_new)),
#                               doc='Selling Price of peer')
m1.Sell_price = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.FiT)),
                         doc='Selling Price')  # Fit is TX US
# m1.Sell_price_Peer = py.Param(m1.t, initialize=dict(zip(sheet_data.time, sheet_data.fixed_incentive)), doc='Selling Price')
# Time duration: we took 15 mint granularity so in one hour it will be 1/4
m1.time_d = py.Param(initialize=(1 / 4), doc='time duration ')  # 1/4
m1.Export_Percent = py.Param(initialize=1, doc='pecentage export ')  # 0.814

m1.cost = py.Param(m1.h, mutable=True)
# </editor-fold>

for h in m1.h:
    for t in m1.t:
        m1.Buy_Price_p2p[h, t] = m1.Buy_price[t]
for h in m1.h:
    for t in m1.t:
        m1.Sell_Price_p2p[h, t] = m1.Sell_price[t]
# m1.max_limit = py.Param(m1.t, initialize=75, doc='Maximum power limit on transformer ')
# m1.DPT = py.Param(initialize=0.069, doc='Daily power tariff ')  # .069
# </editor-fold>

print('Code Starts for HEMS for cost')
# Variable

# <editor-fold desc="buying and selling variables">
m1.P_Buy_Grid = py.Var(m1.h, m1.t, bounds=(0, None))

m1.E_Buy_Grid = py.Param(m1.h, mutable=True)
m1.P_Buy_Total = py.Var(m1.h, m1.t, bounds=(0, None))
# m1.P_Buy_Peer = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_Sell_Grid = py.Var(m1.h, m1.t, bounds=(0, 1000000))
m1.P_Sell_Total = py.Var(m1.h, m1.t, bounds=(0, None))
# m1.P_Sell_Peer = py.Var(m1.h, m1.t, bounds=(0, None))

m1.S_P_sell = py.Var(m1.h, m1.t, within=py.Binary)
m1.S_P_buy = py.Var(m1.h, m1.t, within=py.Binary)

# m1.pflex = py.Var(m1.b, m1.t, doc='active Flexibility')
# m1.qflex = py.Var(m1.b, m1.t,
#                      doc='reactive Flexibility')  # i comment this because i use m1.pflex variable * 0.48

# Tranformal variable
m1.Power_T_P = py.Var(m1.t, bounds=(0, None), doc="power from transformer to Peer")
m1.Power_Total_power = py.Param(m1.t, mutable=True, doc="power from transformer to Peer")
m1.HST = py.Var(m1.t, bounds=(0, None), doc="HST")
m1.DTOT = py.Var(m1.t, bounds=(0, None), doc="HST")
m1.DHST = py.Var(m1.t, bounds=(0, None), doc="HST")
m1.DTOTU = py.Var(m1.t, bounds=(0, None), doc="HST")
m1.DHSTU = py.Var(m1.t, bounds=(0, None), doc="HST")
m1.Power_P_T = py.Var(m1.t, bounds=(0, None), doc="power from Peer to Transformer")
m1.S_P_T = py.Var(m1.h, m1.t, within=py.Binary)
# </editor-fold>

# <editor-fold desc="Electric vehicle Variables">
m1.P_EV_Charge = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_EV_Disch = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_EV_Disch_Home = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_EV_Disch_Grid = py.Var(m1.h, m1.t, bounds=(0, None))
m1.S_EV_Charge = py.Var(m1.h, m1.t, within=py.Binary)
m1.S_EV_Disch = py.Var(m1.h, m1.t, within=py.Binary)
m1.Energy_EV = py.Var(m1.h, m1.t, bounds=(0, None))  # SOC of the EV
# </editor-fold>

# <editor-fold desc="Energy storage system Variables">
m1.Energy_ESS = py.Var(m1.h, m1.t, bounds=(0, None))  # SOC of the ESS
m1.S_ESS_Charge = py.Var(m1.h, m1.t, within=py.Binary)
m1.P_ESS_Disch = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_ESS_Charge = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_ESS_Charge_Grid = py.Var(m1.h, m1.t, bounds=(0, None), doc='ESS charging from the Grid')
m1.P_ESS_Disch_Home = py.Var(m1.h, m1.t, bounds=(0, None))
m1.P_ESS_Disch_Grid = py.Var(m1.h, m1.t, bounds=(0, None))
m1.S_ESS_Disch = py.Var(m1.h, m1.t, within=py.Binary)
# </editor-fold>

# <editor-fold desc="PV variables">
m1.PV_Home = py.Var(m1.h, m1.t, bounds=(0, None))
m1.PV_Grid = py.Var(m1.h, m1.t, bounds=(0, None))
m1.PV_Battery = py.Var(m1.h, m1.t, bounds=(0, None))
# </editor-fold>

# <editor-fold desc="EWH Variables">
m1.tetta_EWH_wat = py.Var(m1.h, m1.t)
m1.S_EWH = py.Var(m1.h, m1.t, within=py.Binary)
m1.P_EWH = py.Var(m1.h, m1.t, doc='power of EWH')


# </editor-fold>
# Constraints


# <editor-fold desc="Buying and Selling Power">
def Power_buy(m1, h, i):
    return m1.P_Buy_Grid[h, i] == m1.base_load[h, i] + m1.Q[h] * m1.S_EWH[h, i] + m1.P_EV_Charge[h, i] - \
        m1.P_EV_Disch_Home[h, i] + m1.P_ESS_Charge[h, i] - \
        m1.P_ESS_Disch_Home[h, i] - m1.PV_Home[h, i] - m1.PV_Battery[h, i]  #


m1.Const_1 = py.Constraint(m1.h, m1.t, rule=Power_buy, doc='Power buy from the Grid')


def Power_buy2(m1, h, i):
    return m1.P_Buy_Grid[h, i] <= m1.max * m1.S_P_buy[h, i]


m1.Const_1a = py.Constraint(m1.h, m1.t, rule=Power_buy2,
                            doc='removing the nonlinearity in the objective fucntion')


def Power_sell1(m1, h, i):
    return m1.P_Sell_Grid[h, i] == m1.P_EV_Disch_Grid[h, i] + m1.PV_Grid[h, i] + m1.P_ESS_Disch_Grid[h, i]


m1.Const_2 = py.Constraint(m1.h, m1.t, rule=Power_sell1, doc='Power sell to the Grid')


def Power_sell2(m1, h, i):
    # return m1.P_Sell_Grid[h, i] <= m1.max.value * (1 - m1.S_P_buy[h, i])
    return m1.P_Sell_Grid[h, i] <= m1.max.value * (1 - m1.S_P_buy[h, i])


m1.Const_2a = py.Constraint(m1.h, m1.t, rule=Power_sell2, doc='Power sell to the Grid')


# put some percentage to export power the grid
def percentage(m1, h, i):
    return sum(m1.P_Sell_Grid[h, i] for i in m1.t for h in m1.h) >= m1.Export_Percent.value * sum(
        m1.P_EV_Disch_Home[h, i] + m1.P_ESS_Disch_Home[h, i]
        + m1.PV_Battery[h, i] + m1.PV_Home[h, i] for i in m1.t for h in m1.h)

    # return sum(m1.P_Sell_Grid[y, i] for i in m1.t for y in m1.h) >= m1.Export_Percent.value * sum(
    #     m1.P_EV_Disch_Home[y, i] + m1.P_ESS_Disch_Home[y, i]
    #     + m1.PV_Battery[y, i] + m1.PV_Home[y, i] for i in m1.t for y in m1.h)


m1.connn1 = py.Constraint(m1.h, m1.t, rule=percentage, doc='Export constraint')


#
# def Status_Power(m1, h, i):
#     return m1.S_P_buy[h, i] + m1.S_P_sell[h, i] <= 1
#
#
# m1.Const_3 = py.Constraint(m1.h, m1.t, rule=Status_Power,
#                            doc='Buying and selling power will not occur at same time')
#

# def Power_total_buy(m1, h, i):
#     return m1.P_Buy_Total[h, i] == m1.P_Buy_Grid[h, i]
#     # return m1.P_Buy_Total[h, i] == m1.P_Buy_Grid[h, i] + m1.P_Buy_Peer[h, i]
#
#
# m1.Const_3a = py.Constraint(m1.h, m1.t, rule=Power_total_buy,
#                             doc='Total Buying power equal to power buy from grid and form '
#                                 'other peers')


#
# def Power_total_Sell(m1, h, i):
#     return m1.P_Sell_Total[h, i] == m1.P_Sell_Grid[h, i]
#     # return m1.P_Sell_Total[h, i] == m1.P_Sell_Grid[h, i] + m1.P_Sell_Peer[h, i]
#
#
# m1.Const_3b = py.Constraint(m1.h, m1.t, rule=Power_total_Sell,
#                             doc='Total Selling power equal to power sell to grid and to '
#                                 'other peers')


#
# def Power_total(m1, h, i):
#     return sum(m1.P_Buy_Peer[h, i] for h in m1.h) == sum(m1.P_Sell_Peer[h, i] for h in m1.h)
#
#
# m1.Const_3c = py.Constraint(m1.h, m1.t, rule=Power_total,
#                             doc='Total Buying  power equal to total Selling power')


def Power_T_P(m1, h, i):
    return m1.Power_T_P[i] == sum(m1.P_Buy_Grid[h, i] for h in m1.h)


#
m1.Const_3d = py.Constraint(m1.h, m1.t, rule=Power_T_P,
                            doc='Power bought from the grid is equal to the Power of transformer to grid direction')


def Power_P_T(m1, h, i):
    return m1.Power_P_T[i] == sum(m1.P_Sell_Grid[h, i] for h in m1.h)


m1.Const_3e = py.Constraint(m1.h, m1.t, rule=Power_P_T,
                            doc='Power sell to the grid is equal to the Power on the transformer from grid direction')


# Transformer limits

# def Power_limit_T_P(m1, h, i):
#     return m1.Power_T_P[i] <=  m1.max.value * (m1.S_P_T[h, i])
#
#
# m1.Const_3f = py.Constraint(m1.h, m1.t, rule=Power_limit_T_P, doc='Power limit on the transformer')
#
#
# def Power_limit_P_T(m1, h, i):
#     return m1.Power_P_T[i] <=  m1.max.value * (1 - m1.S_P_T[h, i])
#
#
# m1.Const_3g = py.Constraint(m1.h, m1.t, rule=Power_limit_P_T, doc='Power limit on the transformer')


# def Power_UDC_Limit(m1, h, i):
#     return m1.P_Buy_Grid[h, i] <= m1.UDC[i]
#
#
# m1.Const_3h = py.Constraint(m1.h, m1.t, rule=Power_UDC_Limit, doc='UDC limit')


# </editor-fold>

#
# <editor-fold desc="Electric vehicle Constraints">
def Power_EV_Charge_limit1(m1, h, i):
    return m1.P_EV_Charge[h, i] <= m1.ChargeRate_EV[h] * m1.S_EV_Charge[h, i]


m1.Const_EV_1 = py.Constraint(m1.h, m1.t, rule=Power_EV_Charge_limit1,
                              doc='Charging power of EV (Upper limit)')


def Power_EV_Charge_limit2(m1, h, i):
    return m1.P_EV_Charge[h, i] >= 0


m1.Const_EV_2 = py.Constraint(m1.h, m1.t, rule=Power_EV_Charge_limit2,
                              doc='Charging power of EV (lower limit)')


def Power_EV_Disch_limit1(m1, h, i):
    return m1.P_EV_Disch[h, i] <= (m1.DischRate_EV[h] * m1.S_EV_Disch[h, i])


m1.Const_EV_3 = py.Constraint(m1.h, m1.t, rule=Power_EV_Disch_limit1,
                              doc='Discharging power of EV (Upper limit)')


def Power_EV_Disch_limit2(m1, h, i):
    return m1.P_EV_Disch[h, i] >= 0


m1.Const_EV_4 = py.Constraint(m1.h, m1.t, rule=Power_EV_Disch_limit2,
                              doc='Discharging power of EV (Lower limit)')


def Status_EV(m1, h, i):
    return m1.S_EV_Disch[h, i] + m1.S_EV_Charge[h, i] <= 1


m1.Const_EV_5 = py.Constraint(m1.h, m1.t, rule=Status_EV,
                              doc='Charging and discharging will not occur at same time')


def Power_EV_Disch(m1, h, i):
    return m1.P_EV_Disch[h, i] * m1.DischEffc_EV[h] == (
        (m1.P_EV_Disch_Home[h, i] + m1.P_EV_Disch_Grid[h, i]))


m1.Const_EV_6 = py.Constraint(m1.h, m1.t, rule=Power_EV_Disch, doc='Discharging power of EV to '
                                                                   'Home and Grid')


def SoC_EV1(m1, h, i):
    return m1.Energy_EV[h, i] == m1.Energy_EV_In[h]


m1.Const_EV_7a = py.Constraint([(h, py.value(m1.alpha[h])) for h in m1.h], rule=SoC_EV1, doc='SoC of the EV at arrival')


# def SoC_EV1(m1, h):
#     alpha_h = m1.alpha[h]
#     return m1.Energy_EV[h, alpha_h] == m1.Energy_EV_In[h]
#
# m1.Const_EV_7a = py.Constraint(m1.h, rule=SoC_EV1, doc='SoC of the EV at arrival')

def SoC_EV2(m1, h, i):
    return m1.Energy_EV[h, i] == m1.Energy_EV[h, i - 1] + (
            m1.P_EV_Charge[h, i] * m1.Ch_Effc_EV[h] * m1.DischEffc_EV[h] - m1.P_EV_Disch[h, i]) * m1.time_d


m1.Const_EV_7b = py.ConstraintList()
for h in m1.h:
    for i in m1.EV_Dur1[h].value:
        m1.Const_EV_7b.add(SoC_EV2(m1, h, i))


def EV_availability1(m1, h, i):
    return m1.Energy_EV[h, i] == 0


# m1.Const_EV_8a = py.Constraint(m1.h, m1.ist_interval[h], rule=EV_availability1,doc='SOC available before arrival time')
# m1.Const_EV_8a = py.Constraint([(h, m1.ist_interval[h].value) for h in m1.h], rule=EV_availability1, doc='SOC available before arrival time')
m1.Const_EV_8a = py.ConstraintList()
for h in m1.h:
    for i in m1.ist_interval[h].value:
        m1.Const_EV_8a.add(EV_availability1(m1, h, i))


def EV_availability2(m1, h, i):
    return m1.Energy_EV[h, i] == 0


# m1.Const_EV_8b = py.Constraint([(h, m1.second_interval[h].value) for h in m1.h], rule=EV_availability2, doc='SOC available after departure time')
# m1.Const_EV_8b = py.Constraint(m1.h, m1.second_interval[h], rule=EV_availability2,doc='SOC available after departure time')
m1.Const_EV_8b = py.ConstraintList()
for h in m1.h:
    for i in m1.second_interval[h].value:
        m1.Const_EV_8b.add(EV_availability2(m1, h, i))


def EV_status_available1(m1, h, i):
    return m1.S_EV_Disch[h, i] + m1.S_EV_Charge[h, i] == 0


# m1.Const_EV_9a = py.Constraint(m1.h, m1.ist_interval[h], rule=EV_status_available1, doc='EV availability before arrival time')
# m1.Const_EV_9a = py.Constraint([(h, m1.ist_interval[h].value) for h in m1.h], rule=EV_status_available1, doc='EV availability before arrival time')
m1.Const_EV_9a = py.ConstraintList()
for h in m1.h:
    for i in m1.ist_interval[h].value:
        m1.Const_EV_9a.add(EV_status_available1(m1, h, i))


def EV_status_available2(m1, h, i):
    return m1.S_EV_Disch[h, i] + m1.S_EV_Charge[h, i] == 0


# m1.Const_EV_9b = py.Constraint(m1.h, m1.second_interval[h], rule=EV_status_available2,doc='EV availability after arrival time')
# m1.Const_EV_9b = py.Constraint([(h, m1.second_interval[h].value) for h in m1.h], rule=EV_status_available2, doc='EV availability after arrival time')
m1.Const_EV_9b = py.ConstraintList()
for h in m1.h:
    for i in m1.second_interval[h].value:
        m1.Const_EV_9b.add(EV_status_available2(m1, h, i))


def EV_SoC_limit1(m1, h, i):
    return m1.Energy_EV[h, i] >= 0.2 * m1.Cap_EV[h]


# m1.Const_EV_10 = py.Constraint(m1.h, m1.EV_Dur[h], rule=EV_SoC_limit1, doc='Minimum SoC of EV')
# m1.Const_EV_10 = py.Constraint([(h, m1.EV_Dur[h].value) for h in m1.h], rule=EV_SoC_limit1, doc='Minimum SoC of EV')
m1.Const_EV_10 = py.ConstraintList()
for h in m1.h:
    for i in m1.EV_Dur[h].value:
        m1.Const_EV_10.add(EV_SoC_limit1(m1, h, i))


def EV_SoC_limit2(m1, h, i):
    return m1.Energy_EV[h, i] <= m1.Cap_EV[h]


# m1.Const_EV_11 = py.Constraint(m1.h, m1.t, rule=EV_SoC_limit2, doc='Maximum SoC of EV')
m1.Const_EV_11 = py.ConstraintList()
for h in m1.h:
    for i in m1.EV_Dur[h].value:
        m1.Const_EV_11.add(EV_SoC_limit2(m1, h, i))


def EV_final_SoC(m1, h, i):
    return m1.Energy_EV[h, i] == m1.Energy_EV_dep[h]


# m1.Const_EV_12 = py.Constraint(m1.h, [m1.beta[h]], rule=EV_final_SoC,doc='Final SoC of EV at departure time')
# m1.Const_EV_12 = py.Constraint([(h,py.value([m1.beta[h]])) for h in m1.h], rule=EV_final_SoC,doc='Final SoC of EV at departure time')
m1.Const_EV_12 = py.Constraint([(h, py.value(m1.beta[h])) for h in m1.h], rule=EV_final_SoC,
                               doc='Final SoC of EV at departure time')


# m1.Const_EV_12 = py.ConstraintList()
# for h in m1.h:
#     for i in py.value(m1.beta[h]):
#         m1.Const_EV_12.add(EV_final_SoC(m1, h, i))

# </editor-fold>

# <editor-fold desc="Energy Storage System Constraints">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def SoC_ESS1(m1, h, i):
    return m1.Energy_ESS[h, i] == m1.Energy_ESS_In[h]


m1.Const_ESS_1a = py.Constraint(m1.h, [m1.t_first.value], rule=SoC_ESS1,
                                doc='SoC of ESS')  # need to check wather we need to put in the brackets or not


def SoC_ESS2(m1, h, i):
    return m1.Energy_ESS[h, i] == m1.Energy_ESS[h, i - 1] + (
            m1.P_ESS_Charge[h, i] * m1.Ch_Effc_ESS[h] - m1.P_ESS_Disch[h, i]) * m1.time_d


m1.Const_ESS_1b = py.Constraint(m1.h, m1.t_second, rule=SoC_ESS2, doc='SoC of ESS')


def Power_ESS_Charge(m1, h, i):
    return m1.P_ESS_Charge[h, i] == m1.P_ESS_Charge_Grid[h, i] + m1.PV_Battery[h, i]


m1.Const_ESS_2 = py.Constraint(m1.h, m1.t, rule=Power_ESS_Charge,
                               doc='Charging power of ESS ')


def Power_ESS_Charge_limit1(m1, h, i):
    return (m1.P_ESS_Charge_Grid[h, i] + m1.PV_Battery[h, i]) <= m1.ChargeRate_ESS[h] * m1.S_ESS_Charge[h, i]


m1.Const_ESS_2a = py.Constraint(m1.h, m1.t, rule=Power_ESS_Charge_limit1,
                                doc='Charging power of ESS (Upper limit)')


def Power_ESS_Charge_limit2(m1, h, i):
    return (m1.P_ESS_Charge_Grid[h, i] + m1.PV_Battery[h, i]) >= 0
    # return (m1.P_ESS_Charge_Grid[h, i] + m1.PV_Battery[h, i]) >=  0.2 * (m1.ChargeRate_ESS[h] * m1.S_ESS_Charge[h, i])


m1.Const_ESS_2b = py.Constraint(m1.h, m1.t, rule=Power_ESS_Charge_limit2,
                                doc='Charging power of ESS (Lower limit)')


def Power_ESS_Disch_limit1(m1, h, i):
    return (m1.P_ESS_Disch_Home[h, i] + m1.P_ESS_Disch_Grid[h, i]) <= (m1.DischRate_ESS[h] * m1.S_ESS_Disch[h, i])


m1.Const_ESS_4 = py.Constraint(m1.h, m1.t, rule=Power_ESS_Disch_limit1,
                               doc='Discharging power of ESS (Upper limit)')


def Power_ESS_Disch_limit2(m1, h, i):
    # return (m1.P_ESS_Disch[h, i]) >= 0.2 * (m1.DischRate_ESS[h] * m1.S_ESS_Disch[h, i])
    return (m1.P_ESS_Disch_Home[h, i] + m1.P_ESS_Disch_Grid[h, i]) >= 0


m1.Const_ESS_5 = py.Constraint(m1.h, m1.t, rule=Power_ESS_Disch_limit2,
                               doc='Discharging power of ESS (Lower limit)')


def Status_ESS(m1, h, i):
    return m1.S_ESS_Disch[h, i] + m1.S_ESS_Charge[h, i] <= 1


m1.Const_ESS_6 = py.Constraint(m1.h, m1.t, rule=Status_ESS,
                               doc='Charging and discharging will not occur at same time')


def Power_ESS_Disch(m1, h, i):
    return (m1.P_ESS_Disch[h, i]) * m1.DischEffc_ESS[h] == (m1.P_ESS_Disch_Home[h, i] + m1.P_ESS_Disch_Grid[h, i])


m1.Const_ESS_7 = py.Constraint(m1.h, m1.t, rule=Power_ESS_Disch,
                               doc='Discharging power of ESS to Home and Grid')


def ESS_SoC_limit1(m1, h, i):
    return m1.Energy_ESS[h, i] >= 0.1 * m1.Cap_ESS[h]


m1.Const_ESS_8 = py.Constraint(m1.h, m1.t, rule=ESS_SoC_limit1, doc='Minimum SoC of ESS')


def ESS_SoC_limit2(m1, h, i):
    return m1.Energy_ESS[h, i] <= m1.Cap_ESS[h]


m1.Const_ESS_9 = py.Constraint(m1.h, m1.t, rule=ESS_SoC_limit2, doc='Maximum SoC of ESS')


def ESS_final_SoC(m1, h, i):
    return m1.Energy_ESS[h, i] >= m1.End_En_ESS[h]


m1.Const_ESS_10 = py.Constraint(m1.h, [m1.t_final.value], rule=ESS_final_SoC,
                                doc='Final SoC of ESS at departure time')


# </editor-fold>

# <editor-fold desc="Electric Water Heater (EWH) Constraints">
def EWH_limit1(m1, h, i):
    return m1.tetta_EWH_wat[h, i] <= m1.tetta_up[h]


m1.Const_EWH_1 = py.Constraint(m1.h, m1.t, rule=EWH_limit1, doc='Maximum Limit')


def EWH_limit2(m1, h, i):
    return m1.tetta_EWH_wat[h, i] >= m1.tetta_low[h]


m1.Const_EWH_2 = py.Constraint(m1.h, m1.t, rule=EWH_limit2, doc='Minimum Limit')


def EWH_power(m1, h, i):
    return m1.P_EWH[h, i] == m1.Q[h] * m1.S_EWH[h, i]


m1.Const_EWH_3 = py.Constraint(m1.h, m1.t, rule=EWH_power, doc='Electric water heater power')


def EWH_temp_1(m1, h, i):
    return m1.tetta_EWH_wat[h, i] == m1.tetta_amb[h, i] + m1.Q[h] * m1.S_EWH[h, i] * m1.R[
        h] * m1.time_d - (
            (m1.M[h] - m1.water_use[h, i]) / m1.M[h]) * (
            m1.tetta_amb_int[h] - m1.tetta_EWH_int[h]) * py.exp(-m1.time_d / (m1.R[h] * m1.C[h]))


m1.Const_EWH_4 = py.Constraint(m1.h, [m1.t_first.value], rule=EWH_temp_1, doc='EWH m1')


def EWH_temp_2(m1, h, i):
    return m1.tetta_EWH_wat[h, i] == m1.tetta_amb[h, i] + m1.Q[h] * m1.S_EWH[h, i] * m1.R[
        h] * m1.time_d - (
            (m1.M[h] - m1.water_use[h, i]) / m1.M[h]) * (
            m1.tetta_amb[h, i] - m1.tetta_EWH_wat[h, i - 1]) * py.exp(
        -m1.time_d / (m1.R[h] * m1.C[h]))


m1.Const_EWH_5 = py.Constraint(m1.h, m1.t_second, rule=EWH_temp_2, doc='EWH m1')


# </editor-fold>

# <editor-fold desc="PV Constraints"> # need to include the PV equation of omer paper

def PV_production(m1, h, i):
    return m1.PV_Grid[h, i] + m1.PV_Home[h, i] + m1.PV_Battery[h, i] == m1.PV[h, i]
    # return m1.PV_Grid[h, i]  + m1.PV_Battery[h, i] == m1.PV[h, i]


m1.Const_PV = py.Constraint(m1.h, m1.t, rule=PV_production, doc='PV Production')


# </editor-fold>


# <editor-fold desc="objective functions">


def objective_rule(m1):
    return sum(
        m1.P_Buy_Grid[y, i] * m1.Buy_price[i] - m1.P_Sell_Grid[y, i] * m1.Sell_price[i] for i in
        m1.t for y in m1.h) * m1.time_d.value

    # return sum(
    #     (m1.P_Buy_Grid[y, i] * m1.Buy_price[i]) * m1.S_P_buy[y, i] - (m1.P_Sell_Grid[y, i] * m1.Sell_price[i])* m1.S_P_sell[y, i]   for i in
    #     m1.t for y in m1.h) * m1.time_d.value


m1.obj1 = py.Objective(rule=objective_rule, sense=py.minimize, doc='Definition of objective function')
# <editor-fold desc="Solver">
# m1.write('m12.lp', io_options={'symbolic_solver_labels': True})
opt = py.SolverFactory('gurobi')
# opt = py.SolverFactory('mindtpy').solve(m1, mip_solver='cplex', nlp_solver='ipopt', tee=True)
# opt = py.SolverFactory('couenne ')
opt.options["mipgap"] = 0.03  # 0.155 for load and 0.8 for other load
result = opt.solve(m1, tee=True)
# result = opt.solve(m1)

# this is for calling the neos
# os.environ['NEOS_EMAIL'] = 'sadamengr15@gmail.com'
# opt = py.SolverManagerFactory('neos')
# result = opt.solve(m1, opt='cplex')

# m1.pprint()
print(result)
for y in m1.h:
    m1.cost[y] = py.value(sum(m1.P_Buy_Grid[y, i] * m1.Buy_price[i] - m1.P_Sell_Grid[y, i] *
                              m1.Sell_price[i] for i in m1.t) * m1.time_d.value)
for h in m1.h:
    print(
        f"Before Cost Objective of Home {h} : " f"{py.value((sum((m1.P_Buy_Grid[h, i] * m1.Buy_price[i]) - (m1.P_Sell_Grid[h, i] * m1.Sell_price[i]) for i in m1.t) * m1.time_d.value))}")
# </editor-fold>

# total power on the transformer:
for i in m1.t:
    m1.Power_Total_power[i] = round(m1.Power_P_T[i].value + m1.Power_T_P[i].value, 3)

# print('Sum of all homes objectives = ', py.value(m1.obj1))
# for h in m1.h:
#     print(
#         f"Before Cost Objective of Hom {h} : " f"{py.value((sum((m1.P_Buy_Grid[h, i] * m1.Buy_price[i]) - (m1.P_Sell_Grid[h, i] * m1.Sell_price[i]) for i in m1.t) * m1.time_d))}")
# < / editor - fold >
# for h in m1.h:
#     print(
#         f"Energy of Home {h} : " f"{py.value((sum((m1.P_Buy_Grid[h, i] * m1.time_d) for i in m1.t)))}")
# for h in m1.h:
#     m1.E_Buy_Grid[h] = ((sum((m1.P_Buy_Grid[h, i] * m1.time_d) for i in m1.t) ))
print('power export ', py.value(sum(m1.P_Sell_Grid[y, i] for i in m1.t for y in m1.h)))
print('power import ', py.value(sum(m1.P_Buy_Grid[y, i] for i in m1.t for y in m1.h)))

# # # <editor-fold desc="Ploting">
##
# # # Plotting for automatic ploting
time = [i for i in m1.t]

pl1_pbuy = [[] for j in m1.h]
pl1_pbuy_extra = [[] for j in m1.h]
pl1_pbuy_extra_1 = [[] for j in m1.h]
pl1_psell_extra = [[] for j in m1.h]
pl1_psell_extra_1 = [[] for j in m1.h]
pl_Buy_Price_p2p = [[] for j in m1.h]
pl_Sell_Price_p2p = [[] for j in m1.h]
pl1_pbuy_peer = [[] for j in m1.h]
pl1_psell = [[] for j in m1.h]
pl1_psell_peer = [[] for j in m1.h]

PEVCharge = [[] for j in m1.h]
PESSChargeGrid = [[] for j in m1.h]
PEVDischHome = [[] for j in m1.h]
PESSDischHome = [[] for j in m1.h]
PESSCharge = [[] for j in m1.h]
SEVCharge = [[] for j in m1.h]
SEVDisch = [[] for j in m1.h]
PEVDischGrid = [[] for j in m1.h]
PESSDischGrid = [[] for j in m1.h]
PVHome = [[] for j in m1.h]
PVGrid = [[] for j in m1.h]
PVBattery = [[] for j in m1.h]
PPV = [[] for j in m1.h]
baseload = [[] for j in m1.h]
EnergyESS = [[] for j in m1.h]
EnergyEV = [[] for j in m1.h]
tettaEWHwat = [[] for j in m1.h]
SEWH = [[] for j in m1.h]
PEWH = [[] for j in m1.h]
Buyprice = []  # cost = [i for i in m1.c.values()]  <<< check this
HST = []  # cost = [i for i in m1.c.values()]  <<< check this
DHST = []  # cost = [i for i in m1.c.values()]  <<< check this
DTOT = []  # cost = [i for i in m1.c.values()]  <<< check this
Transformer_Limit = []  # cost = [i for i in m1.c.values()]  <<< check this
Buyprice_peer = []  # cost = [i for i in m1.c.values()]  <<< check this
Power_P_T = []  # cost = [i for i in m1.c.values()]  <<< check this
Power_T_P = []  # cost = [i for i in m1.c.values()]  <<< check this
Sellprice = []
combine = []
cost_1 = [[] for j in m1.h]
Sellprice_peer = []

for j in m1.h:
    for k, v in m1.P_Buy_Grid.items():
        if k[0] == j:
            pl1_pbuy[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_Buy_extra.items():
        if k[0] == j:
            pl1_pbuy_extra[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_Buy_extra_1.items():
        if k[0] == j:
            pl1_pbuy_extra_1[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_sell_extra.items():
        if k[0] == j:
            pl1_psell_extra[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.P_sell_extra_1.items():
        if k[0] == j:
            pl1_psell_extra_1[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.Buy_Price_p2p.items():
        if k[0] == j:
            pl_Buy_Price_p2p[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.Sell_Price_p2p.items():
        if k[0] == j:
            pl_Sell_Price_p2p[j - 1].append(py.value(v))

# for j in m1.h:
#     for k, v in m1.P_Sell_Peer.items():
#         if k[0] == j:
#             pl1_psell_peer[j - 1].append(py.value(v))
# for j in m1.h:
#     for k, v in m1.P_Buy_Peer.items():
#         if k[0] == j:
#             pl1_pbuy_peer[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_Sell_Grid.items():
        if k[0] == j:
            pl1_psell[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.P_EV_Charge.items():
        if k[0] == j:
            PEVCharge[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_EV_Disch_Home.items():
        if k[0] == j:
            PEVDischHome[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_EV_Disch_Grid.items():
        if k[0] == j:
            PEVDischGrid[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_ESS_Charge_Grid.items():
        if k[0] == j:
            PESSChargeGrid[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_ESS_Disch_Home.items():
        if k[0] == j:
            PESSDischHome[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_ESS_Charge.items():
        if k[0] == j:
            PESSCharge[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_ESS_Disch_Grid.items():
        if k[0] == j:
            PESSDischGrid[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.PV_Home.items():
        if k[0] == j:
            PVHome[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.PV_Grid.items():
        if k[0] == j:
            PVGrid[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.PV_Battery.items():
        if k[0] == j:
            PVBattery[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.PV.items():
        if k[0] == j:
            PPV[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.base_load.items():
        if k[0] == j:
            baseload[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.Energy_ESS.items():
        if k[0] == j:
            EnergyESS[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.Energy_EV.items():
        if k[0] == j:
            EnergyEV[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.P_EWH.items():
        if k[0] == j:
            PEWH[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.tetta_EWH_wat.items():
        if k[0] == j:
            tettaEWHwat[j - 1].append(py.value(v))

for j in m1.h:
    for k, v in m1.S_EWH.items():
        if k[0] == j:
            SEWH[j - 1].append(py.value(v))
for j in m1.h:
    for k, v in m1.cost.items():
        if k == j:
            cost_1[j - 1].append(py.value(v))
# for i in m1.Buy_price_Peer:
#     Buyprice_peer.append(py.value(m1.Buy_price_Peer[i]))
for i in m1.Buy_price:
    Buyprice.append(py.value(m1.Buy_price[i]))

for i in m1.Sell_price:
    Sellprice.append(py.value(m1.Sell_price[i]))
# for i in m1.Sell_price_Peer:
#     Sellprice_peer.append(py.value(m1.Sell_price_Peer[i]))

# # alone
# for k in range(len(m1.h)):
#     fig, ax = plt.subplots(5, 3, figsize=(10, 10))
#     ax[0, 0].bar(time, pbuy[k], label='Buying power')
#     ax[0, 0].bar(time, psell[k], label='Selling power')
#     ax[0, 0].legend(loc='best', fontsize='small', ncol=3)
#     ax[0, 1].bar(time, baseload[k], label='Base load', color='r')
#     ax[0, 1].legend(loc='best', fontsize='small', ncol=3)
#     ax[0, 2].plot(time, Buyprice, label='Buyprice')
#     ax[0, 2].plot(time, Sellprice, label='Sellprice')
#     ax[0, 2].legend(loc='best', fontsize='small', ncol=3)
#     ax[1, 0].bar(time, PEWH[k], label='EWH Power', color='r')
#     ax[1, 0].legend(loc='best', fontsize='small', ncol=3)
#     ax[1, 1].plot(time, tettaEWHwat[k], label='EWH Temp')
#     ax[1, 1].legend(loc='best', fontsize='small', ncol=3)
#     ax[1, 2].bar(time, SEWH[k], label='Status of EWH')
#     ax[1, 2].legend(loc='best', fontsize='small', ncol=3)
#     ax[2, 0].bar(time, PESSChargeGrid[k], label='ESS Charging from Grid', color='r')
#     ax[2, 0].bar(time, PVBattery[k], label='ESS Charging from PV', color='g')
#     ax[2, 0].legend(loc='best', fontsize='small', ncol=3)
#     ax[2, 1].bar(time, PESSDischHome[k], label='ESS Disch to home')
#     ax[2, 1].bar(time, PESSDischGrid[k], label='ESS Disch to grid')
#     ax[2, 1].legend(loc='best', fontsize='small', ncol=3)
#     ax[2, 2].plot(time, EnergyESS[k], label='Energy of ESS', color='g')
#     ax[2, 2].legend(loc='best', fontsize='small', ncol=3)
#     ax[3, 0].bar(time, PVHome[k], label='PV to Home')
#     ax[3, 0].legend(loc='best', fontsize='small', ncol=3)
#     ax[3, 1].bar(time, PVGrid[k], label='PV to Grid')
#     ax[3, 1].bar(time, PVBattery[k], label='PV to battery')
#     ax[3, 1].legend(loc='best', fontsize='small', ncol=3)
#     ax[3, 2].bar(time, PVHome[k], label='PV to Home')
#     ax[3, 2].bar(time, PVGrid[k], label='PV to Grid')
#     ax[3, 2].legend(loc='best', fontsize='small', ncol=3)
#     ax[4, 0].bar(time, PEVCharge[k], label='EV Charging power', color='r')
#     ax[4, 0].legend(loc='best', fontsize='small', ncol=3)
#     ax[4, 1].bar(time, PEVDischHome[k], label='EV Disch to home')
#     ax[4, 1].bar(time, PEVDischGrid[k], label='EV Disch to grid')
#     ax[4, 1].legend(loc='best', fontsize='small', ncol=3)
#     ax[4, 2].plot(time, EnergyEV[k], label='Energy of EV', color='r')
#     ax[4, 2].legend(loc='best', fontsize='small', ncol=3)
#     ax[4, 0].set_xlabel('Time (step)')
#     ax[4, 1].set_xlabel('Time (step)')
#     ax[4, 2].set_xlabel('Time (step)')
#     ax[0, 2].set_ylabel('price ($/W/h)')
#     ax[0, 0].set_ylabel('Power (kW)')
#     ax[1, 0].set_ylabel('Power (kW)')
#     ax[2, 0].set_ylabel('Power (kW)')
#     ax[3, 0].set_ylabel('Power (kW)')
#     ax[4, 0].set_ylabel('Power (kW)')
#     ax[2, 2].set_ylabel('Energy (kWh)')
#     ax[4, 2].set_ylabel('Energy (kWh)')
#     plt.suptitle(
#         f" Home {k + 1} : " f" Cost is :  {py.value((sum((m1.P_Buy_Grid[k + 1, i] * m1.Buy_price[i]) - (m1.P_Sell_Grid[k + 1, i] * m1.Sell_price[i]) for i in m1.t) * m1.time_d))}")
#     pl.tight_layout()
#     plt.show()
for k in m1.t:
    m1.combine[k] = (PEVCharge[1][k - 1] + PEWH[1][k - 1] + baseload[1][k - 1] + PESSChargeGrid[1][k - 1])
# # code for if you want to plot all the home togathoer
for i in m1.combine:
    combine.append(py.value(m1.combine[i]))
# fig, ax = plt.subplots(6, len(m1.h), constrained_layout=True, sharex='col',sharey='row')  # , sharey='row'
# gs = fig.add_gridspec(hspace=0, wspace=0)
# for k in range(len(m1.h)):
#     ax[0, k].bar(time, pl1_pbuy[k], color="blue")
#     ax[1, k].bar(time, pl1_psell[k], color="black")
#     # ax[2, k].bar(time, pl1_pbuy_peer[k], color="green")
#     # ax[3, k].bar(time, pl1_psell_peer[k], color="red")
#     # ax[4, 0].plot(time, Transformer_Limit, color="red")
#     # ax[4, 0].bar(time, Power_P_T, color="blue")
#     # ax[4, 0].legend(['Tranformer_limit'])
#     # ax[4, 1].plot(time, Transformer_Limit, color="red")
#     # ax[4, 1].bar(time, Power_T_P, color="blue")
#     # ax[4, 1].legend(['Power_T_P'])
#     # #     ax[0, k].plot(time, baseload[k], label='Base load')
#
#     ax[2, k].plot(time, Buyprice, label='Buyprice_G', color="blue")
#     # ax[4, 2].plot(time, Buyprice_peer, label='Buyprice_P', color="red")
#     ax[2, k].plot(time, Sellprice, label='Sellprice_G', color="green")
#     # ax[4, 2].plot(time, Sellprice_peer, label='Sellprice_P', color="black")
#     ax[2, 0].legend(['Buyprice_G', 'Sellprice_G'],loc='upper left', fontsize='xx-small')
#     # ax[4, 3].plot(time, HST, label='HST', color="red")
#     # ax[4, 3].plot(time, DHST, label='DHST', color="blue")
#     # ax[4, 3].plot(time, DTOT, label='DTOT', color="green")
#     # ax[4, 3].legend(['HST', 'DHST', 'DTOT'])
#
#     # ax[9, k].plot(time, PEWH[k], label='EWH Power')
#     ax[3, k].plot(time, tettaEWHwat[k], label='EWH Temp')
#     ax[3, 0].legend(ncol=3,loc='upper left', fontsize='xx-small')
#     # ax[5, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     # ax[3, k].plot(time, PESSCharge[k], label='ESS Charging power')
#     # ax[3, k].plot(time, PESSDischHome[k], label='ESS Disch to home')
#     # ax[3, k].plot(time, PESSDischGrid[k], label='ESS Disch to grid')
#     # ax[3, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     # ax[4, k].plot(time, PVHome[k], label='PV to Home')
#     # ax[4, k].plot(time, PVGrid[k], label='PV to Grid')
#     # ax[4, k].plot(time, PPV[k], label='All PV Production')
#     # ax[4, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     # ax[5, k].plot(time, PEVCharge[k], label='EV Charging power')
#     # ax[5, k].plot(time, PEVDischHome[k], label='EV Disch to home')
#     # ax[5, k].plot(time, PEVDischGrid[k], label='EV Disch to grid')
#     # ax[5, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     ax[4, k].plot(time, EnergyESS[k], label='Energy of ESS')
#     ax[4, 0].legend(ncol=3,loc='upper left', fontsize='xx-small')
#     ax[5, k].plot(time, EnergyEV[k], label='Energy of EV')
#     ax[5, 0].legend(ncol=3,loc='upper left', fontsize='xx-small')
#     ax[5, k].set_xlabel('Time (step)')
#     # #     ax[1, k].set_ylabel('Electricity price ($/W/h)')
#     ax[0, 0].set_ylabel('Dem', fontsize='x-small')
#     ax[1, 0].set_ylabel('Sel', fontsize='x-small')
#     ax[0, k].set_title(f"Home {k + 1}", fontsize='xx-small')
#     fig.suptitle('Home Profile before limit', fontsize=16)
# # #
# # pl.tight_layout()
#
# plt.show()

# # if you want to plot each home alone in the figure
# # for k in range(len(m1.h)):
# #     fig, ax = plt.subplots(2)
# #     ax[0].plot(time, pbuy[k], 'b-', label='Base')
# #     ax[0].plot(time, psell[k], 'g--', label='Controllable Load')
# #     ax[1].plot(time, Buyprice, label='buying price')
# #     ax[1].plot(time, Sellprice, 'y-+', label='selling price')
# #     ax[1].legend(loc='upper left')
# #     ax[1].set_xlabel('Time (hour)')
# #     ax[1].set_ylabel('Electricity price ($/W/h)')
# #     plt.suptitle(f"Home {k+1}")
# #     pl.tight_layout()
# #     plt.show()
#
# print('this is the end of code')
# # # # </editor-fold>

# </editor-fold>
# #</editor-fold>

#
# # <editor-fold desc="Ploting">

#
# # # # <editor-fold desc="Ploting">
# # #
# # # # Plotting for automatic ploting
# # time = [i for i in m1.t]
# pl2_pbuy = [[] for j in m1.h]
# # pl2_psell = [[] for j in m1.h]
# # # # PEVCharge = [[] for j in m1.h]
# # # # PESSChargeGrid = [[] for j in m1.h]
# # # # PEVDischHome = [[] for j in m1.h]
# # # # PESSDischHome = [[] for j in m1.h]
# # # # SEVCharge = [[] for j in m1.h]
# # # # SEVDisch = [[] for j in m1.h]
# # # # PEVDischGrid = [[] for j in m1.h]
# # # # PESSDischGrid = [[] for j in m1.h]
# # # # PVHome = [[] for j in m1.h]
# # # # PVGrid = [[] for j in m1.h]
# # # # PVBattery = [[] for j in m1.h]
# # # # PPV = [[] for j in m1.h]
# # # # baseload = [[] for j in m1.h]
# # # # EnergyESS = [[] for j in m1.h]
# # # # EnergyEV = [[] for j in m1.h]
# # # # tettaEWHwat = [[] for j in m1.h]
# # # # SEWH = [[] for j in m1.h]
# # # # PEWH = [[] for j in m1.h]
# # # # Buyprice = []  # cost = [i for i in m1.c.values()]  <<< check this
# # # # Sellprice = []
#
# for j in m1.h:
#     for k, v in m1.P_Buy_Grid.items():
#         if k[0] == j:
#             pl2_pbuy[j - 1].append(py.value(v))
# # for j in m1.h:
# #     for k, v in m1.P_Sell_Grid.items():
# #         if k[0] == j:
# #             pl2_psell[j - 1].append(py.value(v))
# # # #
# # # # for j in m1.h:
# # # #     for k, v in m1.P_EV_Charge.items():
# # # #         if k[0] == j:
# # # #             PEVCharge[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.P_EV_Disch_Home.items():
# # # #         if k[0] == j:
# # # #             PEVDischHome[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.P_EV_Disch_Grid.items():
# # # #         if k[0] == j:
# # # #             PEVDischGrid[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.P_ESS_Charge_Grid.items():
# # # #         if k[0] == j:
# # # #             PESSChargeGrid[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.P_ESS_Disch_Home.items():
# # # #         if k[0] == j:
# # # #             PESSDischHome[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.P_ESS_Disch_Grid.items():
# # # #         if k[0] == j:
# # # #             PESSDischGrid[j - 1].append(py.value(v))
# # # #
# # # # for j in m1.h:
# # # #     for k, v in m1.PV_Home.items():
# # # #         if k[0] == j:
# # # #             PVHome[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.PV_Grid.items():
# # # #         if k[0] == j:
# # # #             PVGrid[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.PV_Battery.items():
# # # #         if k[0] == j:
# # # #             PVBattery[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.PV.items():
# # # #         if k[0] == j:
# # # #             PPV[j - 1].append(py.value(v))
# # # #
# # # # for j in m1.h:
# # # #     for k, v in m1.base_load.items():
# # # #         if k[0] == j:
# # # #             baseload[j - 1].append(py.value(v))
# # # #
# # # # for j in m1.h:
# # # #     for k, v in m1.Energy_ESS.items():
# # # #         if k[0] == j:
# # # #             EnergyESS[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.Energy_EV.items():
# # # #         if k[0] == j:
# # # #             EnergyEV[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.P_EWH.items():
# # # #         if k[0] == j:
# # # #             PEWH[j - 1].append(py.value(v))
# # # # for j in m1.h:
# # # #     for k, v in m1.tetta_EWH_wat.items():
# # # #         if k[0] == j:
# # # #             tettaEWHwat[j - 1].append(py.value(v))
# # # #
# # # # for j in m1.h:
# # # #     for k, v in m1.S_EWH.items():
# # # #         if k[0] == j:
# # # #             SEWH[j - 1].append(py.value(v))
# # # #
# # # # for i in m1.Buy_price:
# # # #     Buyprice.append(value(m1.Buy_price[i]))
# # # #
# # # # for i in m1.Sell_price:
# # # #     Sellprice.append(value(m1.Sell_price[i]))
# # # #
# # # # # alone
# # # for k in range(len(m1.h)):
# # #     fig, ax = plt.subplots(5, 2, figsize=(10, 10))
# # #     ax[0, 0].bar(time, pl2_pbuy[k], label='Buying power-obj2')
# # #     ax[0, 0].bar(time, pl1_pbuy[k], label='Buying power-obj1')
# # #     ax[1, 0].bar(time, pl2_psell[k], label='Selling power-obj2')
# # #     ax[1, 0].bar(time, pl1_psell[k], label='Selling power-obj1')
# # #     ax[0, 0].legend(loc='best', fontsize='small', ncol=3)
# # #     ax[1, 0].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[0, 1].bar(time, baseload[k], label='Base load', color='r')
# # # # #     ax[0, 1].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[0, 2].plot(time, Buyprice, label='Buyprice')
# # # # #     ax[0, 2].plot(time, Sellprice, label='Sellprice')
# # # # #     ax[0, 2].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[1, 0].bar(time, PEWH[k], label='EWH Power', color='r')
# # # # #     ax[1, 0].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[1, 1].plot(time, tettaEWHwat[k], label='EWH Temp')
# # # # #     ax[1, 1].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[1, 2].bar(time, SEWH[k], label='Status of EWH')
# # # # #     ax[1, 2].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[2, 0].bar(time, PESSChargeGrid[k], label='ESS Charging from Grid', color='r')
# # # # #     ax[2, 0].bar(time, PVBattery[k], label='ESS Charging from PV', color='g')
# # # # #     ax[2, 0].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[2, 1].bar(time, PESSDischHome[k], label='ESS Disch to home')
# # # # #     ax[2, 1].bar(time, PESSDischGrid[k], label='ESS Disch to grid')
# # # # #     ax[2, 1].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[2, 2].plot(time, EnergyESS[k], label='Energy of ESS', color='g')
# # # # #     ax[2, 2].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[3, 0].bar(time, PVHome[k], label='PV to Home')
# # # # #     ax[3, 0].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[3, 1].bar(time, PVGrid[k], label='PV to Grid')
# # # # #     ax[3, 1].bar(time, PVBattery[k], label='PV to battery')
# # # # #     ax[3, 1].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[3, 2].bar(time, PVHome[k], label='PV to Home')
# # # # #     ax[3, 2].bar(time, PVGrid[k], label='PV to Grid')
# # # # #     ax[3, 2].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[4, 0].bar(time, PEVCharge[k], label='EV Charging power', color='r')
# # # # #     ax[4, 0].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[4, 1].bar(time, PEVDischHome[k], label='EV Disch to home')
# # # # #     ax[4, 1].bar(time, PEVDischGrid[k], label='EV Disch to grid')
# # # # #     ax[4, 1].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[4, 2].plot(time, EnergyEV[k], label='Energy of EV', color='r')
# # # # #     ax[4, 2].legend(loc='best', fontsize='small', ncol=3)
# # # # #     ax[4, 0].set_xlabel('Time (step)')
# # # # #     ax[4, 1].set_xlabel('Time (step)')
# # # # #     ax[4, 2].set_xlabel('Time (step)')
# # # # #     ax[0, 2].set_ylabel('price ($/W/h)')
# # # # #     ax[0, 0].set_ylabel('Power1 (kW)')
# # # # #     ax[1, 0].set_ylabel('Power (kW)')
# # # # #     ax[2, 0].set_ylabel('Power (kW)')
# # # # #     ax[3, 0].set_ylabel('Power (kW)')
# # # # #     ax[4, 0].set_ylabel('Power (kW)')
# # # # #     ax[2, 2].set_ylabel('Energy (kWh)')
# # # # #     ax[4, 2].set_ylabel('Energy (kWh)')
# # #     plt.suptitle(
# # #         f" Home {k + 1} : " f" Cost is :  {py.value((sum(m1.P_Buy_Grid[k + 1, i]  for i in m1.t) * m1.time_d))}")
# # #     pl.tight_layout()
# # #     plt.show()
# # # #
# # # # # code for if you want to plot all the home togathoer
# # fig, ax = plt.subplots(4, len(m1.h), figsize=(10, 10), constrained_layout=True, sharex='col', sharey='row')
# # gs = fig.add_gridspec(hspace=0, wspace=0)
# # for k in range(len(m1.h)):
# #     ax[0, k].bar(time, pl1_pbuy[k], color='green')
# #     ax[1, k].bar(time, pl2_pbuy[k], color='blue')
# #     ax[2, k].bar(time, pl1_psell[k], color='green')
# #     ax[3, k].bar(time, pl2_psell[k], label='blue')
# #     # ax[0, k].legend(loc='best')
# #     # ax[1, k].legend(loc='best')
# #     # ax[2, k].legend(loc='best')
# #     # ax[3, k].legend(loc='best')
# #     # #     ax[0, k].plot(time, baseload[k], label='Base load')
# #     #     # #     ax[1, k].plot(time, Buyprice,  label='Buyprice')
# #     # #     ax[1, k].legend(loc='best')
# #     #     # #     ax[1, k].plot(time, Sellprice, label='Sellprice')
# #     #     # #     ax[1, k].legend(loc='best')
# #     #     # #     ax[2, k].plot(time, PEWH[k], label='EWH Power')
# #     #     # #     ax[2, k].plot(time, tettaEWHwat[k], label='EWH Temp')
# #     #     # #     ax[2, k].legend(loc='best')
# #     #     # #     ax[3, k].plot(time, PESSCharge[k],label='ESS Charging power')
# #     #     # #     ax[3, k].plot(time, PESSDischHome[k], label='ESS Disch to home')
# #     #     # #     ax[3, k].plot(time, PESSDischGrid[k], label='ESS Disch to grid')
# #     #     # #     ax[3, k].legend(loc='best')
# #     #     # #     ax[4, k].plot(time, PVHome[k], label='PV to Home')
# #     #     # #     ax[4, k].plot(time, PVGrid[k], label='PV to Grid')
# #     #     # #     ax[4, k].plot(time, PPV[k], label='All PV Production')
# #     #     # #     ax[4, k].legend(loc='best')
# #     #     # #     ax[5, k].plot(time, PEVCharge[k], label='EV Charging power')
# #     #     # #     ax[5, k].plot(time, PEVDischHome[k], label='EV Disch to home')
# #     #     # #     ax[5, k].plot(time, PEVDischGrid[k], label='EV Disch to grid')
# #     #     # #     ax[5, k].legend(loc='best')
# #     #     # #     ax[6, k].plot(time, EnergyESS[k], label='Energy of ESS')
# #     #     # #     ax[6, k].legend(loc='best')
# #     #     # #     ax[7, k].plot(time, EnergyEV[k], label='Energy of EV')
# #     #     # #     ax[7, k].legend(loc='best')
# #     #     # #     ax[4, k].set_xlabel('Time (step)')
# #     #     # #     ax[1, k].set_ylabel('Electricity price ($/W/h)')
# #     ax[0, 0].set_ylabel(
# #         'Buy-Power1 (kW)')  # showing only on the side of the graph if you want to put it on all need to use [0,k]
# #     ax[1, 0].set_ylabel('Buy-Power2 (kW)')
# #     ax[2, 0].set_ylabel('Sell-Power1 (kW)')
# #     ax[3, 0].set_ylabel('Sell-Power2 (kW)')
# #
# #     ax[0, k].set_title(f"Home {k + 1}", fontsize='xx-small')
# #     fig.suptitle('Cost and Energy minimization', fontsize=16)
# #
# # plt.show()
# # #
# # # # if you want to plot each home alone in the figure
# # # # for k in range(len(m1.h)):
# # # #     fig, ax = plt.subplots(2)
# # # #     ax[0].plot(time, pbuy[k], 'b-', label='Base')
# # # #     ax[0].plot(time, psell[k], 'g--', label='Controllable Load')
# # # #     ax[1].plot(time, Buyprice, label='buying price')
# # # #     ax[1].plot(time, Sellprice, 'y-+', label='selling price')
# # # #     ax[1].legend(loc='upper left')
# # # #     ax[1].set_xlabel('Time (hour)')
# # # #     ax[1].set_ylabel('Electricity price ($/W/h)')
# # # #     plt.suptitle(f"Home {k+1}")
# # # #     pl.tight_layout()
# # # #     plt.show()
# # #
# # # print('this is the end of code')
# # # </editor-fold>
#
# writer = pd.ExcelWriter('Result_HEMS.xlsx', engine='xlsxwriter')
# time_excel = pd.DataFrame({'Time_Step': time})
# time_excel.to_excel(writer, sheet_name='Power', startcol=0, index=False, header=True)
# for h in range(len(m1.h)):
#     pload_excel = pd.DataFrame({f"Power_Demand {h + 1}": pl1_pbuy[h]})
#     pload_excel.to_excel(writer, sheet_name='Power', startcol=h + 1, index=False, header=True)
#
#     pload_excel = pd.DataFrame({f"Power_Sell {h + 1}": pl1_psell[h]})
#     pload_excel.to_excel(writer, sheet_name='Power', startcol=h + 4, index=False, header=True)
# writer.save()


# fig_HEMS, ax = plt.subplots(5, len(m1.h), constrained_layout=True, sharex='col', sharey='row')  # , sharey='row'
# gs = fig_HEMS.add_gridspec(hspace=0, wspace=0)
# for k in range(len(m1.h)):
#     ax[0, k].bar(time, pl1_pbuy[k], color="blue")
#     ax[1, k].bar(time, pl1_psell[k], color="black")
#     # ax[2, k].bar(time, pl1_pbuy_peer[k], color="green")
#     # ax[3, k].bar(time, pl1_psell_peer[k], color="red")
#     # ax[4, 0].plot(time, Transformer_Limit, color="red")
#     # ax[4, 0].bar(time, Power_P_T, color="blue")
#     # ax[4, 0].legend(['Tranformer_limit'])
#     # ax[4, 1].plot(time, Transformer_Limit, color="red")
#     # ax[4, 1].bar(time, Power_T_P, color="blue")
#     # ax[4, 1].legend(['Power_T_P'])
#     # #     ax[0, k].plot(time, baseload[k], label='Base load')
#
#     # ax[2, k].plot(time, Buyprice, label='Buyprice_G', color="blue")
#     # ax[4, 2].plot(time, Buyprice_peer, label='Buyprice_P', color="red")
#     # ax[2, k].plot(time, Sellprice, label='Sellprice_G', color="green")
#     # ax[4, 2].plot(time, Sellprice_peer, label='Sellprice_P', color="black")
#     # ax[2, 0].legend(['Buyprice_G', 'Sellprice_G'],loc='upper left', fontsize='xx-small')
#     # ax[4, 3].plot(time, HST, label='HST', color="red")
#     # ax[4, 3].plot(time, DHST, label='DHST', color="blue")
#     # ax[4, 3].plot(time, DTOT, label='DTOT', color="green")
#     # ax[4, 3].legend(['HST', 'DHST', 'DTOT'])
#
#     # ax[9, k].plot(time, PEWH[k], label='EWH Power')
#     ax[2, k].plot(time, tettaEWHwat[k], label='EWH Temp')
#     ax[2, 0].legend(ncol=3, loc='upper left', fontsize='xx-small')
#     # ax[5, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     # ax[3, k].plot(time, PESSCharge[k], label='ESS Charging power')
#     # ax[3, k].plot(time, PESSDischHome[k], label='ESS Disch to home')
#     # ax[3, k].plot(time, PESSDischGrid[k], label='ESS Disch to grid')
#     # ax[3, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     # ax[4, k].plot(time, PVHome[k], label='PV to Home')
#     # ax[4, k].plot(time, PVGrid[k], label='PV to Grid')
#     # ax[4, k].plot(time, PPV[k], label='All PV Production')
#     # ax[4, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     # ax[5, k].plot(time, PEVCharge[k], label='EV Charging power')
#     # ax[5, k].plot(time, PEVDischHome[k], label='EV Disch to home')
#     # ax[5, k].plot(time, PEVDischGrid[k], label='EV Disch to grid')
#     # ax[5, 0].legend(ncol=3,loc='best', fontsize='xx-small')
#     ax[3, k].plot(time, EnergyESS[k], label='Energy of ESS')
#     ax[3, 0].legend(ncol=3, loc='upper left', fontsize='xx-small')
#     ax[4, k].bar(time, EnergyEV[k], label='Energy of EV')
#     ax[4, 0].legend(ncol=3, loc='upper left', fontsize='xx-small')
#     ax[4, k].set_xlabel('Time (step)')
#     # #     ax[1, k].set_ylabel('Electricity price ($/W/h)')
#     ax[0, 0].set_ylabel('Dem', fontsize='x-small')
#     ax[1, 0].set_ylabel('Sel', fontsize='x-small')
#     ax[0, k].set_title(f"Home {k + 1}", fontsize='xx-small')
#     fig_HEMS.suptitle('Home Profile', fontsize=16)
# # #
# # pl.tight_layout()
#
# plt.show()

# stack plot of power demand of one house :
# Generate some example data
# Plot stacked bar chart
fig_all, axs = plt.subplots(5, 2, figsize=(8, 8),constrained_layout=True, sharex='col', sharey='row')
labels = ('EV_Charging', 'Power_EWH', 'Baseload', 'Battery_Charging')
data_lists = [(PEVCharge[i], PEWH[i], baseload[i], PESSChargeGrid[i]) for i in range(10)]
rc('font', family='Times New Roman')
for i, ax in enumerate(axs.flat):
    bottom = np.zeros(len(time))
    ax.set_xlim([0, 98])
    ax.set_ylim([0, 18])
    ax.set_xticks(np.arange(0, 98, 6))
    # ax.set_yticks(np.arange(0, 24, 4))
    for label, data in zip(labels, data_lists[i]):
        ax.bar(time, data, bottom=bottom, label=label)
        bottom += data
        # if i == 3 or i == 6 or i ==9:
        #     ax.set_title(f'Consumer-{i+1}', fontname='Times New Roman', fontsize=12)
        # else:
        ax.set_title(f'Prosumer-{i + 1}', fontname='Times New Roman', fontsize=12)
        ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
    if i == 0 or i == 2 or i == 4 or i == 6 or i == 8:
        ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
        ax.set_yticks(np.arange(0, 18, 4))
    else:
        ax.set_ylabel('')
    if i == 8 or i == 9:
        ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
        ax.tick_params(axis='x', which='both', labelsize=12)
    else:
        ax.tick_params(axis='x', which='both', bottom=True, labelbottom=False)  # modified
        ax.set_xticks([])  # added
handles, labels = ax.get_legend_handles_labels()

fig_all.legend(handles, labels, loc='lower center', ncol=4, fontsize=12)
plt.tight_layout()
fig_all.subplots_adjust(bottom=0.129)
plt.show()
#
# fig_h1, ax = plt.subplots(constrained_layout=True,figsize=(8, 4))
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[0], PEWH[0], baseload[0], PESSChargeGrid[0]]
# rc('font', family='Times New Roman')
# bottom_h1 = np.zeros(len(time))
# for label_h1, data_h1 in zip(labels_h1, data_list_h1):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1)
#     bottom_h1 += data_h1
# # Set plot labels and title
# ax.set_ylabel('Power demand (kW)',fontname='Times New Roman',fontsize=12)
# # ax.set_title('Power demand (Prosumer-1)', fontname='Times New Roman')
# ax.legend(loc='upper left',fontsize=12,ncol=2)
# ax.set_xlabel('Time (15 min interval)',fontname='Times New Roman',fontsize=12)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# # Show plot
# plt.show()
#
#
# fig_h2, ax = plt.subplots(constrained_layout=True,figsize=(8, 4))
# labels_h2 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h2 = [PEVCharge[1], PEWH[1], baseload[1], PESSChargeGrid[1]]
# rc('font', family='Times New Roman')
# bottom_h2 = np.zeros(len(time))
# for label_h2, data_h2 in zip(labels_h2, data_list_h2):
#     ax.bar(time, data_h2, bottom=bottom_h2, label=label_h2)
#     bottom_h2 += data_h2
# # ax.plot(time,combine)
# # Set plot labels and title
# ax.set_ylabel('Power demand (kW)', fontname='Times New Roman',fontsize=12)
# # ax.set_title('Power demand (Prosumer-2)', fontname='Times New Roman',fontsize=12)
# ax.legend(loc='upper left',fontsize=12,ncol=2)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman',fontsize=12)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# # Show plot
# plt.show()
#
#
# fig_h3, ax = plt.subplots(constrained_layout=True,figsize=(8, 4))
# labels_h3 = ( 'Power_EWH', 'Baseload')
# data_list_h3 = [PEWH[2], baseload[2]]
# rc('font', family='Times New Roman')
# colors = ['orange', 'green']
# bottom_h3 = np.zeros(len(time))
# # for i,(label_h3, data_h3) in zip(labels_h3, data_list_h3):
# #     ax.bar(time, data_h3, bottom=bottom_h3, label=label_h3, color=colors[label_h3])
# #     bottom_h3 += data_h3
# for i, (label_h3, data_h3) in enumerate(zip(labels_h3, data_list_h3)):
#     ax.bar(time, data_h3, bottom=bottom_h3, label=label_h3, color=colors[i])
#     bottom_h3 += data_h3
#
# # ax.plot(time,combine)
# # Set plot labels and title
# ax.set_ylabel('Power demand (kW)', fontname='Times New Roman',fontsize=12)
# # ax.set_title('Power demand (Consumer-3)', fontname='Times New Roman',fontsize=12)
# ax.legend(loc='upper left',ncol=2,fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman',fontsize=12)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# # Show plot
# plt.show()


# stack plot for the selling energy to the grid
# Plot stacked bar chart

fig_all_sell, axs = plt.subplots(5, 2, sharex='col',constrained_layout=True, figsize=(8, 8), sharey='row')
labels = ('EV-Discharging_Grid', 'EV-Discharging_Home', 'PV_Grid', 'PV_Home', 'PV_Battery', 'Battery-Discharging_Grid',
          'Battery-Discharging_Home')
data_lists = [(PEVDischGrid[k], PEVDischHome[k], PVGrid[k], PVHome[k], PVBattery[k], PESSDischGrid[k], PESSDischHome[k])
              for k in range(10)]
rc('font', family='Times New Roman')
for i, ax in enumerate(axs.flat):
    bottom = np.zeros(len(time))
    ax.set_xlim([0, 98])
    ax.set_ylim([0, 14])
    ax.set_xticks(np.arange(0, 98, 6))
    # ax.set_xticks(
    #     ['9am', '10am', '11am', '12pm', '1pm', '2pm', '3pm', '4pm', '5pm', '6pm', '7pm', '8pm', '9pm', '10pm', '11pm',
    #      '12am', '1am','2am', '3am', '4am', '5am', '6am', '7am', '8am'])

    for label, data in zip(labels, data_lists[i]):
        ax.bar(time, data, bottom=bottom, label=label)
        bottom += data
        # if i == 3 or i == 6 or i ==9:
        #     ax.set_title(f'Consumer-{i+1}', fontname='Times New Roman', fontsize=12)
        # else:
        ax.set_title(f'Prosumer-{i + 1}', fontname='Times New Roman', fontsize=12)
    ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
    if i == 0 or i == 2 or i == 4 or i == 6 or i == 8:
        ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
        ax.set_yticks(np.arange(0, 14, 2))
    else:
        ax.set_ylabel('')
    if i == 8 or i == 9:
        ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
        ax.tick_params(axis='x', which='both', labelsize=12)
    else:
        ax.tick_params(axis='x', which='both', bottom=True, labelbottom=False)  # modified
        ax.set_xticks([])  # added
handles, labels = ax.get_legend_handles_labels()
fig_all_sell.legend(handles, labels, loc='lower center', ncol=4, fontsize=10)
plt.tight_layout()
fig_all_sell.subplots_adjust(bottom=0.14)
plt.show()

# fig2_h1, ax = plt.subplots(constrained_layout=True,figsize=(8, 4))
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[0],PEVDischHome[0], PVGrid[0],PVHome[0],PVBattery[0], PESSDischGrid[0],PESSDischHome[0]]
# bottom2_h1 = np.zeros(len(time))
# for label2_h1, data2_h1 in zip(labels2_h1, data_list2_h1):
#     ax.bar(time, data2_h1, bottom=bottom2_h1, label=label2_h1)
#     bottom2_h1 += data2_h1
# # Set plot labels and title
# ax.set_ylabel('Power Export (kW)', fontname='Times New Roman',fontsize=12)
# ax.set_xlabel('Time (15 min interval)',fontname='Times New Roman',fontsize=12)
# # ax.set_title('Power Export (Prosumer-1)', fontname='Times New Roman',fontsize=12)
# ax.legend(loc='upper left',ncol=3,fontsize=12)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 96, 4))
# # Show plot
# plt.show()

# fig_one, ax = plt.subplots(constrained_layout=True, figsize=(9, 6))
#
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[0], PEWH[0], baseload[0], PESSChargeGrid[0]]
# bottom_h1 = np.zeros(len(time))
# colors_h1 = ['red', 'blue', 'green', 'purple']
# for label_h1, data_h1, color_h1 in zip(labels_h1, data_list_h1, colors_h1):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1, color=color_h1)
#     bottom_h1 += data_h1
#
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[0], PEVDischHome[0], PVGrid[0], PVHome[0], PVBattery[0], PESSDischGrid[0], PESSDischHome[0]]
# bottom2_h1 = np.zeros(len(time))
# colors2_h1 = ['orange', 'pink', 'brown', 'gray', 'cyan', 'magenta', 'skyblue']
# for label2_h1, data2_h1, color2_h1 in zip(labels2_h1, data_list2_h1, colors2_h1):
#     ax.bar(time, np.negative(data2_h1), bottom=bottom2_h1[-len(data2_h1):], label=label2_h1, color=color2_h1) # invert the y-axis by negating the data and bottom values
#     bottom2_h1[-len(data2_h1):] -= data2_h1
#
# ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
# ax.legend(loc='upper left', fontsize=12, ncol=2)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
#
# plt.show()
#
# my_palette = ['#FF5733', '#C70039', '#900C3F', '#581845', '#2E86C1', '#28B463', '#F7DC6F', '#F39C12', '#D35400', '#8E44AD', '#5D6D7E', '#34495E', '#2C3E50', '#ECF0F1']
#
# palette = sns.color_palette(my_palette)
# fig_one, ax = plt.subplots(constrained_layout=True, figsize=(9, 6))
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[0], PEWH[0], baseload[0], PESSChargeGrid[0]]
# bottom_h1 = np.zeros(len(time))
# for label_h1, data_h1, color_h1 in zip(labels_h1, data_list_h1, palette[:4]):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1, color=color_h1)
#     bottom_h1 += data_h1
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[0], PEVDischHome[0], PVGrid[0], PVHome[0], PVBattery[0], PESSDischGrid[0], PESSDischHome[0]]
# bottom2_h1 = np.zeros(len(time))
# for label2_h1, data2_h1, color2_h1 in zip(labels2_h1, data_list2_h1, palette[4:]):
#     ax.bar(time, np.negative(data2_h1), bottom=bottom2_h1[-len(data2_h1):], label=label2_h1, color=color2_h1) # invert the y-axis by negating the data and bottom values
#     bottom2_h1[-len(data2_h1):] -= data2_h1
# ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
# ax.legend(loc='upper left', fontsize=12, ncol=2)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# def pos_int(x, pos):
#     return abs(int(x))
#
# # Format y-axis ticks and labels
# y_ticks = ticker.FuncFormatter(pos_int)
# ax.yaxis.set_major_formatter(y_ticks)
# plt.show()


# fig_two, ax = plt.subplots(constrained_layout=True, figsize=(9, 6))
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[1], PEWH[1], baseload[1], PESSChargeGrid[1]]
# bottom_h1 = np.zeros(len(time))
# for label_h1, data_h1, color_h1 in zip(labels_h1, data_list_h1, palette[:4]):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1, color=color_h1)
#     bottom_h1 += data_h1
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[1], PEVDischHome[1], PVGrid[1], PVHome[1], PVBattery[1], PESSDischGrid[1], PESSDischHome[1]]
# bottom2_h1 = np.zeros(len(time))
# for label2_h1, data2_h1, color2_h1 in zip(labels2_h1, data_list2_h1, palette[4:]):
#     ax.bar(time, np.negative(data2_h1), bottom=bottom2_h1[-len(data2_h1):], label=label2_h1, color=color2_h1) # invert the y-axis by negating the data and bottom values
#     bottom2_h1[-len(data2_h1):] -= data2_h1
# ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
# ax.legend(loc='upper left', fontsize=12, ncol=2)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# def pos_int(x, pos):
#     return abs(int(x))
#
# # Format y-axis ticks and labels
# y_ticks = ticker.FuncFormatter(pos_int)
# ax.yaxis.set_major_formatter(y_ticks)
# plt.show()


# fig_three, ax = plt.subplots(constrained_layout=True, figsize=(9, 6))
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[2], PEWH[2], baseload[2], PESSChargeGrid[2]]
# bottom_h1 = np.zeros(len(time))
# for label_h1, data_h1, color_h1 in zip(labels_h1, data_list_h1, palette[:4]):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1, color=color_h1)
#     bottom_h1 += data_h1
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[2], PEVDischHome[2], PVGrid[2], PVHome[2], PVBattery[2], PESSDischGrid[2], PESSDischHome[2]]
# bottom2_h1 = np.zeros(len(time))
# for label2_h1, data2_h1, color2_h1 in zip(labels2_h1, data_list2_h1, palette[4:]):
#     ax.bar(time, np.negative(data2_h1), bottom=bottom2_h1[-len(data2_h1):], label=label2_h1, color=color2_h1) # invert the y-axis by negating the data and bottom values
#     bottom2_h1[-len(data2_h1):] -= data2_h1
# ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
# ax.legend(loc='upper left', fontsize=12, ncol=2)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# def pos_int(x, pos):
#     return abs(int(x))
#
# # Format y-axis ticks and labels
# y_ticks = ticker.FuncFormatter(pos_int)
# ax.yaxis.set_major_formatter(y_ticks)
# plt.show()

# fig_four, ax = plt.subplots(constrained_layout=True, figsize=(9, 6))
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[3], PEWH[3], baseload[3], PESSChargeGrid[3]]
# bottom_h1 = np.zeros(len(time))
# for label_h1, data_h1, color_h1 in zip(labels_h1, data_list_h1, palette[:4]):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1, color=color_h1)
#     bottom_h1 += data_h1
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[3], PEVDischHome[3], PVGrid[3], PVHome[3], PVBattery[3], PESSDischGrid[3], PESSDischHome[3]]
# bottom2_h1 = np.zeros(len(time))
# for label2_h1, data2_h1, color2_h1 in zip(labels2_h1, data_list2_h1, palette[4:]):
#     ax.bar(time, np.negative(data2_h1), bottom=bottom2_h1[-len(data2_h1):], label=label2_h1, color=color2_h1) # invert the y-axis by negating the data and bottom values
#     bottom2_h1[-len(data2_h1):] -= data2_h1
# ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
# ax.legend(loc='upper left', fontsize=12, ncol=2)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# def pos_int(x, pos):
#     return abs(int(x))
#
# # Format y-axis ticks and labels
# y_ticks = ticker.FuncFormatter(pos_int)
# ax.yaxis.set_major_formatter(y_ticks)
# plt.show()


#
# fig_one, ax = plt.subplots(constrained_layout=True, figsize=(9, 6))
# labels_h1 = ('EV_Charging', 'Power_EWH', 'Baseload', 'ESS_Charging')
# data_list_h1 = [PEVCharge[0], PEWH[0], baseload[0], PESSChargeGrid[0]]
# bottom_h1 = np.zeros(len(time))
# colors_h1 = ['#FF5733', '#2471A3', '#4CAF50', '#9B59B6']
# for label_h1, data_h1, color_h1 in zip(labels_h1, data_list_h1, colors_h1):
#     ax.bar(time, data_h1, bottom=bottom_h1, label=label_h1, color=color_h1)
#     bottom_h1 += data_h1
# labels2_h1 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h1 = [PEVDischGrid[0], PEVDischHome[0], PVGrid[0], PVHome[0], PVBattery[0], PESSDischGrid[0], PESSDischHome[0]]
# bottom2_h1 = np.zeros(len(time))
# colors2_h1 = ['#FF8C42', '#3498DB', '#2ECC71', '#8E44AD', '#FFC300', '#E74C3C', '#85C1E9']
# for label2_h1, data2_h1, color2_h1 in zip(labels2_h1, data_list2_h1, colors2_h1):
#     ax.bar(time, np.negative(data2_h1), bottom=bottom2_h1[-len(data2_h1):], label=label2_h1, color=color2_h1)
#     bottom2_h1[-len(data2_h1):] -= data2_h1
# ax.set_ylabel('Power (kW)', fontname='Times New Roman', fontsize=12)
# ax.set_xlabel('Time (15 min interval)', fontname='Times New Roman', fontsize=12)
# ax.legend(loc='upper left', fontsize=12, ncol=2)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 98, 4))
# plt.show()
#

#
#
#
#
# fig2_h2, ax = plt.subplots(constrained_layout=True,figsize=(8, 4))
# labels2_h2 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h2 = [PEVDischGrid[1],PEVDischHome[1], PVGrid[1],PVHome[1],PVBattery[1], PESSDischGrid[1],PESSDischHome[1]]
# bottom2_h2 = np.zeros(len(time))
# for label2_h2, data2_h2 in zip(labels2_h2, data_list2_h2):
#     ax.bar(time, data2_h2, bottom=bottom2_h2, label=label2_h2)
#     bottom2_h2 += data2_h2
# # Set plot labels and title
# ax.set_ylabel('Power Export (kW)', fontname='Times New Roman',fontsize=12)
# ax.set_xlabel('Time (15 min interval)',fontname='Times New Roman',fontsize=12)
# # ax.set_title('Power Export (Prosumer-2)', fontname='Times New Roman',fontsize=12)
# ax.legend(loc='upper left',ncol=3,fontsize=12)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 96, 4))
# # Show plot
# plt.show()
#
#
# fig2_h3, ax = plt.subplots(constrained_layout=True,figsize=(8, 4))
# labels2_h3 = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list2_h3 = [PEVDischGrid[2],PEVDischHome[2], PVGrid[2],PVHome[2],PVBattery[2], PESSDischGrid[2],PESSDischHome[2]]
# bottom2_h3 = np.zeros(len(time))
# for label2_h3, data2_h3 in zip(labels2_h3, data_list2_h3):
#     ax.bar(time, data2_h3, bottom=bottom2_h3, label=label2_h3)
#     bottom2_h3 += data2_h3
# # Set plot labels and title
# ax.set_ylabel('Power Export (kW)', fontname='Times New Roman')
# ax.set_xlabel('Time (15 min interval)',fontsize=13, fontname='Times New Roman')
# # ax.set_title('Power Export (Consumer-3)', fontname='Times New Roman')
# ax.legend(loc='upper left',ncol=3)
# ax.set_xlim([0, 97])
# ax.set_xticks(np.arange(0, 96, 4))
# # Show plot
# plt.show()


# <editor-fold desc="Home Model for Minimizing Energy">
m2 = py.ConcreteModel()

# <editor-fold desc="Set and Parameters of HOME">
# m2.h1 = py.Set(initialize=sheet_home.home_bus)
#
# m2.h2 = py.Set(initialize=sheet_home.home)
# m2.h = py.Set(m2.h1, m2.h2)
#
#
# def homeset(m):
#     return
#     # ({h1: h2} for h1 in m2.h1 for h2 in m2.h2)
# # create sets with NO indexes
# m2.setHomes = py.Set(initialize=sheet_home.home.unique())
# m2.setBuses = py.Set(initialize=sheet_home.home_bus.unique())
#
# # create sets WITH indexes
# dict_home_givenBus = {j: sheet_home.home[sheet_home.home_bus == j].unique() for j in m2.setBuses}
# m2.setHome_givenBus = py.Set(m2.setBuses, initialize=dict_home_givenBus)
#
# dict_bus_givenHome = {h:int(sheet_home.home_bus[sheet_home.home==h]) for h in m2.setHomes}
# m2.setBuses_givenHome = py.Param(m2.setHomes, initialize=dict_bus_givenHome)
m2.b = py.Set(initialize=sheet_bus.bus, doc='bus')

m2.h = py.Set(initialize=sheet_home.home)
m2.alpha = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                              [i for x in sheet_EV.columns if "arrival" in x for i
                                               in
                                               sheet_EV.loc[:, x].values])), doc="Arrival time of EV")

m2.beta = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                             [i for x in sheet_EV.columns if "departure" in x for i
                                              in
                                              sheet_EV.loc[:, x].values])), doc="departure time of EV")
m2.t_final = py.Param(initialize=96, doc='final time of the day ')  # 96
m2.second = py.Param(initialize=2, doc='second time of the day ')
m2.t = py.Set(initialize=sheet_data.time, ordered=True, doc='time period')
# m2.EV_Dur = py.Set(initialize=py.RangeSet(m2.alpha.value, m2.beta.value),
#                    doc='time interval for EV')
# m2.EV_Dur1 = py.Set(initialize=py.RangeSet(m2.alpha.value + 1, m2.beta.value),
#                     doc='time interval for EV after arrival')
m2.t_second = py.Set(initialize=py.RangeSet(m2.second.value, m2.t_final.value),
                     doc='time greater then 1')
m2.t_first = py.Param(initialize=1, doc='first time of the day ')
# m2.ist_interval = py.Set(initialize=py.RangeSet(m2.t_first.value, m2.alpha.value - 1),
#                          doc='time period before the arrival time')
# m2.second_interval = py.Set(initialize=py.RangeSet(m2.beta.value + 1, m2.t_final.value),
#                             doc='time interval after departure')
m2.EV_Dur1 = py.Set(m2.h, initialize=lambda m, h: range(m.alpha[h] + 1, m.beta[h] + 1), doc='time interval for EV')
m2.EV_Dur = py.Set(m2.h, initialize=lambda m, h: range(m.alpha[h], m.beta[h] + 1), doc='time interval for EV')
m2.ist_interval = py.Set(m2.h, initialize=lambda m, h: range(m2.t_first.value, m.alpha[h]), doc='time interval for EV')
m2.second_interval = py.Set(m2.h, initialize=lambda m, h: range(m.beta[h] + 1, m2.t_final.value + 1),
                            doc='time interval after departure')

# </editor-fold>

# <editor-fold desc="base load and other Parameters of Home">
# Base load : uncontrollable loads
m2.base_load = py.Param(m2.h, m2.t,
                        initialize=dict(zip(list(itertools.product(m2.h.data(), m2.t.data())),
                                            [i for x in sheet_load.columns if "load" in x for i in
                                             sheet_load.loc[:, x].values])), doc="Base Load")

m2.PV = py.Param(m2.h, m2.t, initialize=dict(zip(list(itertools.product(m2.h.data(), m2.t.data())),
                                                 [i for x in sheet_PV.columns if "PV" in x for i in
                                                  sheet_PV.loc[:, x].values])), doc="PV Production")
m2.max = py.Param(initialize=10000, doc='maximum value for selling and buying power')

# </editor-fold>

# <editor-fold desc="Electric Vehicle Parameters">

m2.ChargeRate_EV = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                                      [i for x in sheet_EV.columns if "charging_rate" in x for i
                                                       in
                                                       sheet_EV.loc[:, x].values])), doc="charging rate of EV")

m2.DischRate_EV = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                                     [i for x in sheet_EV.columns if "rate_of_discharging" in x
                                                      for i in
                                                      sheet_EV.loc[:, x].values])), doc="Discharging rate of EV")

m2.Ch_Effc_EV = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                                   [i for x in sheet_EV.columns if "charging_efficiency" in x for
                                                    i in
                                                    sheet_EV.loc[:, x].values])), doc="charging efficency of EV")

m2.DischEffc_EV = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                                     [i for x in sheet_EV.columns if
                                                      "efficiency_of_discharging" in x for i
                                                      in sheet_EV.loc[:, x].values])),
                           doc="Discharging efficency of EV")

m2.Cap_EV = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                               [i for x in sheet_EV.columns if "capacity" in x for i in
                                                sheet_EV.loc[:, x].values])), doc="Capacity of  EV")
m2.End_percentage_EV = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                          [i for x in sheet_EV.columns if "end" in x
                                                           for i in
                                                           sheet_EV.loc[:, x].values])),
                                doc="Departure energy of EV")

m2.In_Percentage_EV = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                         [i for x in sheet_EV.columns if "initial" in x
                                                          for i in
                                                          sheet_EV.loc[:, x].values])),
                               doc="Initial energy of EV")

m2.Energy_EV_dep = py.Param(m2.h, initialize=dict(
    zip(m2.h.data(), np.array(m2.Cap_EV.values()) * m2.End_percentage_EV.values())),  # just changing np>py
                            doc="Departure temperature of EV")

m2.Energy_EV_In = py.Param(m2.h, initialize=dict(
    zip(m2.h.data(), np.array(m2.Cap_EV.values()) * m2.In_Percentage_EV.values())),
                           doc="Initial energy of EV")

# </editor-fold>

# <editor-fold desc="Energy Storage System Parameter">

m2.ChargeRate_ESS = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                                       [i for x in sheet_ESS.columns if "charging_rate" in x for i
                                                        in
                                                        sheet_ESS.loc[:, x].values])), doc="charging rate of ESS")

m2.DischRate_ESS = py.Param(m2.h, initialize=dict(zip(list(itertools.product(m2.h.data())),
                                                      [i for x in sheet_ESS.columns if "rate_of_discharging" in x
                                                       for
                                                       i in
                                                       sheet_ESS.loc[:, x].values])),
                            doc="Discharging rate of ESS")

# m2.ChargeRate_ESS = py.Param(initialize=float(sheet_ESS.charging_rate1), doc='Charging rate of ESS ')
# m2.DischRate_ESS = py.Param(initialize=float(sheet_ESS.discharging_rate1),
#                                doc='Discharging rate of ESS ')
m2.Cap_ESS = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                [i for x in sheet_ESS.columns if "capacity" in x for i in
                                                 sheet_ESS.loc[:, x].values])), doc="Capacity of  ESS")

m2.End_percentage_ESS = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                           [i for x in sheet_ESS.columns if "end" in x
                                                            for i in
                                                            sheet_ESS.loc[:, x].values])),
                                 doc="Departure energy of ESS")

m2.In_Percentage_ESS = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                          [i for x in sheet_ESS.columns if
                                                           "initial" in x for i in
                                                           sheet_ESS.loc[:, x].values])),
                                doc="Initial energy of ESS")

m2.Ch_Effc_ESS = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                    [i for x in sheet_ESS.columns if "charging_efficiency" in x
                                                     for i in
                                                     sheet_ESS.loc[:, x].values])),
                          doc="charging efficiency of ESS")

m2.DischEffc_ESS = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                      [i for x in sheet_ESS.columns if
                                                       "efficiency_of_dicharging" in x for
                                                       i in
                                                       sheet_ESS.loc[:, x].values])),
                            doc="Discharging efficiency of ESS")

m2.Energy_ESS_In = py.Param(m2.h, initialize=dict(
    zip(m2.h.data(), np.array(m2.Cap_ESS.values()) * m2.In_Percentage_ESS.values())),
                            doc="Initial energy of ESS")

m2.End_En_ESS = py.Param(m2.h, initialize=dict(
    zip(m2.h.data(), np.array(m2.Cap_ESS.values()) * m2.End_percentage_ESS.values())),
                         doc="Departure energy of ESS")

# </editor-fold>

# <editor-fold desc="Electric Water Heater Parameter">

m2.tetta_low = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                  [i for x in sheet_EWH.columns if "tetta_low" in x for i in
                                                   sheet_EWH.loc[:, x].values])),
                        doc="Lower bound of the water temperature")
m2.tetta_up = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                 [i for x in sheet_EWH.columns if "tetta_up" in x for i in
                                                  sheet_EWH.loc[:, x].values])),
                       doc="Upper bound of the water temperature")
m2.tetta_amb_int = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                      [i for x in sheet_EWH.columns if "tetta_amb_init" in x for i
                                                       in
                                                       sheet_EWH.loc[:, x].values])),
                            doc="Initial ambient temperature")

m2.tetta_amb = py.Param(m2.h, m2.t,
                        initialize=dict(zip(list(itertools.product(m2.h.data(), m2.t.data())),
                                            [i for x in sheet_ambient.columns if "celsius" in x for i in
                                             sheet_ambient.loc[:, x].values])), doc="Outdoor temperature")

m2.Q = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                          [i for x in sheet_EWH.columns if "capacity" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Power of the EWH")

m2.R = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                          [i for x in sheet_EWH.columns if "thermal_resistance" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Thermal resistance")
m2.C = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                          [i for x in sheet_EWH.columns if "thermal_capacitance" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Thermal resistance")

m2.M = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                          [i for x in sheet_EWH.columns if "water_cap" in x for i in
                                           sheet_EWH.loc[:, x].values])), doc="Water Capacity (L)")

m2.tetta_EWH_int = py.Param(m2.h, initialize=dict(zip((m2.h.data()),
                                                      [i for x in sheet_EWH.columns if "tetta_wat_init" in x for i
                                                       in
                                                       sheet_EWH.loc[:, x].values])), doc="Initial temperature")

m2.water_use = py.Param(m2.h, m2.t,
                        initialize=dict(zip(list(itertools.product(m2.h.data(), m2.t.data())),
                                            [i for x in sheet_wateruse.columns if "Litre" in x for i in
                                             sheet_wateruse.loc[:, x].values])), doc="Hot Water usage")

# </editor-fold2

# <editor-fold desc="Price, Base load, and time duration parameters">
# m2.Buy_price = py.Param(m2.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_RTP)), doc='Buying Price')
# m2.Buy_price = py.Param(m2.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_TOU_winter)), doc='Buying Price')
m2.Buy_price = py.Param(m2.t, initialize=dict(zip(sheet_data.time, sheet_data.TOU_PGE)), doc='Buying Price')
# m2.Buy_price = py.Param(m2.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_flex_D)), doc='Buying Price')
# m2.Buy_price = py.Param(m2.t, initialize=dict(zip(sheet_data.time, sheet_data.Buy_price_fixed)), doc='Buying Price')
m2.Sell_price = py.Param(m2.t, initialize=dict(zip(sheet_data.time, sheet_data.FiT)), doc='Selling Price')
# Time duration: we took 15 mint granularity so in one hour it will be 1/4
m2.time_d = py.Param(initialize=(1 / 4), doc='time duration ')
# m2.DPT = py.Param(initialize=0.069, doc='Daily power tariff ')  # .069
# </editor-fold>

print('Code Starts for HEMS Energy Optimization')
# Variable

# <editor-fold desc="buying and selling variables">
m2.P_Buy_Grid = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_Sell_Grid = py.Var(m2.h, m2.t, bounds=(0, None))
m2.S_P_sell = py.Var(m2.h, m2.t, within=py.Binary)
m2.S_P_buy = py.Var(m2.h, m2.t, within=py.Binary)
m2.peak = py.Var(within=py.NonNegativeReals)
# m2.pflex = py.Var(m2.b, m2.t, doc='active Flexibility')
# m2.qflex = py.Var(m2.b, m2.t,
#                      doc='reactive Flexibility')  # i comment this because i use m2.pflex variable * 0.48
m2.pmax = py.Var(m2.h, m2.t, bounds=(0, None), doc='Maximum power')
m2.pmax_int = py.Var(m2.h, m2.t, bounds=(0, None), doc='Initial Power')

# </editor-fold>

# <editor-fold desc="Electric vehicle Variables">
m2.P_EV_Charge = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_EV_Disch = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_EV_Disch_Home = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_EV_Disch_Grid = py.Var(m2.h, m2.t, bounds=(0, None))
m2.S_EV_Charge = py.Var(m2.h, m2.t, within=py.Binary)
m2.S_EV_Disch = py.Var(m2.h, m2.t, within=py.Binary)
m2.Energy_EV = py.Var(m2.h, m2.t, bounds=(0, None))  # SOC of the EV
# </editor-fold>

# <editor-fold desc="Energy storage system Variables">
m2.Energy_ESS = py.Var(m2.h, m2.t, bounds=(0, None))  # SOC of the ESS
m2.S_ESS_Charge = py.Var(m2.h, m2.t, within=py.Binary)
m2.P_ESS_Disch = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_ESS_Charge = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_ESS_Charge_Grid = py.Var(m2.h, m2.t, bounds=(0, None), doc='ESS charging from the Grid')
m2.P_ESS_Disch_Home = py.Var(m2.h, m2.t, bounds=(0, None))
m2.P_ESS_Disch_Grid = py.Var(m2.h, m2.t, bounds=(0, None))
m2.S_ESS_Disch = py.Var(m2.h, m2.t, within=py.Binary)
# </editor-fold>

# <editor-fold desc="PV variables">
m2.PV_Home = py.Var(m2.h, m2.t, bounds=(0, None))
m2.PV_Grid = py.Var(m2.h, m2.t, bounds=(0, None))
m2.PV_Battery = py.Var(m2.h, m2.t, bounds=(0, None))
# </editor-fold>

# <editor-fold desc="EWH Variables">
m2.tetta_EWH_wat = py.Var(m2.h, m2.t)
m2.S_EWH = py.Var(m2.h, m2.t, within=py.Binary)
m2.P_EWH = py.Var(m2.h, m2.t, doc='power of EWH')


# </editor-fold>
# Constraints


# <editor-fold desc="Buying and Selling Power">
def Power_buy(m2, h, i):
    return m2.P_Buy_Grid[h, i] == m2.base_load[h, i] + m2.Q[h] * m2.S_EWH[h, i] + m2.P_EV_Charge[h, i] - \
        m2.P_EV_Disch_Home[h, i] + m2.P_ESS_Charge[h, i] - \
        m2.P_ESS_Disch_Home[h, i] - m2.PV_Home[h, i] - m2.PV_Battery[h, i]


m2.Const_1 = py.Constraint(m2.h, m2.t, rule=Power_buy, doc='Power buy from the Grid')


def Power_buy2(m2, h, i):
    return m2.P_Buy_Grid[h, i] <= m2.max * m2.S_P_buy[h, i]


m2.Const_1a = py.Constraint(m2.h, m2.t, rule=Power_buy2,
                            doc='removing the nonlinearity in the objective fucntion')


def Power_sell1(m2, h, i):
    return m2.P_Sell_Grid[h, i] == m2.P_EV_Disch_Grid[h, i] + m2.PV_Grid[h, i] + m2.P_ESS_Disch_Grid[h, i]


m2.Const_2 = py.Constraint(m2.h, m2.t, rule=Power_sell1, doc='Power sell to the Grid')


# def Power_sell2(m2, h, i):
#     return m2.P_Sell_Grid[h, i] <= m2.max * m2.S_P_sell[h, i]
#
#
# m2.Const_2a = py.Constraint(m2.h, m2.t, rule=Power_sell2, doc='Power sell to the Grid')
def Power_sell2(m2, h, i):
    return m2.P_Sell_Grid[h, i] <= m2.max.value * (1 - m2.S_P_buy[h, i])


m2.Const_2a = py.Constraint(m2.h, m2.t, rule=Power_sell2, doc='Power sell to the Grid')


# def Status_Power(m2, h, i):
#     return m2.S_P_buy[h, i] + m2.S_P_sell[h, i] <= 1
#
#
# m2.Const_3 = py.Constraint(m2.h, m2.t, rule=Status_Power,
#                            doc='Buying and selling power will not occur at same time')


# </editor-fold>


# <editor-fold desc="Electric vehicle Constraints">
def Power_EV_Charge_limit1(m2, h, i):
    return m2.P_EV_Charge[h, i] <= m2.ChargeRate_EV[h] * m2.S_EV_Charge[h, i]


m2.Const_EV_1 = py.Constraint(m2.h, m2.t, rule=Power_EV_Charge_limit1,
                              doc='Charging power of EV (Upper limit)')


def Power_EV_Charge_limit2(m2, h, i):
    return m2.P_EV_Charge[h, i] >= 0


m2.Const_EV_2 = py.Constraint(m2.h, m2.t, rule=Power_EV_Charge_limit2,
                              doc='Charging power of EV (lower limit)')


def Power_EV_Disch_limit1(m2, h, i):
    return m2.P_EV_Disch[h, i] <= (m2.DischRate_EV[h] * m2.S_EV_Disch[h, i])


m2.Const_EV_3 = py.Constraint(m2.h, m2.t, rule=Power_EV_Disch_limit1,
                              doc='Discharging power of EV (Upper limit)')


def Power_EV_Disch_limit2(m2, h, i):
    return m2.P_EV_Disch[h, i] >= 0


m2.Const_EV_4 = py.Constraint(m2.h, m2.t, rule=Power_EV_Disch_limit2,
                              doc='Discharging power of EV (Lower limit)')


def Status_EV(m2, h, i):
    return m2.S_EV_Disch[h, i] + m2.S_EV_Charge[h, i] <= 1


m2.Const_EV_5 = py.Constraint(m2.h, m2.t, rule=Status_EV,
                              doc='Charging and discharging will not occur at same time')


def Power_EV_Disch(m2, h, i):
    return m2.P_EV_Disch[h, i] * m2.DischEffc_EV[h] == (
        (m2.P_EV_Disch_Home[h, i] + m2.P_EV_Disch_Grid[h, i]))


m2.Const_EV_6 = py.Constraint(m2.h, m2.t, rule=Power_EV_Disch, doc='Discharging power of EV to '
                                                                   'Home and Grid')


def SoC_EV1(m2, h, i):
    return m2.Energy_EV[h, i] == m2.Energy_EV_In[h]


# m2.Const_EV_7a = py.Constraint(m2.h, [m2.alpha.value], rule=SoC_EV1, doc='SoC of the EV at arrival')
m2.Const_EV_7a = py.Constraint([(h, py.value(m2.alpha[h])) for h in m2.h], rule=SoC_EV1, doc='SoC of the EV at arrival')


def SoC_EV2(m2, h, i):
    return m2.Energy_EV[h, i] == m2.Energy_EV[h, i - 1] + (
            m2.P_EV_Charge[h, i] * m2.Ch_Effc_EV[h] - m2.P_EV_Disch[h, i]) * m2.time_d


# m2.Const_EV_7b = py.Constraint(m2.h, m2.EV_Dur1, rule=SoC_EV2, doc='SoC of the EV after arrival time')
m2.Const_EV_7b = py.ConstraintList()
for h in m2.h:
    for i in m2.EV_Dur1[h].value:
        m2.Const_EV_7b.add(SoC_EV2(m2, h, i))


def EV_availability1(m2, h, i):
    return m2.Energy_EV[h, i] == 0


# m2.Const_EV_8a = py.Constraint(m2.h, m2.ist_interval, rule=EV_availability1,
#                                doc='SOC available before arrival time')
m2.Const_EV_8a = py.ConstraintList()
for h in m2.h:
    for i in m2.ist_interval[h].value:
        m2.Const_EV_8a.add(EV_availability1(m2, h, i))


def EV_availability2(m2, h, i):
    return m2.Energy_EV[h, i] == 0


# m2.Const_EV_8b = py.Constraint(m2.h, m2.second_interval, rule=EV_availability2,
#                                doc='SOC available after departure time')
m2.Const_EV_8b = py.ConstraintList()
for h in m2.h:
    for i in m2.second_interval[h].value:
        m2.Const_EV_8b.add(EV_availability2(m2, h, i))


def EV_status_available1(m2, h, i):
    return m2.S_EV_Disch[h, i] + m2.S_EV_Charge[h, i] == 0


# m2.Const_EV_9a = py.Constraint(m2.h, m2.ist_interval, rule=EV_status_available1,
#                                doc='EV availability before arrival time')
m2.Const_EV_9a = py.ConstraintList()
for h in m2.h:
    for i in m2.ist_interval[h].value:
        m2.Const_EV_9a.add(EV_status_available1(m2, h, i))


def EV_status_available2(m2, h, i):
    return m2.S_EV_Disch[h, i] + m2.S_EV_Charge[h, i] == 0


# m2.Const_EV_9b = py.Constraint(m2.h, m2.second_interval, rule=EV_status_available2,
#                                doc='EV availability after arrival time')
m2.Const_EV_9b = py.ConstraintList()
for h in m2.h:
    for i in m2.second_interval[h].value:
        m2.Const_EV_9b.add(EV_status_available2(m2, h, i))


def EV_SoC_limit1(m2, h, i):
    return m2.Energy_EV[h, i] >= 0.2 * m2.Cap_EV[h]


# m2.Const_EV_10 = py.Constraint(m2.h, m2.EV_Dur, rule=EV_SoC_limit1, doc='Minimum SoC of EV')
m2.Const_EV_10 = py.ConstraintList()
for h in m2.h:
    for i in m2.EV_Dur[h].value:
        m2.Const_EV_10.add(EV_SoC_limit1(m2, h, i))


def EV_SoC_limit2(m2, h, i):
    return m2.Energy_EV[h, i] <= m2.Cap_EV[h]


# m2.Const_EV_11 = py.Constraint(m2.h, m2.t, rule=EV_SoC_limit2, doc='Maximum SoC of EV')
m2.Const_EV_11 = py.ConstraintList()
for h in m2.h:
    for i in m2.EV_Dur[h].value:
        m2.Const_EV_11.add(EV_SoC_limit2(m2, h, i))


def EV_final_SoC(m2, h, i):
    return m2.Energy_EV[h, i] == m2.Energy_EV_dep[h]


# m2.Const_EV_12 = py.Constraint(m2.h, [m2.beta.value], rule=EV_final_SoC,
#                                doc='Final SoC of EV at departure time')
m2.Const_EV_12 = py.Constraint([(h, py.value(m2.beta[h])) for h in m2.h], rule=EV_final_SoC,
                               doc='Final SoC of EV at departure time')


# </editor-fold>

# <editor-fold desc="Energy Storage System Constraints">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def SoC_ESS1(m2, h, i):
    return m2.Energy_ESS[h, i] == m2.Energy_ESS_In[h]


m2.Const_ESS_1a = py.Constraint(m2.h, [m2.t_first.value], rule=SoC_ESS1,
                                doc='SoC of ESS')  # need to check wather we need to put in the brackets or not


def SoC_ESS2(m2, h, i):
    return m2.Energy_ESS[h, i] == m2.Energy_ESS[h, i - 1] + (
            m2.P_ESS_Charge[h, i] * m2.Ch_Effc_ESS[h] - m2.P_ESS_Disch[h, i]) * m2.time_d


m2.Const_ESS_1b = py.Constraint(m2.h, m2.t_second, rule=SoC_ESS2, doc='SoC of ESS')


def Power_ESS_Charge(m2, h, i):
    return m2.P_ESS_Charge[h, i] == m2.P_ESS_Charge_Grid[h, i] + m2.PV_Battery[h, i]


m2.Const_ESS_2 = py.Constraint(m2.h, m2.t, rule=Power_ESS_Charge,
                               doc='Charging power of ESS ')


def Power_ESS_Charge_limit1(m2, h, i):
    return (m2.P_ESS_Charge_Grid[h, i] + m2.PV_Battery[h, i]) <= m2.ChargeRate_ESS[h] * m2.S_ESS_Charge[
        h, i]


m2.Const_ESS_2a = py.Constraint(m2.h, m2.t, rule=Power_ESS_Charge_limit1,
                                doc='Charging power of ESS (Upper limit)')


def Power_ESS_Charge_limit2(m2, h, i):
    return (m2.P_ESS_Charge_Grid[h, i] + m2.PV_Battery[h, i]) >= 0


m2.Const_ESS_2b = py.Constraint(m2.h, m2.t, rule=Power_ESS_Charge_limit2,
                                doc='Charging power of ESS (Lower limit)')


def Power_ESS_Disch_limit1(m2, h, i):
    return (m2.P_ESS_Disch_Home[h, i] + m2.P_ESS_Disch_Grid[h, i]) <= (
            m2.DischRate_ESS[h] * m2.S_ESS_Disch[h, i])


m2.Const_ESS_4 = py.Constraint(m2.h, m2.t, rule=Power_ESS_Disch_limit1,
                               doc='Discharging power of ESS (Upper limit)')


def Power_ESS_Disch_limit2(m2, h, i):
    return (m2.P_ESS_Disch_Home[h, i] + m2.P_ESS_Disch_Grid[h, i]) >= 0


m2.Const_ESS_5 = py.Constraint(m2.h, m2.t, rule=Power_ESS_Disch_limit2,
                               doc='Discharging power of ESS (Lower limit)')


def Status_ESS(m2, h, i):
    return m2.S_ESS_Disch[h, i] + m2.S_ESS_Charge[h, i] <= 1


m2.Const_ESS_6 = py.Constraint(m2.h, m2.t, rule=Status_ESS,
                               doc='Charging and discharging will not occur at same time')


def Power_ESS_Disch(m2, h, i):
    return (m2.P_ESS_Disch[h, i]) * m2.DischEffc_ESS[h] == (m2.P_ESS_Disch_Home[h, i] + m2.P_ESS_Disch_Grid[h, i])


m2.Const_ESS_7 = py.Constraint(m2.h, m2.t, rule=Power_ESS_Disch,
                               doc='Discharging power of ESS to Home and Grid')


def ESS_SoC_limit1(m2, h, i):
    return m2.Energy_ESS[h, i] >= 0.1 * m2.Cap_ESS[h]


m2.Const_ESS_8 = py.Constraint(m2.h, m2.t, rule=ESS_SoC_limit1, doc='Minimum SoC of ESS')


def ESS_SoC_limit2(m2, h, i):
    return m2.Energy_ESS[h, i] <= m2.Cap_ESS[h]


m2.Const_ESS_9 = py.Constraint(m2.h, m2.t, rule=ESS_SoC_limit2, doc='Maximum SoC of ESS')


def ESS_final_SoC(m2, h, i):
    return m2.Energy_ESS[h, i] >= m2.End_En_ESS[h]


m2.Const_ESS_10 = py.Constraint(m2.h, [m2.t_final.value], rule=ESS_final_SoC,
                                doc='Final SoC of ESS at departure time')


# </editor-fold>

# <editor-fold desc="Electric Water Heater (EWH) Constraints">
def EWH_limit1(m2, h, i):
    return m2.tetta_EWH_wat[h, i] <= m2.tetta_up[h]


m2.Const_EWH_1 = py.Constraint(m2.h, m2.t, rule=EWH_limit1, doc='Maximum Limit')


def EWH_limit2(m2, h, i):
    return m2.tetta_EWH_wat[h, i] >= m2.tetta_low[h]


m2.Const_EWH_2 = py.Constraint(m2.h, m2.t, rule=EWH_limit2, doc='Minimum Limit')


def EWH_power(m2, h, i):
    return m2.P_EWH[h, i] == m2.Q[h] * m2.S_EWH[h, i]


m2.Const_EWH_3 = py.Constraint(m2.h, m2.t, rule=EWH_power, doc='Electric water heater power')


def EWH_temp_1(m2, h, i):
    return m2.tetta_EWH_wat[h, i] == m2.tetta_amb[h, i] + m2.Q[h] * m2.S_EWH[h, i] * m2.R[
        h] * m2.time_d - (
            (m2.M[h] - m2.water_use[h, i]) / m2.M[h]) * (
            m2.tetta_amb_int[h] - m2.tetta_EWH_int[h]) * py.exp(-m2.time_d / (m2.R[h] * m2.C[h]))


m2.Const_EWH_4 = py.Constraint(m2.h, [m2.t_first.value], rule=EWH_temp_1, doc='EWH m2')


def EWH_temp_2(m2, h, i):
    return m2.tetta_EWH_wat[h, i] == m2.tetta_amb[h, i] + m2.Q[h] * m2.S_EWH[h, i] * m2.R[
        h] * m2.time_d - (
            (m2.M[h] - m2.water_use[h, i]) / m2.M[h]) * (
            m2.tetta_amb[h, i] - m2.tetta_EWH_wat[h, i - 1]) * py.exp(
        -m2.time_d / (m2.R[h] * m2.C[h]))


m2.Const_EWH_5 = py.Constraint(m2.h, m2.t_second, rule=EWH_temp_2, doc='EWH m2')


# </editor-fold>

# <editor-fold desc="PV Constraints"> # need to include the PV equation of omer paper

def PV_production(m2, h, i):
    return m2.PV_Grid[h, i] + m2.PV_Home[h, i] + m2.PV_Battery[h, i] == m2.PV[h, i]


m2.Const_PV = py.Constraint(m2.h, m2.t, rule=PV_production, doc='PV Production')


# </editor-fold>
# <editor-fold desc="objective functions">


def objective_rule(m2):
    return sum(m2.P_Buy_Grid[h, i] for i in m2.t for h in m2.h) * m2.time_d.value


m2.obj2 = py.Objective(rule=objective_rule, sense=py.minimize, doc='Definition of objective function')
# <editor-fold desc="Solver">
m2.write('m22.lp', io_options={'symbolic_solver_labels': True})
opt = py.SolverFactory('gurobi')
opt.options["mipgap"] = 0.8  # 0.155 for load and 0.8 for other load
result = opt.solve(m2, tee=True)  # report_timing=True

print(result)
# print('Sum of all homes objectives = ', py.value(m2.obj2))
# for h in m2.h:
#     print(f"Objective of Home {h} : " f"{(sum(m2.P_Buy_Grid[h, i].value for i in m2.t) * m2.time_d.value)}")
# print("second objective Done ")


# </editor-fold>
# # <editor-fold desc="Ploting">

#
# # # <editor-fold desc="Ploting">
# #
# # # Plotting for automatic ploting
time = [i for i in m2.t]
pl2_pbuy = [[] for j in m2.h]
# pl2_psell = [[] for j in m2.h]
PEVCharge2 = [[] for j in m2.h]
PESSChargeGrid2 = [[] for j in m2.h]
PEVDischHome2 = [[] for j in m2.h]
PESSDischHome2 = [[] for j in m2.h]
# # # SEVCharge = [[] for j in m2.h]
# # # SEVDisch = [[] for j in m2.h]
PEVDischGrid2 = [[] for j in m2.h]
PESSDischGrid2 = [[] for j in m2.h]
PVHome2 = [[] for j in m2.h]
PVGrid2 = [[] for j in m2.h]
PVBattery2 = [[] for j in m2.h]
# # # PPV = [[] for j in m2.h]
baseload2 = [[] for j in m2.h]
# # # EnergyESS = [[] for j in m2.h]
# # # EnergyEV = [[] for j in m2.h]
# # # tettaEWHwat = [[] for j in m2.h]
# # # SEWH = [[] for j in m2.h]
PEWH2 = [[] for j in m2.h]
# # # Buyprice = []  # cost = [i for i in m2.c.values()]  <<< check this
# # # Sellprice = []
# # #

for j in m2.h:
    for k, v in m2.P_Buy_Grid.items():
        if k[0] == j:
            pl2_pbuy[j - 1].append(py.value(v))
# for j in m2.h:
#     for k, v in m2.P_Sell_Grid.items():
#         if k[0] == j:
#             pl2_psell[j - 1].append(py.value(v))
# # #
for j in m2.h:
    for k, v in m2.P_EV_Charge.items():
        if k[0] == j:
            PEVCharge2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.P_EV_Disch_Home.items():
        if k[0] == j:
            PEVDischHome2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.P_EV_Disch_Grid.items():
        if k[0] == j:
            PEVDischGrid2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.P_ESS_Charge_Grid.items():
        if k[0] == j:
            PESSChargeGrid2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.P_ESS_Disch_Home.items():
        if k[0] == j:
            PESSDischHome2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.P_ESS_Disch_Grid.items():
        if k[0] == j:
            PESSDischGrid2[j - 1].append(py.value(v))
# # #
for j in m2.h:
    for k, v in m2.PV_Home.items():
        if k[0] == j:
            PVHome2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.PV_Grid.items():
        if k[0] == j:
            PVGrid2[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.PV_Battery.items():
        if k[0] == j:
            PVBattery2[j - 1].append(py.value(v))
# # # for j in m2.h:
# # #     for k, v in m2.PV.items():
# # #         if k[0] == j:
# # #             PPV[j - 1].append(py.value(v))
# # #
for j in m2.h:
    for k, v in m2.base_load.items():
        if k[0] == j:
            baseload2[j - 1].append(py.value(v))
# # #
# # # for j in m2.h:
# # #     for k, v in m2.Energy_ESS.items():
# # #         if k[0] == j:
# # #             EnergyESS[j - 1].append(py.value(v))
# # # for j in m2.h:
# # #     for k, v in m2.Energy_EV.items():
# # #         if k[0] == j:
# # #             EnergyEV[j - 1].append(py.value(v))
for j in m2.h:
    for k, v in m2.P_EWH.items():
        if k[0] == j:
            PEWH2[j - 1].append(py.value(v))
# # # for j in m2.h:
# # #     for k, v in m2.tetta_EWH_wat.items():
# # #         if k[0] == j:
# # #             tettaEWHwat[j - 1].append(py.value(v))
# # #
# # # for j in m2.h:
# # #     for k, v in m2.S_EWH.items():
# # #         if k[0] == j:
# # #             SEWH[j - 1].append(py.value(v))
# # #

# # #
# # # # alone
# # for k in range(len(m2.h)):
# #     fig, ax = plt.subplots(5, 2, figsize=(10, 10))
# #     ax[0, 0].bar(time, pl2_pbuy[k], label='Buying power-obj2')
# #     ax[0, 0].bar(time, pl1_pbuy[k], label='Buying power-obj1')
# #     ax[1, 0].bar(time, pl2_psell[k], label='Selling power-obj2')
# #     ax[1, 0].bar(time, pl1_psell[k], label='Selling power-obj1')
# #     ax[0, 0].legend(loc='best', fontsize='small', ncol=3)
# #     ax[1, 0].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[0, 1].bar(time, baseload[k], label='Base load', color='r')
# # # #     ax[0, 1].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[0, 2].plot(time, Buyprice, label='Buyprice')
# # # #     ax[0, 2].plot(time, Sellprice, label='Sellprice')
# # # #     ax[0, 2].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[1, 0].bar(time, PEWH[k], label='EWH Power', color='r')
# # # #     ax[1, 0].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[1, 1].plot(time, tettaEWHwat[k], label='EWH Temp')
# # # #     ax[1, 1].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[1, 2].bar(time, SEWH[k], label='Status of EWH')
# # # #     ax[1, 2].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[2, 0].bar(time, PESSChargeGrid[k], label='ESS Charging from Grid', color='r')
# # # #     ax[2, 0].bar(time, PVBattery[k], label='ESS Charging from PV', color='g')
# # # #     ax[2, 0].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[2, 1].bar(time, PESSDischHome[k], label='ESS Disch to home')
# # # #     ax[2, 1].bar(time, PESSDischGrid[k], label='ESS Disch to grid')
# # # #     ax[2, 1].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[2, 2].plot(time, EnergyESS[k], label='Energy of ESS', color='g')
# # # #     ax[2, 2].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[3, 0].bar(time, PVHome[k], label='PV to Home')
# # # #     ax[3, 0].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[3, 1].bar(time, PVGrid[k], label='PV to Grid')
# # # #     ax[3, 1].bar(time, PVBattery[k], label='PV to battery')
# # # #     ax[3, 1].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[3, 2].bar(time, PVHome[k], label='PV to Home')
# # # #     ax[3, 2].bar(time, PVGrid[k], label='PV to Grid')
# # # #     ax[3, 2].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[4, 0].bar(time, PEVCharge[k], label='EV Charging power', color='r')
# # # #     ax[4, 0].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[4, 1].bar(time, PEVDischHome[k], label='EV Disch to home')
# # # #     ax[4, 1].bar(time, PEVDischGrid[k], label='EV Disch to grid')
# # # #     ax[4, 1].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[4, 2].plot(time, EnergyEV[k], label='Energy of EV', color='r')
# # # #     ax[4, 2].legend(loc='best', fontsize='small', ncol=3)
# # # #     ax[4, 0].set_xlabel('Time (step)')
# # # #     ax[4, 1].set_xlabel('Time (step)')
# # # #     ax[4, 2].set_xlabel('Time (step)')
# # # #     ax[0, 2].set_ylabel('price ($/W/h)')
# # # #     ax[0, 0].set_ylabel('Power1 (kW)')
# # # #     ax[1, 0].set_ylabel('Power (kW)')
# # # #     ax[2, 0].set_ylabel('Power (kW)')
# # # #     ax[3, 0].set_ylabel('Power (kW)')
# # # #     ax[4, 0].set_ylabel('Power (kW)')
# # # #     ax[2, 2].set_ylabel('Energy (kWh)')
# # # #     ax[4, 2].set_ylabel('Energy (kWh)')
# #     plt.suptitle(
# #         f" Home {k + 1} : " f" Cost is :  {py.value((sum(m2.P_Buy_Grid[k + 1, i]  for i in m2.t) * m2.time_d))}")
# #     pl.tight_layout()
# #     plt.show()
# # #
# # # # code for if you want to plot all the home togathoer
# fig, ax = plt.subplots(4, len(m2.h), figsize=(10, 10), constrained_layout=True, sharex='col', sharey='row')
# gs = fig.add_gridspec(hspace=0, wspace=0)
# for k in range(len(m2.h)):
#     ax[0, k].bar(time, pl1_pbuy[k], color='green')
#     ax[1, k].bar(time, pl2_pbuy[k], color='blue')
#     ax[2, k].bar(time, pl1_psell[k], color='green')
#     ax[3, k].bar(time, pl2_psell[k], label='blue')
#     # ax[0, k].legend(loc='best')
#     # ax[1, k].legend(loc='best')
#     # ax[2, k].legend(loc='best')
#     # ax[3, k].legend(loc='best')
#     # #     ax[0, k].plot(time, baseload[k], label='Base load')
#     #     # #     ax[1, k].plot(time, Buyprice,  label='Buyprice')
#     # #     ax[1, k].legend(loc='best')
#     #     # #     ax[1, k].plot(time, Sellprice, label='Sellprice')
#     #     # #     ax[1, k].legend(loc='best')
#     #     # #     ax[2, k].plot(time, PEWH[k], label='EWH Power')
#     #     # #     ax[2, k].plot(time, tettaEWHwat[k], label='EWH Temp')
#     #     # #     ax[2, k].legend(loc='best')
#     #     # #     ax[3, k].plot(time, PESSCharge[k],label='ESS Charging power')
#     #     # #     ax[3, k].plot(time, PESSDischHome[k], label='ESS Disch to home')
#     #     # #     ax[3, k].plot(time, PESSDischGrid[k], label='ESS Disch to grid')
#     #     # #     ax[3, k].legend(loc='best')
#     #     # #     ax[4, k].plot(time, PVHome[k], label='PV to Home')
#     #     # #     ax[4, k].plot(time, PVGrid[k], label='PV to Grid')
#     #     # #     ax[4, k].plot(time, PPV[k], label='All PV Production')
#     #     # #     ax[4, k].legend(loc='best')
#     #     # #     ax[5, k].plot(time, PEVCharge[k], label='EV Charging power')
#     #     # #     ax[5, k].plot(time, PEVDischHome[k], label='EV Disch to home')
#     #     # #     ax[5, k].plot(time, PEVDischGrid[k], label='EV Disch to grid')
#     #     # #     ax[5, k].legend(loc='best')
#     #     # #     ax[6, k].plot(time, EnergyESS[k], label='Energy of ESS')
#     #     # #     ax[6, k].legend(loc='best')
#     #     # #     ax[7, k].plot(time, EnergyEV[k], label='Energy of EV')
#     #     # #     ax[7, k].legend(loc='best')
#     #     # #     ax[4, k].set_xlabel('Time (step)')
#     #     # #     ax[1, k].set_ylabel('Electricity price ($/W/h)')
#     ax[0, 0].set_ylabel(
#         'Buy-Power1 (kW)')  # showing only on the side of the graph if you want to put it on all need to use [0,k]
#     ax[1, 0].set_ylabel('Buy-Power2 (kW)')
#     ax[2, 0].set_ylabel('Sell-Power1 (kW)')
#     ax[3, 0].set_ylabel('Sell-Power2 (kW)')
#
#     ax[0, k].set_title(f"Home {k + 1}", fontsize='xx-small')
#     fig.suptitle('Cost and Energy minimization', fontsize=16)
#
# plt.show()
# #
# # # if you want to plot each home alone in the figure
# # # for k in range(len(m2.h)):
# # #     fig, ax = plt.subplots(2)
# # #     ax[0].plot(time, pbuy[k], 'b-', label='Base')
# # #     ax[0].plot(time, psell[k], 'g--', label='Controllable Load')
# # #     ax[1].plot(time, Buyprice, label='buying price')
# # #     ax[1].plot(time, Sellprice, 'y-+', label='selling price')
# # #     ax[1].legend(loc='upper left')
# # #     ax[1].set_xlabel('Time (hour)')
# # #     ax[1].set_ylabel('Electricity price ($/W/h)')
# # #     plt.suptitle(f"Home {k+1}")
# # #     pl.tight_layout()
# # #     plt.show()
# #
# # print('this is the end of code')
# # </editor-fold>
#
# # </editor-fold>
# </editor-fold>

# </editor-fold>


# Plot stacked bar chart
# fig11, ax = plt.subplots()
# labels = ('EV_Charging', 'EWH', 'Baseload', 'ESS_Charging')
# data_list = [PEVCharge2[1], PEWH2[1], baseload2[1], PESSChargeGrid2[1]]
# bottom = np.zeros(len(time))
# for label, data in zip(labels, data_list):
#     ax.bar(time, data, bottom=bottom, label=label)
#     bottom += data
# # Set plot labels and title
# ax.set_ylabel('Power (kW)')
# ax.set_xlabel('Time Step')
# ax.set_title('House Appliances (HEMS)_Energy Min')
# ax.legend(loc='upper left')
#
# # Show plot
# plt.show()
#
#
# fig111_en, ax = plt.subplots()
# labels_en = ('EV-Discharging_Grid','EV-Discharging_Home', 'PV_Grid', 'PV_Home','PV_Battery','ESS-Discharging_Grid','ESS-Discharging_Home')
# data_list_en = [PEVDischGrid[1],PEVDischHome[1], PVGrid[1],PVHome[1],PVBattery[1], PESSDischGrid[1],PESSDischHome[1]]
# bottom_en = np.zeros(len(time))
# for label_en, data_en in zip(labels_en, data_list_en):
#     ax.bar(time, data_en, bottom=bottom_en, label=label_en)
#     bottom2+= data_en
# # Set plot labels and title
# ax.set_ylabel('Power (kW)')
# ax.set_xlabel('Time Step')
# ax.set_title('Power of House Appliances export to Home/Grid (HEMS)-Energ Min')
# ax.legend(loc='upper left')
#
# # Show plot
# plt.show()

writer = pd.ExcelWriter('Result_HEMS.xlsx', engine='xlsxwriter')
time_excel = pd.DataFrame({'Time_Step': time})
time_excel.to_excel(writer, sheet_name='Power', startcol=0, index=False, header=True)
for h in range(len(m1.h)):
    pload_excel = pd.DataFrame({f"Power_Demand {h + 1}": pl1_pbuy[h]})
    pload_excel.to_excel(writer, sheet_name='Power', startcol=h + 1, index=False, header=True)

    pload_excel = pd.DataFrame({f"Power_Sell {h + 1}": pl1_psell[h]})
    pload_excel.to_excel(writer, sheet_name='Power', startcol=h + 4, index=False, header=True)
writer.save()