def opt_control_minCost(self):
# Instantiate optimization problem
self.opt_problem = optimization.Optimization(self.mpc,
optimization.EnergyCostMin,
optimization.JModelica,
self.target_variable,
constraint_data = self.constraints.data,
add_objective = self.slack_var
)
print("%%%%%%%%%%%%%%%----Starting Optimization of Control ---%%%%%%%%%%%%%")
self.opt_options = {}
self.opt_options['blocking_factors'] = [1]*10
self.opt_problem.set_optimization_options(self.opt_options)
self.opt_problem.optimize(self.opt_start,self.opt_end,
price_data = self.price.data,
rho = self.rho.data,
addobj = self.addobj.data
)
print("----Optimization stats----")
print(self.opt_problem.get_optimization_statistics())
print("----Optimization outcome----")
self.opt_controlseq = self.opt_problem.Model.control_data # dictionary with mpcpy-timeseries variables of controls
store_namespace('opt_control_mincost_'+self.building,self.opt_controlseq)
def opt_control_minDRCost(self):
# Instantiate optimization problem
self.opt_problem = optimization.Optimization(self.mpc,
optimization.DRCostMin,
optimization.JModelica,
self.target_variable,
constraint_data = self.constraints.data,
add_objective = self.slack_var
)
print("%%%%%%%%%%%%%%%----Starting Optimization of Control ---%%%%%%%%%%%%%")
self.opt_options = {}
self.opt_options['IPOPT_options']={}
self.opt_options['IPOPT_options']['obj_scaling_factor'] = 100
self.opt_options['n_cp'] = 1
self.opt_problem.set_optimization_options(self.opt_options)
self.opt_problem.optimize(self.opt_start,self.opt_end,
price_data = self.price.data,
ref_profile = self.ref_profile.data,
flex_cost = self.flex_cost.data,
rho = self.rho.data,
addobj = self.addobj.data
)
print("----Optimization stats----")
print(self.opt_problem.get_optimization_statistics())
print("----Optimization outcome----")
self.opt_controlseq = self.opt_problem.Model.control_data # dictionary with mpcpy-timeseries variables of controls
store_namespace('opt_control_DRcost_'+self.building,self.opt_controlseq)
def opt_control_minEnergy(self):
# Instantiate optimization problem
self.opt_problem = optimization.Optimization(
self.mpc,
optimization.EnergyMin,
optimization.JModelica,
self.target_variable,
constraint_data=self.constraints.data)
self.opt_problem
print(
"%%%%%%%%%%%%%%%----Starting Optimization of Control ---%%%%%%%%%%%%%"
)
self.opt_problem.optimize(self.opt_start,
self.opt_end,
res_control_step=self.meas_sampl)
print("----Optimization stats----")
print(self.opt_problem.get_optimization_statistics())
print("----Optimization outcome----")
self.opt_controlseq = self.opt_problem.Model.control_data # dictionary with mpcpy-timeseries variables of controls
print(self.opt_controlseq)
#print(opt_control['Qflow1'])
#print(opt_control['Qflow2'])
store_namespace('opt_control_minenergy_' + self.building,
self.opt_controlseq)
def opt_control_minDRCost(self):
# Instantiate optimization problem
self.opt_problem = optimization.Optimization(
self.mpc,
optimization.DRCostMin,
optimization.JModelica,
self.target_variable,
constraint_data=self.constraints.data)
print(
"%%%%%%%%%%%%%%%----Starting Optimization of Control ---%%%%%%%%%%%%%"
)
self.opt_problem.optimize(self.opt_start,
self.opt_end,
price_data=self.price.data,
ref_profile=self.ref_profile.data,
flex_cost=self.flex_cost.data)
print("----Optimization stats----")
print(self.opt_problem.get_optimization_statistics())
print("----Optimization outcome----")
self.opt_controlseq = self.opt_problem.Model.control_data # dictionary with mpcpy-timeseries variables of controls
#print(opt_control)
#print(opt_control['Qflow1'])
#print(opt_control['Qflow2'])
store_namespace('opt_control_DRcost_' + self.building,
self.opt_controlseq)
def emulate_opt(self,start,end):
print("%%%---Emulating real system---%%%")
self.emu.control_data = self.opt_controlseq
emulate_jmod(self.emu, self.meas_vars_emu, self.meas_sampl, start, end)
print("Updating measurements")
self.mpc.measurements = self.emu.measurements
store_namespace('optemu_'+self.building,self.emu.display_measurements('Measured'))
def update_params(self, param, value, unit):
# Add a new value fixed value to parameters
self.parameters.data[param] = {
'Free': variables.Static('FreeOrNot', False, units.boolean),
'Minimum': variables.Static(param, value, unit),
'Covariance': variables.Static('Covar', 0, unit),
'Value': variables.Static(param, value, unit),
'Maximum': variables.Static(param, value, unit)
}
store_namespace('params_upd_' + self.building, self.parameters)
def opt_control_minDRCost(self):
# Instantiate optimization problem
print("----Optimization stats----")
print(self.opt_problem.get_optimization_statistics())
print("----Optimization outcome----")
self.opt_controlseq = self.opt_problem.Model.control_data # dictionary with mpcpy-timeseries
store_namespace('opt_control_DRcost_' + self.building,
self.opt_controlseq)
def get_control(self):
self.control = exodata.ControlFromCSV(self.control_file,
self.contr_varmap,
tz_name = self.weather.tz_name)
index = pd.date_range(self.sim_start, self.sim_end, freq = str(self.meas_sampl)+'S')
# Random control signal
control_signal1 = pd.Series(np.random.rand(len(index))*0.1,index=index)
# Define control data
self.control.data = {"HPPower": variables.Timeseries('HPPower', control_signal1,units.W,tz_name=self.weather.tz_name)
}
store_namespace('control_'+self.building,self.control)
def run_reference(self, start, end):
print("%%%---Running Reference Simulation---%%%")
emulate_jmod(self.emuref,self.meas_vars_ref, self.meas_sampl_ref, start, end)
#print(self.emuref.display_measurements('Measured')['TAir'])
#print(self.emuref.display_measurements('Measured')['HeatInput'])
store_namespace('ref_power_'+self.building, self.emuref.display_measurements('Measured')['PowerCompr'])
store_namespace('ref_temp_'+self.building, self.emuref.display_measurements('Measured')['TAir'])
def emulate_opt(self, start, end):
print("%%%---Emulating real system---%%%")
self.emu.control_data = self.opt_controlseq
emulate_jmod(self.emu, self.meas_vars_emu, self.meas_sampl, start, end)
#print("Updating measurements")
#self.mpc.measurements = self.emu.measurements
#print("Validating")
#self.mpc.validate(start, end, 'val_opt', plot=1)
#print(emu_opt.display_measurements('Measured')['TAir'])
store_namespace('optemu_' + self.building,
self.emu.display_measurements('Measured'))
def get_constraints(self, start, end):
self.constraints = exodata.ConstraintFromCSV(self.constraint_csv,
self.optcon_varmap)
#print("%%%% constraint data %%%%")
#print(self.constraints)
#print(self.constraints.data)
index = pd.date_range(start, end, freq=str(self.meas_sampl) + 'S')
# Set points based on UCL paper on set points!!! High variability? Commercial?
mor_start = np.random.randint(5, 9)
mor_end = np.random.randint(9, 12)
eve_start = np.random.randint(15, 19)
eve_end = np.random.randint(19, 23)
dem_temp = np.random.randint(18, 23)
t_min = pd.Series(14 + 273.15, index=index) # Contracted?
t_max = pd.Series(28 + 273.15, index=index) # Contracted?
for i in index:
if i.hour >= mor_start and i.hour <= mor_end:
t_min[i] = dem_temp - 1 + 273.15
t_max[i] = dem_temp + 1 + 273.15
if i.hour >= eve_start and i.hour <= eve_end:
t_min[i] = dem_temp - 1 + 273.15
t_max[i] = dem_temp + 1 + 273.15
pheat_min = pd.Series(0, index=index)
pheat_max = pd.Series(10000, index=index)
#print(t_min)
self.constraints.data = {
'TAir': {
'GTE':
variables.Timeseries('TAir_GTE',
t_min,
units.K,
tz_name=self.weather.tz_name),
'LTE':
variables.Timeseries('TAir_LTE',
t_max,
units.K,
tz_name=self.weather.tz_name)
},
'ConvGain2': {
'GTE':
variables.Timeseries('ConvGain2_GTE',
pheat_min,
units.W,
tz_name=self.weather.tz_name),
'LTE':
variables.Timeseries('ConvGain2_LTE',
pheat_max,
units.W,
tz_name=self.weather.tz_name)
}
}
store_namespace('constraints_' + self.building, self.constraints)
def get_DRinfo(self,start,end,**kwargs):
self.price = exodata.PriceFromCSV(self.price_file,
self.price_varmap,
tz_name = self.weather.tz_name)
self.flex_cost = exodata.PriceFromCSV(self.price_file,
self.flex_cost_varmap,
tz_name = self.weather.tz_name)
self.rho = exodata.PriceFromCSV(self.price_file,
self.rho_varmap,
tz_name = self.weather.tz_name)
self.ref_profile = exodata.ControlFromCSV(self.control_file,
self.ref_profile_varmap,
tz_name = self.weather.tz_name)
self.addobj = exodata.ControlFromCSV(self.price_file,
self.addobj_varmap,
tz_name = self.weather.tz_name)
index = pd.date_range(start, end, freq = str(self.meas_sampl)+'S')
# Random control signal
index = pd.date_range(start, end, freq = '1800S') #half-hourly price signal
price_signal = pd.Series(np.random.rand(len(index))*40,index=index)
for i in index:
if i.hour >= 7 and i.hour <= 11:
price_signal[i] = np.random.uniform(0.8,1)*60
if i.hour >= 18 and i.hour <= 19:
price_signal[i] = np.random.uniform(0.9,1)*90
if i.hour >= 20 and i.hour <= 22:
price_signal[i] = np.random.uniform(0.8,1)*60
index = pd.date_range(start, end, freq = str(self.meas_sampl)+'S')
flex_signal = pd.Series(0,index=index)
k = pd.Series(1,index=index)
ref_signal = pd.Series(0.3,index=index)
rho_signal = pd.Series(1000,index=index)
#ref_signal = load_namespace(self.ref_profile_file)[0]
#print(type(ref_signal))
self.price.data = {"pi_e": variables.Timeseries('pi_e', price_signal,units.cents_kWh,tz_name=self.weather.tz_name)
}
self.flex_cost.data = {"flex_cost": variables.Timeseries('flex_cost', flex_signal,units.cents_kWh,tz_name=self.weather.tz_name)
}
self.ref_profile.data = {"ref_profile": variables.Timeseries('ref_profile', ref_signal, units.W,tz_name=self.weather.tz_name)
}
self.rho.data = {"rho": variables.Timeseries('rho', rho_signal, units.unit1,tz_name=self.weather.tz_name)
}
self.addobj.data = {}
for item in self.slack_var:
self.addobj.data[item] = variables.Timeseries(item, pd.Series(0,index=index), units.unit1,tz_name=self.weather.tz_name)
#print(self.addobj.data)
store_namespace('price_'+self.building,self.price)
store_namespace('flex_cost_'+self.building,self.flex_cost)
store_namespace('ref_profile_'+self.building,self.ref_profile)
store_namespace('rho_'+self.building,self.rho)
def update_constraints(self, start, end):
print(" %%%%%%%%%%%%%%%% Updating constraints %%%%%%%%%%%%%%%%")
#print(self.constraints)
#print(self.constraints.data)
index = pd.date_range(start, end, freq=str(self.meas_sampl) + 'S')
mor_start = np.random.randint(5, 9)
mor_end = np.random.randint(9, 12)
eve_start = np.random.randint(15, 19)
eve_end = np.random.randint(19, 24)
dem_temp = np.random.randint(18, 23)
t_min = pd.Series(15 + 273.15, index=index)
t_max = pd.Series(26 + 273.15, index=index)
for i in index:
if i.hour >= mor_start and i.hour <= mor_end:
t_min[i] = dem_temp - 1 + 273.15
t_max[i] = dem_temp + 1 + 273.15
if i.hour >= eve_start and i.hour <= eve_end:
t_min[i] = dem_temp - 1 + 273.15
t_max[i] = dem_temp + 1 + 273.15
pheat_min = pd.Series(0, index=index)
pheat_max = pd.Series(10000, index=index)
#print(t_min)
self.constraints.data = {
'TAir': {
'GTE':
variables.Timeseries('TAir_GTE',
t_min,
units.K,
tz_name=self.weather.tz_name),
'LTE':
variables.Timeseries('TAir_LTE',
t_max,
units.K,
tz_name=self.weather.tz_name)
},
'ConvGain2': {
'GTE':
variables.Timeseries('ConvGain2_GTE',
pheat_min,
units.W,
tz_name=self.weather.tz_name),
'LTE':
variables.Timeseries('ConvGain2_LTE',
pheat_max,
units.W,
tz_name=self.weather.tz_name)
}
}
#print(self.constraints.display_data())
store_namespace('constraints_upd_' + self.building, self.constraints)
def get_other_input(self,start,end):
index = pd.date_range(start, end, freq = str(self.meas_sampl)+'S')
# Zero signal
radgain = pd.Series(np.random.rand(len(index))*100,index=index)
zero_signal = pd.Series(np.zeros(len(index)),index=index)
self.other_input = exodata.ControlFromCSV(self.control_file,
self.other_varmap,
tz_name = self.weather.tz_name)
self.other_input.data = {"ConvGain1": variables.Timeseries('ConvGain1', zero_signal,units.W,tz_name=self.weather.tz_name),
"RadGain": variables.Timeseries('RadGain', radgain,units.W,tz_name=self.weather.tz_name)
}
store_namespace('other_input_'+self.building,self.other_input)
def update_control(self, start, end):
print("%%%%%%%%%%%%%%%% Updating control %%%%%%%%%%%%%%%%")
index = pd.date_range(start, end, freq=str(self.meas_sampl) + 'S')
# Random control signal
control_signal1 = pd.Series(np.random.rand(len(index)) * 0,
index=index)
# Define control data
self.control.data = {
"ConvGain2":
variables.Timeseries('ConvGain2',
control_signal1,
units.W,
tz_name=self.weather.tz_name)
}
#pheat_max = pd.Series(10000,index=index)
#self.control.collect_data(self.sim_start, self.sim_end)
#print(self.control.display_data())
store_namespace('control_upd_' + self.building, self.control)
def sys_id(self):
print("%%%% ---Starting system identification --- %%%%")
# Emulate
print('%%%%---Measured variables---%%%%')
print(self.emu.display_measurements('Measured'))
#Simulate mpc
self.mpc.simulate(self.id_start, self.id_end)
print('%%%%---Simulated variables---%%%%')
print(self.mpc.display_measurements('Simulated'))
print('%%%%---Estimating parameters---%%%%')
self.mpc.estimate(self.id_start,self.id_end, self.est_params)
# Just print the parameters
print("%%%---Estimated Parameters----%%%%")
for key in self.mpc.parameter_data.keys():
print(key, self.mpc.parameter_data[key]['Value'].display_data())
store_namespace('est_params_'+self.building,self.mpc.parameter_data)
def get_constraints(self,start,end, **kwargs):
self.constraints = exodata.ConstraintFromCSV(self.constraint_csv, self.optcon_varmap)
index = pd.date_range(start, end, freq = str(self.meas_sampl) +'S')
# Set points based on UCL paper on set points!!! High variability? Commercial?
mor_start = np.random.randint(7,8)
mor_end = np.random.randint(7,8)
eve_start = np.random.randint(17,18)
eve_end = np.random.randint(19,23)
dem_temp = np.random.randint(19,21)
t_min = pd.Series(16+273.15,index=index) # Contracted?
t_max = pd.Series(24+273.15,index=index) # Contracted?
ppl_nr = np.random.randint(1,5)
radgain = pd.Series(np.random.rand(len(index))*100,index=index)
zero_signal = pd.Series(np.zeros(len(index)),index=index)
control_signal1 = pd.Series(np.random.rand(len(index))*0,index=index)
for i in index:
if i.hour >= mor_start and i.hour <= mor_end:
t_min[i] = dem_temp-1+273.15
t_max[i] = dem_temp+1+273.15
radgain[i] = np.random.uniform(0,1)*50*np.random.randint(0,ppl_nr)
control_signal1[i] = np.random.uniform(0.2,0.6)
if i.hour >= eve_start and i.hour <= eve_end:
t_min[i] = dem_temp-1+273.15
t_max[i] = dem_temp+1+273.15
radgain[i] = np.random.uniform(0,1)*50*np.random.randint(0,ppl_nr)
control_signal1[i] = np.random.uniform(0.2,0.6)
pheat_min = pd.Series(0,index=index)
pheat_max = pd.Series(1,index=index)
if 'set_change' in kwargs.keys():
set_change = kwargs['set_change']
else:
set_change = 1
#print(t_min)
self.constraints.data = {
'HPPower':
{'GTE': variables.Timeseries('HPPower_GTE', pheat_min, units.W, tz_name=self.weather.tz_name),
'LTE': variables.Timeseries('HPPower_LTE', pheat_max, units.W,tz_name=self.weather.tz_name)},
'TAir':
{'Slack_GTE': variables.Timeseries('TAir_Slack_GTE', t_min, units.K, tz_name=self.weather.tz_name),
'Slack_LTE': variables.Timeseries('TAir_Slack_LTE', t_max, units.K, tz_name=self.weather.tz_name)}
}
self.constraints_reg = self.constraints # Regular constraints
self.other_input.data = {"ConvGain1": variables.Timeseries('ConvGain1', zero_signal,units.W,tz_name=self.weather.tz_name),
"RadGain": variables.Timeseries('RadGain', radgain,units.W,tz_name=self.weather.tz_name)
}
if "upd_control" in kwargs.keys():
self.control.data = {"HPPower": variables.Timeseries('HPPower', control_signal1,units.W,tz_name=self.weather.tz_name)}
store_namespace('control_'+self.building,self.control)
store_namespace('constraints_'+self.building,self.constraints)
store_namespace('other_input_'+self.building,self.other_input)
def get_control(self):
self.control = exodata.ControlFromCSV(self.control_file,
self.contr_varmap,
tz_name=self.weather.tz_name)
index = pd.date_range(self.sim_start,
self.sim_end,
freq=str(self.meas_sampl) + 'S')
# Random control signal
control_signal1 = pd.Series(np.random.rand(len(index)) * 3000,
index=index)
# Define control data
self.control.data = {
"ConvGain2":
variables.Timeseries('ConvGain2',
control_signal1,
units.W,
tz_name=self.weather.tz_name)
}
#pheat_max = pd.Series(10000,index=index)
#self.control.collect_data(self.sim_start, self.sim_end)
#print(self.control.display_data())
store_namespace('control_' + self.building, self.control)
def get_other_input(self, start, end):
index = pd.date_range(start, end, freq=str(self.meas_sampl) + 'S')
# Zero signal
radgain = pd.Series(np.random.rand(len(index)) * 100, index=index)
zero_signal = pd.Series(np.zeros(len(index)), index=index)
#t_start = pd.Series(self.start_temp, index=index)
mor_start = np.random.randint(5, 9)
mor_end = np.random.randint(9, 12)
eve_start = np.random.randint(15, 19)
eve_end = np.random.randint(19, 24)
dem_temp = np.random.randint(18, 23)
ppl_nr = np.random.randint(1, 5)
for i in index:
if i.hour >= mor_start and i.hour <= mor_end:
radgain[i] = np.random.uniform(0, 1) * 150 * np.random.randint(
0, ppl_nr)
if i.hour >= eve_start and i.hour <= eve_end:
radgain[i] = np.random.uniform(0, 1) * 150 * np.random.randint(
0, ppl_nr)
self.other_input = exodata.ControlFromCSV(self.control_file,
self.other_varmap,
tz_name=self.weather.tz_name)
self.other_input.data = {
"ConvGain1":
variables.Timeseries('ConvGain1',
zero_signal,
units.W,
tz_name=self.weather.tz_name),
"RadGain":
variables.Timeseries('RadGain',
radgain,
units.W,
tz_name=self.weather.tz_name)
}
store_namespace('other_input_' + self.building, self.other_input)
def get_DRinfo(self, start, end, **kwargs):
self.price = exodata.PriceFromCSV(self.price_file,
self.price_varmap,
tz_name=self.weather.tz_name)
self.flex_cost = exodata.PriceFromCSV(self.price_file,
self.flex_cost_varmap,
tz_name=self.weather.tz_name)
self.ref_profile = exodata.ControlFromCSV(self.control_file,
self.ref_profile_varmap,
tz_name=self.weather.tz_name)
index = pd.date_range(start, end, freq=str(self.meas_sampl) + 'S')
# Random control signal
price_signal = pd.Series(np.random.rand(len(index)) * 40, index=index)
flex_signal = pd.Series(0, index=index)
k = pd.Series(1, index=index)
ref_signal = pd.Series(25000, index=index)
#ref_signal = load_namespace(self.ref_profile_file)[0]
#print(type(ref_signal))
for i in index:
if i.hour >= 7 and i.hour <= 11:
price_signal[i] = np.random.uniform(0.8, 1) * 60
if i.hour >= 17 and i.hour <= 19:
price_signal[i] = np.random.uniform(0.8, 1) * 90
if i.hour >= 20 and i.hour <= 22:
price_signal[i] = np.random.uniform(0.8, 1) * 60
self.price.data = {
"pi_e":
variables.Timeseries('pi_e',
price_signal,
units.cents_kWh,
tz_name=self.weather.tz_name)
}
self.flex_cost.data = {
"flex_cost":
variables.Timeseries('flex_cost',
flex_signal,
units.cents_kWh,
tz_name=self.weather.tz_name)
}
self.ref_profile.data = {
"ref_profile":
variables.Timeseries('ref_profile',
ref_signal,
units.W,
tz_name=self.weather.tz_name)
}
#pheat_max = pd.Series(10000,index=index)
#self.control.collect_data(self.sim_start, self.sim_end)
#print(self.price.display_data())
#print(self.flex_cost.display_data())
#print(self.ref_profile.display_data())
store_namespace('price_' + self.building, self.price)
store_namespace('flex_cost_' + self.building, self.flex_cost)
store_namespace('ref_profile_' + self.building, self.ref_profile)
def validate(self, val_start, val_end, id , plotfile):
print("%%%%%%%%%%%%%%%----Starting another validation with estimated parameters ---%%%%%%%%%%%%%")
# Validate against another time period
self.emu.collect_measurements(val_start, val_end)
self.mpc.measurements = self.emu.measurements
self.mpc.validate(val_start, val_end, plotfile, plot=1)
plt.clf() # clear the figure
print("----The RMSE------")
for key in self.mpc.RMSE.keys():
print(self.mpc.RMSE[key].display_data())
store_namespace('RMSE_'+id+'_'+self.building,self.mpc.RMSE)
store_namespace('sim_'+id+'_'+self.building,self.mpc.display_measurements('Simulated'))
store_namespace('meas_'+id+'_'+self.building,self.emu.display_measurements('Measured'))
emutemps_df = pd.concat([emutemps_df, emutemps_df1])
power_df1 = pd.DataFrame.from_dict(power[sim_id], orient='index')
power_df1.index = pd.to_datetime(power_df1.index)
power_df1.index = power_df1.index.shift(1, freq=str(step) + 'S')
power_df = pd.concat([power_df, power_df1])
opt_stats_df1 = pd.DataFrame.from_dict(opt_stats[sim_id],
orient='index')
opt_stats_df1.index = pd.to_datetime(opt_stats_df1.index)
opt_stats_df = pd.concat([opt_stats, opt_stats_df1])
i = i + 1
store_namespace(os.path.join(simu_path, folder, 'emutemps'), emutemps_df)
store_namespace(os.path.join(simu_path, folder, 'mpctemps'), mpctemps)
store_namespace(os.path.join(simu_path, folder, 'opt_stats'), opt_stats_df)
constraints = {}
for bldg in bldg_list:
setpoint_dict = load_namespace(
os.path.join(simu_path, constr_folder,
'constraints_' + bldg + '_' + model_id)).data['TAir']
constraints[bldg] = {}
for param in setpoint_dict.keys():
constraints[bldg]['hi'] = setpoint_dict['Slack_LTE'].display_data(
).resample(str(step) + 'S').ffill()
constraints[bldg]['lo'] = setpoint_dict['Slack_GTE'].display_data(
).resample(str(step) + 'S').ffill()
def update_weather(self, start, end):
# Next we get exogenous data from epw-file
print("%%%%%%---Getting weather data---%%%%%%%%%%%%%")
self.weather = exodata.WeatherFromEPW(self.weather_file)
self.weather.collect_data(start, end)
store_namespace('weather', self.weather.display_data())
def get_params(self):
self.parameters = exodata.ParameterFromCSV(self.param_file)
self.parameters.collect_data()
store_namespace('params_' + self.building, self.parameters)
def init_ARMA_model(self, order, endog_var, exog_features, train_data):
self.ARMA_model = ARMA_model(
order, endog_var, exog_features, train_data
) # This computes the transition matrices of the discretised RC-model
store_namespace('ARMA_model_' + self.building, self.ARMA_model)
def init_ARX_model(self, features, target, train_data):
self.ARX_model = ARX_model(
features, target, train_data
) # This computes the transition matrices of the discretised RC-model
store_namespace('ARX_model_' + self.building, self.ARX_model)
emutemps[time_idx] = load_namespace(
os.path.join(simu_path, folder,
'emutemps_' + building + '_' + sim_id + '_' + t))
mpctemps[time_idx] = load_namespace(
os.path.join(simu_path, folder,
'mpctemps_' + building + '_' + sim_id + '_' + t))
power[time_idx] = load_namespace(
os.path.join(simu_path, folder,
'power_' + building + '_' + sim_id + '_' + t))
opt_stats_df = pd.DataFrame.from_dict(opt_stats, orient='index')
opt_stats_df.index = pd.to_datetime(opt_stats_df.index)
store_namespace(os.path.join(simu_path, folder, 'mpctemps'), mpctemps)
store_namespace(os.path.join(simu_path, folder, 'emutemps'), emutemps)
store_namespace(os.path.join(simu_path, folder, 'power'), power)
store_namespace(os.path.join(simu_path, folder, 'opt_stats'), opt_stats_df)
#print(controlseq)
# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# Optimization temps
emutemps_df = pd.DataFrame.from_dict(emutemps, orient='index')
emutemps_df.index = pd.to_datetime(emutemps_df.index)
emutemps_df.index = emutemps_df.index.shift(1, freq=str(step) + 'S')
power_df = pd.DataFrame.from_dict(power, orient='index')
power_df.index = pd.to_datetime(power_df.index)
power_df.index = power_df.index.shift(1, freq=str(step) + 'S')
def update_DRinfo(self, start, end, **kwargs):
index = pd.date_range(start, end, freq=str(self.meas_sampl) + 'S')
# Random control signal
flex_signal = pd.Series(0, index=index)
#price_signal = pd.Series(np.random.rand(len(index))*5,index=index)
if 'use_ref_file' in kwargs:
ref_signal = load_namespace(
kwargs['profile_file']).display_data()['ref_profile']
else:
ref_signal = pd.Series(10000, index=index)
#print(type(ref_signal))
#print(ref_signal)
flex_signal = pd.Series(0, index=index)
if kwargs['DRevent_check'] == 1:
print('%%%%%%%%% DR event triggered %%%%%%%%%%')
for i in index:
if i.hour >= kwargs['DRstart'] and i.hour < kwargs['DRend']:
flex_signal.loc[i] = kwargs['flex_cost']
flex_signal.sort_index()
'''
for i in index:
if i.hour >= 7 and i.hour <= 10:
price_signal[i] = np.random.uniform(0.8,1)*40
if i.hour >= 17 and i.hour <= 23:
price_signal[i] = np.random.uniform(0.8,1)*40
'''
# Create DR event or not
if 'DRevent_check' == 1 and use_ref_file == 0:
print('%%%%%%%%% DR event triggered %%%%%%%%%%')
#index = ref_signal.index.tz_convert(None)
k = pd.Series(1, index=index)
#flex_signal = pd.Series(0,index=index)
#ref_signal.index = index
if kwargs['DRevent_check'] == 1:
for i in index:
if i.hour >= kwargs['DRstart'] and i.hour <= kwargs[
'DRend']:
k.loc[i] = 0.8
print(k)
print('Reference profile before modification:')
print(ref_signal)
# Sort the indices
ref_signal.sort_index()
k.sort_index()
#flex_signal.sort_index()
# Define the reference signal
ref_signal = ref_signal * k * 30
print('Reference profile after modification:')
print(ref_signal)
print('Flex cost:')
print(flex_signal)
#print(price_signal)
# Define control data
'''
self.price.data = {"pi_e": variables.Timeseries('pi_e', price_signal,units.cents_kWh,tz_name=self.weather.tz_name)
}
'''
self.flex_cost.data = {
"flex_cost":
variables.Timeseries('flex_cost',
flex_signal,
units.cents_kWh,
tz_name=self.weather.tz_name)
}
self.ref_profile.data = {
"ref_profile":
variables.Timeseries('ref_profile',
ref_signal,
units.W,
tz_name=self.weather.tz_name)
}
#pheat_max = pd.Series(10000,index=index)
#self.control.collect_data(self.sim_start, self.sim_end)
#print(self.price.display_data())
#print(self.flex_cost.display_data())
#print(self.ref_profile.display_data())
#store_namespace('price_upd_'+self.building,self.price)
store_namespace('flex_cost_upd_' + self.building, self.flex_cost)
store_namespace('ref_profile_upd_' + self.building, self.ref_profile)
os.path.join(Sim.simu_path, 'ibpsa_paper', 'prices',
'sim_price_' + mon))
index = pd.date_range(start,
opt_end_str,
freq=meas_sampl + 'S',
tz=Sim.weather.tz_name)
if dyn_price == 0:
price_signal = pd.Series(stat_cost, index)
Sim.price.data = {
"pi_e":
variables.Timeseries('pi_e',
price_signal,
units.cents_kWh,
tz_name=Sim.weather.tz_name)
}
store_namespace(os.path.join(folder, 'sim_price'), Sim.price)
else:
Sim.weather = Sim_list[i - 2].weather
Sim.ref_profile = Sim_list[i - 2].ref_profile
Sim.flex_cost = Sim_list[i - 2].flex_cost
Sim.price = Sim_list[i - 2].price
Sim.rho = Sim_list[i - 2].rho
Sim.addobj = Sim_list[i - 2].addobj
#Sim.sim_start= '1/1/2017 00:00'
Sim.get_control()
#Sim.sim_start= start
Sim.get_other_input(init_start_str, opt_end_str)
Sim.get_constraints(init_start_str, opt_end_str, upd_control=1)
Sim.param_file = os.path.join(Sim.simu_path, 'csvs',
index = pd.date_range(init_start_str, opt_end_str, freq=meas_sampl + 'S')
SimAggr.price = load_namespace(os.path.join('prices', 'sim_price_' + mon))
if dyn_price == 0:
index = pd.date_range(init_start_str, opt_end_str, freq='1800S')
price_signal = pd.Series(50, index=index)
SimAggr.price.data = {
"pi_e":
variables.Timeseries('pi_e',
price_signal,
units.cents_kWh,
tz_name=SimAggr.weather.tz_name)
}
store_namespace(os.path.join(folder, 'sim_price'), SimAggr.price)
store_namespace(os.path.join(folder, 'params_' + SimAggr.building),
SimAggr.parameters)
store_namespace(os.path.join(folder, 'control_' + SimAggr.building),
SimAggr.control)
store_namespace(os.path.join(folder, 'constraints_' + SimAggr.building),
SimAggr.constraints)
SimAggr.init_models(use_ukf=0, use_fmu_emu=0,
use_fmu_mpc=0) # Use for initialising models
#SimAggr.init_refmodel(use_fmu=1)
# Instantiate Simulator
Emu_list = []
i = 0
