def reset(self, name_save):
# stop existing energyplus simulation
if self.ep:
print("Closing the old simulation and socket.")
self.ep.close() # needs testing: check if it stops the simulation
tm.sleep(5)
self.ep = None
# tm.sleep(30)
# start new simulation
print("Starting a new simulation..")
self.kStep = 0
pyEp.set_eplus_dir("C:\\EnergyPlusV9-2-0")
path_to_buildings = os.path.join(self.directory, 'eplusModels')
builder = pyEp.socket_builder(path_to_buildings)
configs = builder.build()
self.ep = pyEp.ep_process('localhost', configs[0][0], configs[0][1],
self.weather_file)
self.outputs = np.round(self.ep.decode_packet_simple(self.ep.read()),
1).tolist()
self.name_save = name_save
for i in range(5, 10):
self.outputs[i] = calculate_tank_soc(
self.outputs[i],
min_temperature=self.tank_min_temperature,
max_temperature=self.tank_max_temperature)
time, day, outdoor_air_temperature, cooling_load, chiller_energy_consumption, storage_soc, storage_soc_l1, \
storage_soc_l2, storage_soc_l3, storage_soc_l4, diff_i, dir_i, auxiliary_energy_consumption, \
pump_energy_consumption = self.outputs
pv_power, efficiency = self.pv.electricity_prediction(
direct_radiation=dir_i,
diffuse_radiation=diff_i,
day=self.day_shift,
time=time,
t_out=outdoor_air_temperature)
self.SOC = storage_soc
electricity_price = self.electricity_price_schedule[0][self.kStep]
# the cooling load is returned as negative value from energy plus
cooling_load = np.abs(cooling_load)
next_state = (outdoor_air_temperature, cooling_load, electricity_price,
storage_soc, storage_soc_l1, storage_soc_l2,
storage_soc_l3, storage_soc_l4, pv_power,
auxiliary_energy_consumption, self.battery.soc, time,
day)
return next_state
# Import predictions
cooling_load_predictions = pd.read_csv('supportFiles\\prediction-cooling_load_perfect.csv')
electricity_price_predictions = pd.read_csv('supportFiles\\prediction-electricity_price_perfect.csv')
pv_power_generation_predictions = pd.read_csv('supportFiles\\prediction-pv_power_generation_perfect.csv')
electricity_price_schedule = pd.read_csv('supportFiles\\' + price_schedule_name, header=None)
# Set the number of actions
n_actions = 3
input_dims = env.observation_space.shape[0]
# define period for RBC control and
min_price = float(electricity_price_schedule[0].min())
# evaluate SOC
max_storage_soc = calculate_tank_soc(min_temperature_limit, min_temperature_limit,
max_temperature_limit) # The storage is full
min_charging_storage_soc = calculate_tank_soc(min_charging_temperature, min_temperature_limit,
max_temperature_limit)
min_storage_soc = calculate_tank_soc(max_temperature_limit, min_temperature_limit,
max_temperature_limit) # The storage is empty
# Initialize agent
agent = SACAgent(state_dim=input_dims,
action_dim=n_actions, hidden_dim=hidden_size, discount=discount_factor, tau=tau,
lr_critic=learning_rate_critic, lr_actor=learning_rate_actor,
batch_size=batch_size, replay_buffer_capacity=replay_buffer_capacity, learning_start=30 * 24,
reward_scaling=10., seed=seed, rbc_controller=None, safe_exploration=safe_exploration,
automatic_entropy_tuning=automatic_entropy_tuning, alpha=alpha)
rbc_controller = RBCAgent(min_storage_soc=min_storage_soc,
min_charging_storage_soc=min_charging_storage_soc,
def step(self, action: np.ndarray):
# current time from start of simulation
time = self.kStep * self.deltaT
# current time from start of day
dayTime = time % 86400
day_of_the_year = (time // 86400) + self.day_shift
if dayTime == 0:
print("Day: ", int(self.kStep / self.DAYSTEPS))
# prendo le azioni dal controllore
action = action[0]
cooling_load_total = 0
pv_power_total = 0
reward_total = 0
for i in range(0, self.ep_time_step):
if self.SOC == 0 and action < 0: # AVOID discharge when SOC is 0
action = 0
eplus_commands = get_eplus_action_encoding(action=action)
elif self.SOC > 0.97 and action > 0:
action = 0
eplus_commands = get_eplus_action_encoding(action=action)
else:
eplus_commands = get_eplus_action_encoding(action=action)
# EPlus simulation, input packet construction and feeding to Eplus
self.inputs = eplus_commands
input_packet = self.ep.encode_packet_simple(self.inputs, time)
self.ep.write(input_packet)
# after EnergyPlus runs the simulation step, it returns the outputs
output_packet = self.ep.read()
self.outputs = self.ep.decode_packet_simple(output_packet)
# Append agent action, may differ from actual actions
self.action_list.append(action)
# print("Outputs:", self.outputs)
if not self.outputs:
print("Outputs:", self.outputs)
print("Actions:", action)
next_state = self.reset()
return next_state, 0, False, {}
# Unpack Eplus output
# CALCULATE soc
for i in range(5, 10):
self.outputs[i] = calculate_tank_soc(
self.outputs[i],
min_temperature=self.tank_min_temperature,
max_temperature=self.tank_max_temperature)
time, day, outdoor_air_temperature, cooling_load, chiller_energy_consumption, storage_soc, storage_soc_l1, \
storage_soc_l2, storage_soc_l3, storage_soc_l4, diff_i, dir_i, auxiliary_energy_consumption, \
pump_energy_consumption, time_of_day, day_of_week = self.outputs
self.SOC = storage_soc
building_energy_consumption_ac = chiller_energy_consumption + pump_energy_consumption
# PV model from PV class, PV power in W, PV energy in Joule
incidence, zenith = self.pv.solar_angles_calculation(
day=day_of_the_year, time=time)
pv_power, efficiency = self.pv.electricity_prediction(
direct_radiation=dir_i,
diffuse_radiation=diff_i,
day=day_of_the_year,
time=time,
t_out=outdoor_air_temperature)
pv_energy_production_dc = pv_power * 60 * 60 / self.ep_time_step
pv_energy_excess_dc = pv_energy_production_dc - building_energy_consumption_ac / self.eta_ac_dc
# PV has always priority
# agent_battery_energy = abs(action_batt * self.battery.max_power * 60 * 60 / self.epTimeStep)
max_charge_dc = min(
self.battery.max_power_charging * 60 * 60 / self.ep_time_step,
(self.battery.soc_max - self.battery.soc) *
self.battery.max_capacity * 3600 / self.battery.eta_dc_dc)
max_discharge_dc = min(
self.battery.max_power_discharging * 60 * 60 /
self.ep_time_step, (self.battery.soc - self.battery.soc_min) *
self.battery.max_capacity * 3600 * self.battery.eta_dc_dc)
electricity_price = self.electricity_price_schedule[0][self.kStep]
if pv_energy_excess_dc > 0:
battery_energy_to_building_ac = 0
pv_energy_to_building_ac = building_energy_consumption_ac
grid_energy_to_building_ac = 0
grid_energy_to_battery_ac = 0
if pv_energy_excess_dc > max_charge_dc:
net_battery_energy_dc = max_charge_dc
pv_energy_to_grid_ac = (pv_energy_excess_dc -
max_charge_dc) * self.eta_ac_dc
else:
net_battery_energy_dc = pv_energy_excess_dc
pv_energy_to_grid_ac = 0
self.battery.charge(net_battery_energy_dc)
pv_energy_to_battery_dc = net_battery_energy_dc
else:
pv_energy_to_building_ac = pv_energy_production_dc * self.eta_ac_dc
pv_energy_to_battery_dc = 0
pv_energy_to_grid_ac = 0
grid_energy_to_battery_ac = 0
if electricity_price >= self.max_price:
building_energy_residual_ac = building_energy_consumption_ac - pv_energy_to_building_ac
if building_energy_residual_ac / self.eta_ac_dc <= max_discharge_dc:
net_battery_energy_dc = building_energy_consumption_ac / self.eta_ac_dc - pv_energy_production_dc
battery_energy_to_building_ac = net_battery_energy_dc * self.eta_ac_dc
grid_energy_to_building_ac = 0
else:
net_battery_energy_dc = max_discharge_dc
battery_energy_to_building_ac = net_battery_energy_dc * self.eta_ac_dc
grid_energy_to_building_ac = building_energy_consumption_ac - pv_energy_to_building_ac - \
battery_energy_to_building_ac
else:
net_battery_energy_dc = 0
battery_energy_to_building_ac = 0
pv_energy_to_grid_ac = 0
grid_energy_to_building_ac = building_energy_consumption_ac - pv_energy_to_building_ac
self.battery.discharge(net_battery_energy_dc)
grid_energy_ac = grid_energy_to_building_ac + grid_energy_to_battery_ac
self.battery.soc = np.clip(self.battery.soc, self.battery.soc_min,
self.battery.soc_max)
# START REWARD CALCULATIONS
energy_cost_from_grid = (grid_energy_ac / (3.6 * 1000000) *
electricity_price)
energy_cost_to_grid = (pv_energy_to_grid_ac / (3.6 * 1000000) *
self.min_price / 2)
reward_price = -energy_cost_from_grid + energy_cost_to_grid
# price component
reward = reward_price * self.reward_multiplier
# END REWARD CALCULATIONS
self.reward_list.append(reward)
self.price_list.append(electricity_price)
self.tank_soc_list.append(storage_soc)
self.battery_soc_list.append(self.battery.soc)
self.incidence_list.append(incidence)
self.zenith_list.append(zenith)
self.efficiency_list.append(efficiency)
self.pv_power_generation_list.append(pv_power)
self.pv_energy_production_list.append(pv_energy_production_dc)
self.pv_energy_to_building_list.append(pv_energy_to_building_ac)
self.pv_energy_to_battery_list.append(pv_energy_to_battery_dc)
self.pv_energy_to_grid_list.append(pv_energy_to_grid_ac)
self.grid_energy_list.append(grid_energy_ac)
self.grid_energy_to_building_list.append(
grid_energy_to_building_ac)
self.grid_energy_to_battery_list.append(grid_energy_to_battery_ac)
self.battery_energy_to_building_list.append(
battery_energy_to_building_ac)
self.building_energy_consumption_list.append(
building_energy_consumption_ac)
self.p_cool_list.append(cooling_load)
self.energy_cost_from_grid_list.append(energy_cost_from_grid)
self.energy_cost_to_grid_list.append(energy_cost_to_grid)
# the cooling load is returned as negative value from energy plus
cooling_load = np.abs(cooling_load)
cooling_load_total += cooling_load
pv_power_total += pv_power
reward_total += reward
self.kStep += 1
if self.kStep >= self.MAXSTEPS:
break
cooling_load_total = cooling_load_total / self.ep_time_step
pv_power_total = pv_power_total / self.ep_time_step
next_state = (outdoor_air_temperature, cooling_load_total,
electricity_price, storage_soc, storage_soc_l1,
storage_soc_l2, storage_soc_l3, storage_soc_l4,
pv_power_total, auxiliary_energy_consumption,
self.battery.soc, time_of_day, day_of_week)
next_state = order_state_variables(
env_names=self.state_names,
observation=next_state,
cooling_load_predictions=self.cooling_load_predictions,
electricity_price_predictions=self.electricity_price_predictions,
pv_power_generation_predictions=self.
pv_power_generation_predictions,
horizon=self.horizon,
step=self.hStep)
self.hStep += 1
done = False
if self.kStep >= self.MAXSTEPS:
print(self.kStep)
# requires one more step to close the simulation
input_packet = self.ep.encode_packet_simple(self.inputs, time)
self.ep.write(input_packet)
# output is empty in the final step
# but it is required to read this output for termination
output_packet = self.ep.read()
last_output = self.ep.decode_packet_simple(output_packet)
print("Finished simulation")
print("Last action: ", action)
print("Last reward: ", reward)
done = True
print(done)
self.ep.close()
tm.sleep(20)
dataep = pd.read_csv(self.directory +
'\\eplusModels\\storageTank_Model\\' +
self.idf_name + '.csv')
dataep['Action'] = self.action_list
dataep['Reward'] = self.reward_list
dataep['Price'] = self.price_list
dataep['Tank SOC'] = self.tank_soc_list
dataep['Battery soc'] = self.battery_soc_list
dataep['Incidence'] = self.incidence_list
dataep['Zenith'] = self.zenith_list
dataep['Efficiency'] = self.efficiency_list
dataep['PV power generation [W]'] = self.pv_power_generation_list
dataep['PV energy production [J]'] = self.pv_energy_production_list
dataep[
'PV energy to building [J]'] = self.pv_energy_to_building_list
dataep['PV energy to grid [J]'] = self.pv_energy_to_grid_list
dataep['PV energy to battery [J]'] = self.pv_energy_to_battery_list
dataep['grid energy [J]'] = self.grid_energy_list
dataep[
'grid energy to building [J]'] = self.grid_energy_to_building_list
dataep[
'grid energy to battery [J]'] = self.grid_energy_to_battery_list
dataep[
'battery energy to building [J]'] = self.battery_energy_to_building_list
dataep['Cooling load [W]'] = self.p_cool_list
dataep['Building load [J]'] = self.building_energy_consumption_list
dataep[
'Energy costs from grid [€]'] = self.energy_cost_from_grid_list
dataep['Energy costs to grid [€]'] = self.energy_cost_to_grid_list
episode_electricity_consumption = dataep[
'CHILLER:Chiller Electric Energy [J](TimeStep)'].sum() / (
3.6 * 1000000)
episode_electricity_cost = dataep['Energy costs from grid [€]'].sum(
) - dataep['Energy costs to grid [€]'].sum()
self.episode_electricity_cost = episode_electricity_cost
print('Elec consumption: ' + str(episode_electricity_consumption) +
' Elec Price: ' + str(episode_electricity_cost))
dataep.to_csv(path_or_buf=self.res_directory + '/' + 'episode_' +
str(self.episode_number) + '.csv',
sep=';',
decimal=',',
index=False)
self.episode_number = self.episode_number + 1
self.ep = None
self.action_list = []
self.reward_list = []
self.price_list = []
self.tank_soc_list = []
self.battery_soc_list = []
self.incidence_list = []
self.zenith_list = []
self.efficiency_list = []
self.pv_power_generation_list = []
self.pv_energy_production_list = []
self.pv_energy_to_building_list = []
self.pv_energy_to_grid_list = []
self.pv_energy_to_battery_list = []
self.grid_energy_list = []
self.grid_energy_to_building_list = []
self.grid_energy_to_battery_list = []
self.battery_energy_to_building_list = []
self.p_cool_list = []
self.building_energy_consumption_list = []
self.grid_list = []
self.energy_cost_from_grid_list = []
self.energy_cost_to_grid_list = []
self.SOC = 1
self.battery.soc = 0.46
info = {}
if self.kStep == self.MAXSTEPS:
print(done)
return next_state, reward, done, info