def update_CP_state(CP_name, dt_sim_time):
#Check if EV is there
CP_obj = gridlabd.get_object(CP_name)
EV_name = 'EV_' + CP_name.split('_')[-1]
EV_obj = gridlabd.get_object(EV_name)
#New car arrived
#import pdb; pdb.set_trace()
#print(int(CP_obj['EV_connected']))
if int(
CP_obj['EV_connected']
) == 1: #This should be whatever signal which pushes the new that a car arrived/disconnected
#import pdb; pdb.set_trace()
Kev = float(EV_obj['Kev'])
tdep = pandas.to_datetime(EV_obj['tdep'])
Emax = float(EV_obj['battery_capacity'])
DeltaE = float(EV_obj['DeltaE'])
#Write to database
parameter_string = '(timedate, Kev, tdep, Emax, DeltaE)'
value_tuple = (
str(dt_sim_time),
str(Kev),
str(tdep),
Emax,
DeltaE,
)
myfct.set_values(EV_name + '_state_in', parameter_string, value_tuple)
#Reset action pointer
gridlabd.set_value(CP_name, 'EV_connected', str(0))
elif int(CP_obj['EV_connected']) == -1:
gridlabd.set_value(CP_name, 'EV_connected', str(0))
def get_houseobjects(house_name, time):
#Get information from physical representation
house_obj = gridlabd.get_object(house_name) #GUSTAVO: API implementation
#Switch off default control
gridlabd.set_value(house_name, 'thermostat_control', 'NONE')
gridlabd.set_value(house_name, 'system_mode', 'OFF')
#Read out settings
k = float(house_obj['k'])
T_max = float(house_obj['T_max'])
cooling_setpoint = float(house_obj['cooling_setpoint'])
cooling_demand = float(
house_obj['cooling_demand']) #cooling_demand is in kW
T_min = float(house_obj['T_min'])
heating_setpoint = float(house_obj['heating_setpoint'])
heating_demand = float(
house_obj['heating_demand']) #heating_demand is in kW
#Save in long-term memory (in the db) - accessible for market code
parameter_string = '(timedate, k, T_min, heating_setpoint, T_max, cooling_setpoint)' #timedate TIMESTAMP PRIMARY KEY,
value_tuple = (
time,
k,
T_min,
heating_setpoint,
T_max,
cooling_setpoint,
)
myfct.set_values(house_name + '_settings', parameter_string, value_tuple)
return
def dispatch(self, dt_sim_time, p_lem, alpha):
#import pdb; pdb.set_trace()
inverter = 'Bat_inverter_' + self.name.split('_')[-1]
if (self.Q_buy_bid > 0.0) and (self.P_buy_bid > p_lem):
gridlabd.set_value(inverter, 'P_Out', str(-self.Q_buy_bid * 1000.))
elif (self.Q_buy_bid > 0.0) and (self.P_buy_bid == p_lem):
print('This HVAC is marginal; no partial implementation yet: ' +
str(alpha))
gridlabd.set_value(inverter, 'P_Out', str(-self.Q_buy_bid * 1000.))
elif (self.Q_sell_bid > 0.0) and (self.P_sell_bid < p_lem):
gridlabd.set_value(inverter, 'P_Out', str(self.Q_sell_bid * 1000.))
elif (self.Q_sell_bid > 0.0) and (self.P_sell_bid == p_lem):
print('This HVAC is marginal; no partial implementation yet: ' +
str(alpha))
gridlabd.set_value(inverter, 'P_Out', str(self.Q_sell_bid * 1000.))
else:
gridlabd.set_value(inverter, 'P_Out', str(0.0))
myfct.set_values(
self.name + '_state_out',
'(timedate, p_demand, p_supply, q_demand, q_supply)',
(dt_sim_time, str(self.P_buy_bid), str(
self.P_sell_bid), str(self.Q_buy_bid), str(self.Q_sell_bid)))
self.P_sell_bid = 100000.0
self.P_buy_bid = -100000.0
self.Q_sell_bid = 0.0
self.Q_buy_bid = 0.0
def set_HVAC_GLD(dt_sim_time,df_house_state,df_awarded_bids):
for ind in df_house_state.index:
house = df_house_state['house_name'].loc[ind]
if df_house_state['active'].loc[ind] == 1:
system_mode = df_house_state['system_mode'].loc[ind]
gridlabd.set_value(house,'system_mode',system_mode) #Cool or heat
p_bid = df_house_state['bid_p'].loc[ind]
q_bid = df_house_state['bid_q'].loc[ind]
#mysql_functions.set_values('awarded_bids','(appliance_name,p_bid,q_bid,timedate)',(house,float(p_bid),float(q_bid),dt_sim_time))
df_awarded_bids = df_awarded_bids.append(pandas.DataFrame(columns=df_awarded_bids.columns,data=[[dt_sim_time,house,float(p_bid),float(q_bid),'D']]),ignore_index=True)
else:
system_mode = 'OFF'
gridlabd.set_value(house,'system_mode',system_mode)
return df_house_state,df_awarded_bids
def set_HVAC_GLD(dt_sim_time, df_house_state, df_awarded_bids):
for ind in df_house_state.index:
house = df_house_state['house_name'].loc[ind]
#Switch on/off control for gas
if (df_house_state['system_mode'].loc[ind]
== 'HEAT') and (df_house_state['heating_system'].loc[ind]
== 'GAS'):
thermostat_control = 'FULL'
gridlabd.set_value(house, 'thermostat_control', thermostat_control)
elif (df_house_state['system_mode'].loc[ind]
== 'COOL') and (df_house_state['heating_system'].loc[ind]
== 'GAS'):
thermostat_control = 'NONE'
gridlabd.set_value(house, 'thermostat_control', thermostat_control)
#Set system_mode for active systems
if df_house_state['active'].loc[ind] == 1:
#import pdb; pdb.set_trace()
system_mode = df_house_state['system_mode'].loc[ind]
gridlabd.set_value(house, 'system_mode',
system_mode) #Cool or heat
p_bid = df_house_state['bid_p'].loc[ind]
q_bid = df_house_state['bid_q'].loc[ind]
#mysql_functions.set_values('awarded_bids','(appliance_name,p_bid,q_bid,timedate)',(house,float(p_bid),float(q_bid),dt_sim_time))
df_awarded_bids = df_awarded_bids.append(pandas.DataFrame(
columns=df_awarded_bids.columns,
data=[[dt_sim_time, house,
float(p_bid),
float(q_bid), 'D']]),
ignore_index=True)
elif not ((df_house_state['system_mode'].loc[ind] == 'HEAT') and
(df_house_state['heating_system'].loc[ind] == 'GAS')):
#import pdb; pdb.set_trace()
system_mode = 'OFF'
gridlabd.set_value(house, 'system_mode', system_mode)
return df_house_state, df_awarded_bids
def charge_EV(dt_sim_time, df_EV_state):
df_EV_state_red = df_EV_state.loc[df_EV_state['connected'] == 1]
df_EV_state_red = df_EV_state_red.loc[df_EV_state_red['u_t'] > 0.0]
for EV in df_EV_state_red.index:
EV_number = int(EV.split('_')[-1]) #int(battery.split('_')[1])
SOC = df_EV_state['SOC_t'].loc[
EV] #this is SOC at the beginning of the period t
u = -1000 * df_EV_state['u_t'].loc[EV]
gridlabd.set_value('EV_inverter_' + EV[3:], 'P_Out', str(u)) #kW -> W
print('GLD battery model is not used for EV, manual updating!')
df_EV_state['SOC_t'] = df_EV_state[
'SOC_t'] + df_EV_state['connected'] * df_EV_state['u_t'] / 12.
df_EV_state['soc_t'] = df_EV_state['SOC_t'] / df_EV_state['SOC_max']
return df_EV_state
def initialize_EVs(house_name, time):
#Check if EV is connected
EV_name = 'EV' + house_name[5:]
try:
EV_obj = gridlabd.get_object(EV_name)
status = True
except:
status = False
if status:
parameter_string = '(timedate, Kev, tdep, Emax, DeltaE)'
try:
Kev = float(EV_obj['Kev'])
except:
Kev = 1.0
try:
tdep = pandas.to_datetime(EV_obj['tdep'])
except:
#Assuming that departure is in the morning
t0 = pandas.to_datetime(time)
t0.hours = 0
tdep = t0 + pandas.Timedelta(hours=0) + pandas.Timedelta(
minutes=random.randint(0, 60 * 1))
gridlabd.set_value(EV_name, 'tdep', str(tdep))
try:
Emax = float(EV_obj['battery_capacity'])
except:
Emax = 1000.0 #Set very large
try:
DeltaE = float(EV_obj['DeltaE'])
except:
DeltaE = 100.0 #100% / full charge
if DeltaE == 0.0:
DeltaE = 100.0
value_tuple = (
time,
str(Kev),
str(tdep),
Emax,
DeltaE,
)
myfct.set_values(EV_name + '_state_in', parameter_string, value_tuple)
def set_battery_GLD(dt_sim_time,df_bids_battery,df_awarded_bids):
#Check efficiencies!!!
#Set charging/discharging
#Change from no to battery_name
#Do more quickly by setting database through Gridlabd?
for battery in df_bids_battery.index:
batt_number = int(battery.split('_')[-1]) #int(battery.split('_')[1])
SOC = df_bids_battery['SOC_t'].loc[battery] #this is SOC at the beginning of the period t
active = df_bids_battery['active_t'].loc[battery] #this is activity in t
if active == 1:
q_bid = df_bids_battery['q_buy'].loc[battery]
p_bid = df_bids_battery['p_buy'].loc[battery]
gridlabd.set_value('Bat_inverter_'+battery[8:],'P_Out',str(-1000*q_bid)) #kW -> W
#mysql_functions.set_values('awarded_bids','(appliance_name,p_bid,q_bid,timedate)',(battery,float(p_bid),-float(q_bid)/1000,dt_sim_time))
df_awarded_bids = df_awarded_bids.append(pandas.DataFrame(columns=df_awarded_bids.columns,data=[[dt_sim_time,battery,float(p_bid),float(q_bid),'D']]),ignore_index=True)
elif active == -1:
q_bid = df_bids_battery['q_sell'].loc[battery]
p_bid = df_bids_battery['p_sell'].loc[battery]
gridlabd.set_value('Bat_inverter_'+battery[8:],'P_Out',str(1000*q_bid)) #kW -> W
#Include sales as negative
#mysql_functions.set_values('awarded_bids','(appliance_name,p_bid,q_bid,timedate)',(battery,float(p_bid),-float(q_bid)/1000,dt_sim_time))
df_awarded_bids = df_awarded_bids.append(pandas.DataFrame(columns=df_awarded_bids.columns,data=[[dt_sim_time,battery,float(p_bid),float(q_bid),'S']]),ignore_index=True)
else:
gridlabd.set_value('Bat_inverter_'+battery[8:],'P_Out','0.0')
return df_bids_battery, df_awarded_bids
def set_PV_GLD(dt_sim_time, df_PV_state, df_awarded_bids, partial, alpha):
#import pdb; pdb.set_trace()
for ind in df_PV_state.index:
PV = df_PV_state['PV_name'].loc[ind]
# if inverter has not been and is not switched off, only save bid and NO interaction with GLD
if (df_PV_state['inv_ON_t'].loc[ind]
== 1.) and (df_PV_state['inv_ON_t-1'].loc[ind] == 1.):
# Keep inverter unchanged:
pass
elif (df_PV_state['inv_ON_t'].loc[ind] >
0.0) and (df_PV_state['inv_ON_t-1'].loc[ind] < 1.):
gridlabd.set_value(df_PV_state['inverter_name'].loc[ind],
'generator_status', 'ONLINE')
gridlabd.set_value(df_PV_state['inverter_name'].loc[ind], 'P_Out',
str(df_PV_state['inv_ON_t'].loc[ind] *
df_PV_state['q_sell'].loc[ind])
) #Switch on inverter at 1.0 or alpha
# if inverter is to be switched off
elif (df_PV_state['inv_ON_t'].loc[ind] == 0.0):
#gridlabd.set_value(df_PV_state['inverter_name'].loc[ind],'P_Out','0.0') #Switch inverter (partially) off
gridlabd.set_value(df_PV_state['inverter_name'].loc[ind],
'generator_status',
'OFFLINE') #Switch inverter (partially) off
else:
print('Should not happen unless for the first iteration')
return df_PV_state, df_awarded_bids
def dispatch(self, dt_sim_time, p_lem, alpha):
inverter = self.name
if (self.Q_bid > 0.0) and (self.P_bid > p_lem):
gridlabd.set_value(inverter, 'P_Out', str(-self.Q_bid * 1000.))
mode = 1.
elif (self.Q_bid > 0.0) and (self.P_bid == p_lem):
print('This HVAC is marginal; no partial implementation yet: ' +
str(alpha))
gridlabd.set_value(inverter, 'P_Out', str(-self.Q_bid * 1000.))
mode = 1.
else:
gridlabd.set_value(inverter, 'P_Out', str(0.0))
mode = 0.
parameter_string = '(timedate, P_bid, Q_bid, mode, DeltaE)' #DeltaE at beginning of period
value_tuple = (
dt_sim_time,
float(self.P_bid),
float(self.Q_bid),
float(mode),
float(self.DeltaE),
)
myfct.set_values('EV_' + self.ID + '_state_out', parameter_string,
value_tuple)
self.P_bid = -100000.0
self.Q_bid = 0.0
return
def set_EV_GLD(dt_sim_time, df_bids_EV, df_awarded_bids):
#Set charging/discharging
#Change from no to battery_name
#Do more quickly by setting database through Gridlabd?
for EV in df_bids_EV.index:
EV_number = int(EV.split('_')[-1]) #int(battery.split('_')[1])
#print df_bids_EV[['connected','SOC','active','next_event']].loc[df_bids_EV['appliance_id'] == EV_number]
#print type(df_bids_EV['next_event'].loc[df_bids_EV['appliance_id'] == EV_number].values[0])
#print pd.isnull(df_bids_EV['next_event'].loc[df_bids_EV['appliance_id'] == EV_number].values[0])
SOC = df_bids_EV['SOC_t'].loc[
EV] #this is SOC at the beginning of the period t
active = df_bids_EV['active_t'].loc[EV] #this is activity in t
connected = df_bids_EV['connected'].loc[EV]
if active == 1:
q_bid = -1000 * df_bids_EV['q_buy'].loc[EV]
p_bid = df_bids_EV['p_buy'].loc[EV]
gridlabd.set_value('EV_inverter_' + EV[3:], 'P_Out',
str(q_bid)) #kW -> W
#mysql_functions.set_values('awarded_bids','(appliance_name,p_bid,q_bid,timedate)',(EV,float(p_bid),-float(q_bid)/1000,dt_sim_time))
df_awarded_bids = df_awarded_bids.append(pandas.DataFrame(
columns=df_awarded_bids.columns,
data=[[
dt_sim_time, EV,
float(p_bid), -float(q_bid) / 1000, 'D'
]]),
ignore_index=True)
#elif active == -1:
# gridlabd_functions.set('EV_inverter_'+EV[3:],'P_Out',1000*df_bids_EV['q_sell'].loc[df_bids_EV['appliance_id'] == batt_number].values[0]) #kW -> W
else:
gridlabd.set_value('EV_inverter_' + EV[3:], 'P_Out', '0.0')
print('GLD battery model is not used for EV, manual updating!')
df_bids_EV['SOC_t'] = df_bids_EV[
'SOC_t'] + df_bids_EV['active_t'] * df_bids_EV['q_buy'] / 12
df_bids_EV['soc_t'] = df_bids_EV['SOC_t'] / df_bids_EV['SOC_max']
return df_bids_EV, df_awarded_bids
def get_settings_EVs_rnd(EVlist, interval, mysql=False):
cols_EV = [
'EV_name', 'house_name', 'SOC_max', 'i_max', 'v_max', 'u_max',
'efficiency', 'charging_type', 'k', 'soc_t', 'SOC_t', 'connected',
'next_event', 'active_t-1', 'active_t'
]
df_EV = pandas.DataFrame(columns=cols_EV)
start_time = dt_sim_time = parser.parse(
gridlabd.get_global('clock')).replace(tzinfo=None)
for EV in EVlist:
house_name = 'GLD_' + EV[3:]
EV_obj = gridlabd.get_object(EV)
#Determine some values
v_max = float(EV_obj['V_Max']) #keep v_max constant for now
SOC_max = np.random.choice(list_SOC) #in kWh
gridlabd.set_value(EV, 'battery_capacity', str(SOC_max * 1000))
u_max = np.random.choice(list_u) #in kW
i_max = 1000 * u_max / v_max
gridlabd.set_value(EV, 'I_Max', str(i_max))
eff = float(EV_obj['base_efficiency'])
charging_type = EV_obj['charging_type']
k = float(EV_obj['k']) #no market: always highest wllingsness to pay
#Randomly generate SOC at midnight
soc_t = np.random.uniform(0.2, 0.8) #relative soc
soc_t = soc_t + (
1. - soc_t
) / 2. #No EV connected yet - at midnight, initialize with 50% charged already
gridlabd.set_value(EV, 'state_of_charge', str(soc_t))
SOC_t = soc_t * SOC_max
connected = 1
gridlabd.set_value(EV, 'generator_status', 'ONLINE')
next_event = start_time + pandas.Timedelta(
hours=np.random.choice(dep_hours),
minutes=np.random.choice(range(60))) #Next event: disconnection
#Save
df_EV = df_EV.append(pandas.Series([
EV, house_name, SOC_max, i_max, v_max, u_max, eff, charging_type,
k, soc_t, SOC_t, connected, next_event, 0, 0
],
index=cols_EV),
ignore_index=True)
df_EV.set_index('EV_name', inplace=True)
#Maybe drop all columns which are not used in this glm
#import pdb; pdb.set_trace()
return df_EV
def dispatch_PV(PV, dt_sim_time):
#import pdb; pdb.set_trace()
#Should refer to DB and not to python object
if PV.mode == 1:
# No constraint
gridlabd.set_value('PV_' + str(PV.id), 'P_Out',
str(PV.Q_bid)) #What if larger?
elif PV.mode > 0:
gridlabd.set_value('PV_' + str(PV.id), 'P_Out',
str(PV.Q_bid * PV.mode))
else:
gridlabd.set_value('PV_' + str(PV.id), 'P_Out', '0.0')
def compute_bill(gridlabd, **kwargs):
global csvwriter
verbose = gridlabd.get_global("verbose") == "TRUE"
global csvfile
# get data
classname = kwargs['classname']
id = kwargs['id']
data = kwargs['data']
bill_name = f"{classname}:{id}"
bill = gridlabd.get_object(bill_name)
bill_name = bill["name"]
baseline = to_float(bill["baseline_demand"])
tariff = gridlabd.get_object(bill["tariff"])
meter = gridlabd.get_object(bill["meter"])
energy = to_float(meter["measured_real_energy"]) / 1000 # units in kW
# get duration
clock = to_datetime(gridlabd.get_global('clock'), '%Y-%m-%d %H:%M:%S %Z')
if not "lastreading" in data.keys():
duration = timedelta(0)
else:
duration = clock - data["lastreading"]
data["lastreading"] = clock
billing_days = (duration.total_seconds() / 86400) # seconds in a day
# compute energy usage
if not "lastenergy" in data.keys():
usage = 0.0
else:
usage = energy - data["lastenergy"]
data["lastenergy"] = energy
# calculate bill
tariff_name = tariff["name"]
meter_name = meter["name"]
if verbose:
gridlabd.output(
f"Bill '{bill_name}' for meter '{meter_name}' on tariff '{tariff_name}' at time '{clock}':"
)
gridlabd.output(f" Billing days..... %5.0f days" % (billing_days))
gridlabd.output(f" Meter reading.... %7.1f kWh" % (energy))
if baseline == 0.0:
if verbose:
gridlabd.output(f" Energy usage..... %7.1f kWh" % (usage))
charges = usage * to_float(tariff["energy_charge_base"])
else:
tier1 = min(usage, baseline * billing_days)
tier2 = min(usage - tier1, baseline * billing_days * 4)
tier3 = usage - tier1 - tier2
if verbose:
gridlabd.output(f" Tier 1 usage..... %7.1f kWh" % (tier1))
if tier2 > 0:
gridlabd.output(f" Tier 2 usage..... %7.1f kWh" % (tier2))
if tier3 > 0:
gridlabd.output(f" Tier 3 usage..... %7.1f kWh" % (tier3))
charges = tier1 * to_float(
tariff["energy_charge_base"]) + tier2 * to_float(
tariff["energy_charge_100"]) + tier3 * to_float(
tariff["energy_charge_400"])
# apply discount, if any
discount = to_float(tariff["discount"])
if discount > 0:
charges -= usage * discount
# apply daily minimum
minimum = to_float(tariff["minimum_daily_charge"])
if charges < minimum * billing_days:
charges = minimum * billing_days
if verbose:
gridlabd.output(f" Energy charges... %8.2f US$" % (charges))
# output billing record only if charges are non-zero
if charges > 0:
csvwriter.writerow([
clock.strftime('%Y-%m-%d'), meter_name, tariff_name,
int(billing_days),
round(usage, 1), 0,
round(charges, 2)
])
csvfile.flush()
# update billing data
gridlabd.set_value(bill_name, "total_bill",
str(to_float(bill["total_bill"]) + charges))
gridlabd.set_value(bill_name, "billing_days", str(billing_days))
gridlabd.set_value(bill_name, "energy_charges",
str(to_float(bill["energy_charges"]) + charges))
gridlabd.set_value(bill_name, "total_charges",
str(to_float(bill["total_charges"]) + charges))
def setup(obj, t): # called to set up a new thermostat in a house
thermostats[obj] = thermostat(obj)
gridlabd.set_value(obj, "thermostat_control", 'NONE')
# disable the internal thermostat
return 0 # setup ok
def simulate_EVs(house_name, dt_sim_time):
EV_name = 'EV' + house_name[5:]
EV_obj = gridlabd.get_object(EV_name)
online_t = EV_obj['generator_status']
CP_inv_name = 'EV_inverter' + house_name[5:]
if dt_sim_time.hour >= 0 and dt_sim_time.hour <= 19:
if online_t == 'OFFLINE':
arrival = numpy.random.choice([True, False],
p=[10 / 60., 1. - 10 / 60.])
if arrival:
#Actual physical parameters
gridlabd.set_value(EV_name, 'generator_status', 'ONLINE')
soc = numpy.random.uniform(0.2, 0.8)
gridlabd.set_value(EV_name, 'state_of_charge',
str(soc)) #Unknow in TESS
#Settings through User App
Kev = numpy.random.uniform(0.5, 1.5)
gridlabd.set_value(EV_name, 'Kev', str(Kev))
tdep = dt_sim_time + pandas.Timedelta(
hours=7) + pandas.Timedelta(
minutes=random.randint(0, 60 * 1))
gridlabd.set_value(EV_name, 'tdep', str(tdep))
DeltaE = max(
numpy.random.choice(numpy.arange(5., 30., 5.),
p=[1 / 5.] * 5), (1. - soc) * 100.)
gridlabd.set_value(EV_name, 'DeltaE', str(DeltaE))
gridlabd.set_value(CP_inv_name, 'EV_connected', str(1))
if online_t == 'ONLINE':
#EV_obj = gridlabd.get_object(EV_name) #get new departure time
if pandas.to_datetime(EV_obj['tdep']) < dt_sim_time:
gridlabd.set_value(EV_name, 'generator_status', 'OFFLINE')
gridlabd.set_value(CP_inv_name, 'EV_connected', str(-1))
def update_EV(dt_sim_time, df_EV_state):
print('Update EV')
df_EV_state['active_t-1'] = df_EV_state['active_t']
df_EV_state['active_t'] = 0
df_events = pandas.read_csv('EV_events_pop.csv',
index_col=[0],
parse_dates=df_EV_state.index.tolist())
for EV in df_EV_state.index:
EV_number = int(EV.split('_')[-1])
next_event, next_u, next_soc, next_socmax = df_events[[
EV, EV + '_u', EV + '_SOC', EV + '_SOCmax'
]].iloc[0]
next_event = next_event.to_pydatetime()
#Event change
if next_event <= dt_sim_time: #event change in the last period -> change in status of battery
#prev_event, prev_soc = df_events[[EV,EV+'_SOC']].iloc[0]
df_events[[EV, EV + '_u', EV + '_SOC',
EV + '_SOCmax']] = df_events[[
EV, EV + '_u', EV + '_SOC', EV + '_SOCmax'
]].shift(-1)
#Randomly choose for fast-charging
if EV_speed == 'fast':
energy_refuel = (1. - next_soc) * next_socmax
list_EVs = [(24., 22.), (50., 32.), (50., 60.), (120., 90.)]
EV_type = np.random.choice(len(list_EVs), 1)[0]
next_u, next_socmax = list_EVs[EV_type]
next_soc = max(next_socmax - energy_refuel, 0.0) / next_socmax
#next_event, next_soc = df_events[[EV,EV+'_SOC']].iloc[0]
if not np.isnan(next_soc):
#Set EV
gridlabd.set_value(EV, 'generator_status', 'ONLINE')
gridlabd.set_value(EV, 'state_of_charge', str(next_soc))
gridlabd.set_value(EV, 'battery_capacity',
str(next_socmax * 1000))
i_max = 1000 * next_u / df_EV_state['v_max'].loc[EV]
gridlabd.set_value(EV, 'I_Max', str(i_max))
gridlabd.set_value(EV, 'P_Max', str(next_u * 1000))
gridlabd.set_value(EV, 'E_Max', str(next_u * 1000 * 1))
EV_inv = 'EV_inverter' + EV[2:]
gridlabd.set_value(EV_inv, 'rated_power',
str(1.2 * next_u * 1000))
gridlabd.set_value(EV_inv, 'rated_battery_power',
str(1.2 * next_u * 1000))
#import pdb; pdb.set_trace()
#Set df_EV_state
df_EV_state.at[EV, 'SOC_max'] = next_socmax
df_EV_state.at[EV, 'i_max'] = i_max
df_EV_state.at[EV, 'u_max'] = next_u
df_EV_state.at[
EV,
'connected'] = 1 #Does this one not work such that delay in connection?
df_EV_state.at[EV, 'soc_t'] = next_soc
df_EV_state.at[EV, 'SOC_t'] = next_soc * next_socmax
df_EV_state.at[EV, 'next_event'] = next_event
else: #if next event associated with non-NaN SOC - now connected and pot. charging
#Set EV (only switch off)
gridlabd.set_value(EV, 'generator_status', 'OFFLINE')
gridlabd.set_value(EV, 'state_of_charge', str(0.0))
#Set df_EV_state
df_EV_state.at[EV, 'SOC_max'] = 0.0
df_EV_state.at[EV, 'i_max'] = 0.0
df_EV_state.at[EV, 'u_max'] = 0.0
df_EV_state.at[
EV,
'connected'] = 0 #Does this one not work such that delay in connection?
df_EV_state.at[EV, 'soc_t'] = 0.0
df_EV_state.at[EV, 'SOC_t'] = 0.0
df_EV_state.at[EV, 'next_event'] = next_event
#After last event (no upcoming events)
elif pandas.isnull(next_event):
#Set EV (only switch off)
gridlabd.set_value(EV, 'generator_status', 'OFFLINE')
#Set df_EV_state
df_EV_state.at[EV, 'SOC_max'] = 0.0
df_EV_state.at[EV, 'i_max'] = 0.0
df_EV_state.at[EV, 'u_max'] = 0.0
df_EV_state.at[
EV,
'connected'] = 0 #Does this one not work such that delay in connection?
df_EV_state.at[EV, 'soc_t'] = 0.0
df_EV_state.at[EV, 'SOC_t'] = 0.0
df_EV_state.at[EV, 'next_event'] = next_event
#During charging event: Update EV state (SOC)
elif pandas.isnull(next_socmax):
# Updating through GridlabD model
EV_obj = gridlabd.get_object(EV)
soc_t = float(EV_obj['state_of_charge'])
df_EV_state.at[EV, 'soc_t'] = soc_t
SOC_t = soc_t * float(
EV_obj['battery_capacity']
) / 1000 #In Wh #Losses updated by GridlabD ?
df_EV_state.at[EV, 'SOC_t'] = SOC_t
# Updating using df
#print('GLD battery model is not used, manual updating!')
#gridlabd.set_value(EV,'state_of_charge',str(df_EV_state['soc_t'].loc[EV])) #in p.u.
else:
pass
df_events.to_csv('EV_events_pop.csv')
return df_EV_state
def get_settings_EVs(EVlist, interval, mysql=False):
cols_EV = [
'EV_name', 'house_name', 'SOC_max', 'i_max', 'v_max', 'u_max',
'efficiency', 'charging_type', 'k', 'soc_t', 'SOC_t', 'connected',
'next_event', 'active_t-1', 'active_t'
]
df_EV = pandas.DataFrame(columns=cols_EV)
#Read in charging events
#df_events = pandas.read_csv('EV_events_2016_july_Austin.csv',index_col=[0],parse_dates=True) #'EV_events_2015_july.csv'
df_events = pandas.read_csv(EV_data, index_col=[0], parse_dates=True)
first_time = pandas.Timestamp.today()
first_time = first_time.replace(year=first_time.year +
4) #to ensure working with RT data
for EV in EVlist:
df_events[EV] = pandas.to_datetime(df_events[EV])
if df_events[EV].min() < first_time:
first_time = df_events[EV].min()
first_time = first_time.replace(hour=0, minute=0, second=0)
start_time = pandas.to_datetime(start_time_str)
delta = start_time - first_time
for EV in EVlist:
df_events[EV] = df_events[EV] + delta
EV_obj = gridlabd.get_object(EV)
#gridlabd.set_value(EV,'use_internal_battery_model','FALSE')
house_name = 'GLD_' + EV[3:]
#Use GridLABD default values
v_max = float(EV_obj['V_Max']) #keep v_max constant for now
eff = float(EV_obj['base_efficiency'])
#Fills TABLE market_appliances
#SOC_min = float(EV_obj['reserve_state_of_charge']) #in % - 20%
#SOC_max = float(EV_obj['battery_capacity'])/1000 #Wh in Gridlabd -> kWh
#str_i_max = EV_obj['I_Max']
#i_max = str_i_max.split('+')[1]
#u_max = float(EV_obj['V_Max'])*float(i_max)/1000 #W -> kW #better inverter?
charging_type = EV_obj['charging_type']
k = float(EV_obj['k']) #no market: always highest wllingsness to pay
#Gets next event
cols = [EV, EV + '_u', EV + '_SOC', EV + '_SOCmax']
df_events_EV = df_events[cols]
discard_events = True
while discard_events:
if (df_events_EV[EV].iloc[0] < pandas.to_datetime(start_time_str)
) and (df_events_EV[EV].iloc[1] <
pandas.to_datetime(start_time_str)):
df_events_EV = df_events_EV.iloc[2:]
elif (df_events_EV[EV].iloc[0] < pandas.to_datetime(start_time_str)
) and (df_events_EV[EV].iloc[1] >
pandas.to_datetime(start_time_str)):
#Get information from EV events table
soc_t = df_events_EV[EV + '_SOC'].iloc[0] #relative soc
u_max = df_events_EV[EV + '_u'].iloc[0] #in kW
SOC_max = df_events_EV[EV + '_SOCmax'].iloc[0] #in kWh
#For start of the simulation
soc_t = soc_t + (
1. - soc_t
) / 2. #No EV connected yet - at midnight, initialize with 50% charged already
SOC_t = soc_t * SOC_max
gridlabd.set_value(EV, 'state_of_charge', str(soc_t))
gridlabd.set_value(EV, 'battery_capacity', str(SOC_max * 1000))
i_max = 1000 * u_max / v_max
gridlabd.set_value(EV, 'I_Max', str(i_max))
gridlabd.set_value(EV, 'generator_status', 'ONLINE')
next_event = df_events_EV[EV].iloc[
1] #Next event: disconnection
df_events_EV = df_events_EV.iloc[
1:] #Only discard connection event
connected = 1
discard_events = False
elif (df_events_EV[EV].iloc[0] > pandas.to_datetime(start_time_str)
) and (df_events_EV[EV].iloc[1] >
pandas.to_datetime(start_time_str)):
soc_t = 0.0
u_max = 0.0
SOC_max = 0.0
soc_t = 0.0
SOC_t = 0.0
i_max = 0.0
next_event = df_events_EV[EV].iloc[0] #Next event: connection
connected = 0
gridlabd.set_value(EV, 'generator_status', 'OFFLINE')
discard_events = False
else:
print(
'Unclear or no EV events at that charging station during that time'
)
soc_t = 0.0
i_max = 0.0
next_event = pandas.to_datetime(
end_time_str) #Next event: none / end_time
connected = 0
gridlabd.set_value(EV, 'generator_status', 'OFFLINE')
discard_events = False
df_EV = df_EV.append(pandas.Series([
EV, house_name, SOC_max, i_max, v_max, u_max, eff, charging_type,
k, soc_t, SOC_t, connected, next_event, 0, 0
],
index=cols_EV),
ignore_index=True)
df_events_EV.index = df_events_EV.index - df_events_EV.index[
0] #reset index to range()
df_events[cols] = df_events_EV[cols]
df_events.to_csv('EV_events_pop.csv')
df_EV.set_index('EV_name', inplace=True)
#Maybe drop all columns which are not used in this glm
return df_EV
def update_EV_rnd(dt_sim_time, df_EV_state):
print('Update EV')
df_EV_state['active_t-1'] = df_EV_state['active_t']
df_EV_state['active_t'] = 0
today = pandas.Timestamp(dt_sim_time.year, dt_sim_time.month,
dt_sim_time.day)
for EV in df_EV_state.index:
EV_number = int(EV.split('_')[-1])
next_event = df_EV_state['next_event'].loc[EV]
#Event change
if next_event <= dt_sim_time: #event change in the last period -> change in status of battery
#Randomly choose for fast-charging
if EV_speed == 'fast':
energy_refuel = (1. - next_soc) * next_socmax
list_EVs = [(24., 22.), (50., 32.), (50., 60.), (120., 90.)]
EV_type = np.random.choice(len(list_EVs), 1)[0]
next_u, next_socmax = list_EVs[EV_type]
next_soc = max(next_socmax - energy_refuel, 0.0) / next_socmax
#just arrived
if df_EV_state['connected'].loc[EV] == 0:
#Set EV
next_u = df_EV_state['u_max'].loc[EV]
gridlabd.set_value(EV, 'generator_status', 'ONLINE')
soc_t = np.random.uniform(0.2, 0.8)
gridlabd.set_value(EV, 'state_of_charge', str(soc_t))
gridlabd.set_value(EV, 'battery_capacity',
str(df_EV_state['SOC_max'].loc[EV] * 1000))
i_max = 1000 * next_u / df_EV_state['v_max'].loc[EV]
gridlabd.set_value(EV, 'I_Max', str(i_max))
gridlabd.set_value(EV, 'P_Max', str(next_u * 1000))
gridlabd.set_value(EV, 'E_Max', str(next_u * 1000 * 1))
EV_inv = 'EV_inverter' + EV[2:]
gridlabd.set_value(EV_inv, 'rated_power',
str(1.2 * next_u * 1000))
gridlabd.set_value(EV_inv, 'rated_battery_power',
str(1.2 * next_u * 1000))
#import pdb; pdb.set_trace()
#Set df_EV_state
df_EV_state.at[
EV,
'connected'] = 1 #Does this one not work such that delay in connection?
df_EV_state.at[EV, 'soc_t'] = soc_t
df_EV_state.at[
EV, 'SOC_t'] = soc_t * df_EV_state['SOC_max'].loc[EV]
#Departure time tomorrow
df_EV_state.at[EV, 'next_event'] = today + pandas.Timedelta(
days=1,
hours=np.random.choice(dep_hours),
minutes=np.random.choice(
range(60))) #Next event: disconnection
else: #if next event associated with non-NaN SOC - now connected and pot. charging
#Set EV (only switch off)
gridlabd.set_value(EV, 'generator_status', 'OFFLINE')
gridlabd.set_value(EV, 'state_of_charge', str(0.0))
#Set df_EV_state
df_EV_state.at[
EV,
'connected'] = 0 #Does this one not work such that delay in connection?
df_EV_state.at[EV, 'soc_t'] = 0.0
df_EV_state.at[EV, 'SOC_t'] = 0.0
#Arrival time today
df_EV_state.at[EV, 'next_event'] = today + pandas.Timedelta(
hours=np.random.choice(arr_hours),
minutes=np.random.choice(
range(60))) #Next event: disconnection
#During charging event: Update EV state (SOC)
elif df_EV_state['connected'].loc[EV] == 1:
# Updating through GridlabD model
# EV_obj = gridlabd.get_object(EV)
# soc_t = float(EV_obj['state_of_charge'])
# df_EV_state.at[EV,'soc_t'] = soc_t
# SOC_t = soc_t*float(EV_obj['battery_capacity'])/1000 #In Wh #Losses updated by GridlabD ?
# df_EV_state.at[EV,'SOC_t'] = SOC_t
# Updating using df
#print('GLD battery model is not used for EVs, manual updating!')
gridlabd.set_value(EV, 'state_of_charge',
str(df_EV_state['soc_t'].loc[EV])) #in p.u.
else:
pass
return df_EV_state
