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