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 _get_control_results(self, Optimization): '''Update the control data dictionary in the model with optimization results. ''' fmu_variable_units = self._get_fmu_variable_units() for key in self.Model.control_data.keys(): data = self.res_opt['mpc_model.' + key] time = self.res_opt['time'] timedelta = pd.to_timedelta(time, 's') timeindex = self.start_time_utc + timedelta ts = pd.Series(data=data, index=timeindex) ts.name = key unit = self._get_unit_class_from_fmu_variable_units( 'mpc_model.' + key, fmu_variable_units) if not unit: unit = units.unit1 Optimization.Model.control_data[key] = variables.Timeseries( key, ts, unit) for key in Optimization.Model.measurements.keys(): data = self.res_opt['mpc_model.' + key] time = self.res_opt['time'] timedelta = pd.to_timedelta(time, 's') timeindex = self.start_time_utc + timedelta ts = pd.Series(data=data, index=timeindex) ts.name = key unit = self._get_unit_class_from_fmu_variable_units( 'mpc_model.' + key, fmu_variable_units) if not unit: unit = units.unit1 Optimization.Model.measurements[key][ 'Simulated'] = variables.Timeseries(key, ts, unit)
def test_display_time_zone(self): '''Test that the default time zone is UTC.''' # Time zone by tz_name self.var = variables.Timeseries('var1', self.dataC_pd, units.degC) for i in range(len(self.dataC)): self.assertEqual(self.var.get_base_data().index[i], self.time[i].tz_localize('UTC')) self.assertEqual(self.var.display_data().index[i], self.time[i].tz_localize('UTC')) self.var = variables.Timeseries('var1', self.dataC_pd, units.degC, tz_name='America/Los_Angeles') for i in range(len(self.dataC)): self.assertEqual( self.var.get_base_data().index[i], self.time[i].tz_localize('UTC') + relativedelta(hours=8)) self.assertEqual( self.var.display_data().index[i], self.time[i].tz_localize('UTC') + relativedelta(hours=8)) # Time zone by geography self.var = variables.Timeseries('var1', self.dataC_pd, units.degC, geography=[41.8781, -87.6298]) for i in range(len(self.dataC)): self.assertEqual( self.var.get_base_data().index[i], self.time[i].tz_localize('UTC') + relativedelta(hours=6)) self.assertEqual( self.var.display_data().index[i], self.time[i].tz_localize('UTC') + relativedelta(hours=6))
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 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_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_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 _simulate_fmu(self): '''Simulate an fmu with pyfmi and using any given exodata inputs. Yields ------ measurements[key]['Simulated'] : variables.Timeseries Populates the `Simulated` key of the ``measurements`` dictionary attribute with mpcpy timeseries variables. ''' # Create input_mpcpy_ts_list self._create_input_mpcpy_ts_list_sim(); # Set inputs self._create_input_object_from_input_mpcpy_ts_list(self._input_mpcpy_ts_list); # Get simulation options self._sim_opts = self.fmu.simulate_options(); # Set simulation fmu with start if self._continue: # Continue fmu self._sim_opts['initialize'] = False; else: # Load fmu self.fmu.reset(); # Set start/final time start_time = self.total_elapsed_seconds - self.elapsed_seconds; final_time = self.total_elapsed_seconds; # Set parameters in fmu if they exist if hasattr(self, 'parameter_data'): for key in self.parameter_data.keys(): self.fmu.set(key, self.parameter_data[key]['Value'].get_base_data()); # Get minimum measurement sample rate for simulation min_sample = 3600; for key in self.measurements.keys(): sample = self.measurements[key]['Sample'].get_base_data(); if sample < min_sample: min_sample = sample; # Set sample rate for simulation self._sim_opts['ncp'] = int(self.elapsed_seconds/min_sample); # Set cvode solver tolerance if model exchange fmu if self.fmu_target is 'me': self._sim_opts['CVode_options']['rtol'] = 1e-6; # Simulate self._res = self.fmu.simulate(start_time = start_time, \ final_time = final_time, \ input = self._input_object, \ options = self._sim_opts); # Retrieve measurements fmu_variable_units = self._get_fmu_variable_units(); for key in self.measurements.keys(): data = self._res[key]; time = self._res['time']; timedelta = pd.to_timedelta(time-time[0], 's'); timeindex = self.start_time_utc + timedelta; ts = pd.Series(data = data, index = timeindex); ts.name = key; unit = self._get_unit_class_from_fmu_variable_units(key,fmu_variable_units); if not unit: unit = units.unit1; self.measurements[key]['Simulated'] = variables.Timeseries(key, ts, unit);
def test_replace(self): '''Replace 'calm' with 0.5 mph in timeseries variable.''' self.var = variables.Timeseries('var', self.ts_calm, units.mph, \ cleaning_type = variables.Timeseries.cleaning_replace, cleaning_args = ('calm',0.5)); self.assertAlmostEqual(self.var.get_base_data().get_values()[2], 0.22352, places = 3); self.assertAlmostEqual(self.var.display_data().get_values()[2], 0.5, places = 3);
def _dataframe_to_mpcpy_ts_variable(self, df, key, varname, unit, **kwargs): '''Convert dataframe column to mpcpy timeseries variable. Parameters ---------- df : ``pandas`` dataframe object Dataframe with a datetime index. key : string Column name to convert to mpcpy timeseries variable. varname : string Variable name to assign to mpcpy timeseries variable. unit : units.unit class Unit to assign to mpcpy timeseries variable cleaning_type : variables.Timseries.cleaning_type class, optional Cleaning to be done to the data. cleaning_args : tuple, required if cleaning_type Arguments of the cleaning type. Returns ------- var : variables.Timeseries mpcpy timeseries variable resulting from the dataframe column. ''' if 'start_time' in kwargs: start_time = kwargs['start_time'] else: start_time = df.index.values[0] if 'final_time' in kwargs: final_time = kwargs['final_time'] else: final_time = df.index.values[-1] if 'cleaning_type' in kwargs: cleaning_type = kwargs['cleaning_type'] cleaning_args = kwargs['cleaning_args'] var = variables.Timeseries(varname, df.loc[start_time:final_time, key], unit, tz_name = self.tz_name, \ cleaning_type = cleaning_type, \ cleaning_args = cleaning_args) else: var = variables.Timeseries(varname, df.loc[start_time:final_time, key], unit, tz_name=self.tz_name) return var
def setUp(self): '''Instantiate timeseries variables.''' self.dataC = np.array([20, 21, 22, 23, 24, 25]) self.start = pd.datetime(2016, 1, 1, 0) self.end = pd.datetime(2016, 1, 1, 5) self.time = pd.date_range(self.start, self.end, freq='H') self.dataC_pd = pd.Series(data=self.dataC, index=self.time) self.e = variables.Timeseries('e', self.dataC_pd, units.degC)
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 setUp(self): '''Instantiate timeseries variable.''' self.dataC = np.array([20,21,22,23,24,25]); self.dataF = np.array([72,73,74,75,76,77]); self.start = pd.datetime(2016, 1, 1, 0); self.end = pd.datetime(2016, 1, 1, 5); self.time = pd.date_range(self.start, self.end, freq='H'); self.dataC_pd = pd.Series(data = self.dataC, index = self.time); self.dataF_pd = pd.Series(data = self.dataF, index = self.time); self.var = variables.Timeseries('var1', self.dataC_pd, units.degC);
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 _simulate_fmu(self): '''Simulate an fmu using pyfmi. Yields ------ measurements[key]['Simulated'] : variables.Timeseries Populates the `Simulated` key of the ``measurements`` dictionary attribute with mpcpy timeseries variables. ''' # Create input_mpcpy_ts_list self._create_input_mpcpy_ts_list_sim() # Set inputs self._create_input_object_from_input_mpcpy_ts_list( self._input_mpcpy_ts_list) # Load simulation fmu simulate_model = load_fmu(self.fmupath) # Set parameters in fmu if they exist if hasattr(self, 'parameter_data'): for key in self.parameter_data.keys(): simulate_model.set( key, self.parameter_data[key]['Value'].get_base_data()) # Get minimum measurement sample rate for simulation min_sample = 3600 for key in self.measurements.keys(): sample = self.measurements[key]['Sample'].get_base_data() if sample < min_sample: min_sample = sample # Set Options self._sim_opts = simulate_model.simulate_options() self._sim_opts['ncp'] = int(self.elapsed_seconds / min_sample) # Simulate self._res = simulate_model.simulate(start_time = 0, \ final_time = self.elapsed_seconds, \ input = self._input_object, \ options = self._sim_opts) # Retrieve measurements fmu_variable_units = self._get_fmu_variable_units() for key in self.measurements.keys(): data = self._res[key] time = self._res['time'] timedelta = pd.to_timedelta(time, 's') timeindex = self.start_time_utc + timedelta ts = pd.Series(data=data, index=timeindex) ts.name = key unit = self._get_unit_class_from_fmu_variable_units( key, fmu_variable_units) if not unit: unit = units.unit1 self.measurements[key]['Simulated'] = variables.Timeseries( key, ts, unit)
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 init_refmodel(self, use_fmu, use_const, const_path): print("%%%---Initialising Reference Simulation---%%%") # Define control profile for reference self.control_ref = 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_ref) + 'S') if use_const == 1: t_set = load_namespace( os.path.join(const_path, 'constraints_' + self.building) ).data['TAir']['Slack_GTE'].get_base_data() + 1.0 else: t_set = pd.Series(20 + 273.15, index=index) for i in index: if i.hour >= 6 and i.hour <= 9: t_set[i] = 20 + 273.15 if i.hour >= 17 and i.hour <= 23: t_set[i] = 20 + 273.15 # Define control data self.control_ref.data = { "SetPoint": variables.Timeseries('SetPoint', t_set, units.K, tz_name=self.weather.tz_name) } if use_fmu == 0: self.emuref = systems.EmulationFromFMU( self.meas_vars_ref, moinfo=self.moinfo_emu_ref, weather_data=self.weather.data, control_data=self.control_ref.data, other_inputs=self.other_input.data, tz_name=self.weather.tz_name) else: self.emuref = systems.EmulationFromFMU( self.meas_vars_ref, fmupath=self.fmupath_ref, weather_data=self.weather.data, control_data=self.control_ref.data, other_inputs=self.other_input.data, tz_name=self.weather.tz_name)
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 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)
if i == 1: Sim.update_weather(init_start_str, opt_end_str) Sim.get_DRinfo(init_start_str, opt_end_str) Sim.price = load_namespace( 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)
bldg_other_input = load_namespace(os.path.join(SimAggr.simu_path, 'mincost vs minene', 'minene_opt results', 'other_input_'+bldg+'_R2CW')) bldg_constraints = load_namespace(os.path.join(SimAggr.simu_path, 'mincost vs minene', 'minene_opt results', 'constraints_'+bldg+'_R2CW')) model_name = bldg+'_R2CW' #print(SimAggr.start_temp) for key in bldg_params: SimAggr.update_params(model_name+'.heatCapacitor.T.start',SimAggr.start_temp,unit=units.degC) SimAggr.update_params(model_name+'.heatCapacitor1.T.start',SimAggr.start_temp, unit=units.degC) SimAggr.update_params(model_name+'.'+key, bldg_params[key]['Value'].data, unit=bldg_params[key]['Value'].get_display_unit()) #print(SimAggr.parameters.display_data()) for key in bldg_control.data: SimAggr.control.data[key+'_'+bldg] = variables.Timeseries( name = key+'_'+bldg, timeseries = pd.Series(np.random.rand(len(index))*3000,index=index), display_unit = bldg_control.data[key].get_display_unit(), tz_name = SimAggr.weather.tz_name ) for key in bldg_other_input.data: SimAggr.other_input.data[model_name+'.'+key] = variables.Timeseries( name = model_name+'.'+key, timeseries = bldg_other_input.display_data().loc[index][key], display_unit = bldg_other_input.data[key].get_display_unit(), tz_name = SimAggr.weather.tz_name ) for key in bldg_constraints.data: if key == 'ConvGain2': SimAggr.constraints.data[key+'_'+bldg] = {}
def _writeukfcsv(self, Model): '''Write the UKF csv file. ''' # Collect additional inputs for csv file self._additional_inputs = {}; # Measurements for key_mea in Model.measurement_variable_list: variable = Model.measurements[key_mea]; self._additional_inputs[key_mea] = {}; self._additional_inputs[key_mea] = variable['Measured']; # Parameters free_parameters = []; for key_par in Model.parameter_data.keys(): variable = Model.parameter_data[key_par]; if variable['Free'].get_base_data(): free_parameters.append(key_par) time = self._additional_inputs[key_mea].get_base_data().index.values; data = variable['Value'].get_base_data()*np.ones(len(time)); unit = variable['Value'].get_base_unit(); ts = pd.Series(index = time, data = data) self._additional_inputs[key_par] = variables.Timeseries(key_par+'_ukf', ts, unit); # Create mpcpy ts list self._input_mpcpy_ts_list = []; # Weather for key in Model.weather_data.keys(): if key in Model.input_names: self._input_mpcpy_ts_list.append(Model.weather_data[key]); # Internal for zone in Model.internal_data.keys(): for intLoad in ['intCon', 'intRad', 'intLat']: if intLoad+'_'+zone in Model.input_names: self._input_mpcpy_ts_list.append(Model.internal_data[zone][intLoad]); # Controls for key in Model.control_data.keys(): if key in Model.input_names: self._input_mpcpy_ts_list.append(Model.control_data[key]); # Other inputs for key in Model.other_inputs.keys(): if key in Model.input_names: self._input_mpcpy_ts_list.append(Model.other_inputs[key]); # Add measurements and parameters for key in self._additional_inputs.keys(): self._input_mpcpy_ts_list.append(self._additional_inputs[key]); # Create input object to write to csv # Set timing self.start_time_utc = Model.start_time_utc; self.final_time_utc = Model.final_time_utc; self._global_start_time_utc = Model._global_start_time_utc self.elapsed_seconds = Model.elapsed_seconds; self.total_elapsed_seconds = Model.total_elapsed_seconds; self._create_input_object_from_input_mpcpy_ts_list(self._input_mpcpy_ts_list) # Write to csv self.csv_path = 'ukf.csv'; with open(self.csv_path, 'wb') as f: ukfwriter = csv.writer(f); ukfwriter.writerow(['time'] + list(self._input_object[0])); for i in range(len(self._input_object[1][:,0])): ukfwriter.writerow(self._input_object[1][i]);
def _simulate(self, Model): '''Use Monte Carlo simulation to predict an occupancy timeseries. ''' # Set the number of simulations for the Monte Carlo iter_num = self.simulate_options['iter_num']; # Initialize variables ts_pred = pd.Series(); ts_std = pd.Series(); d = 0; # Get weekdays of simulation time period date_range = pd.date_range(Model.start_time, Model.final_time, freq = 'D'); # Monte Carlo simulate each day of the simulation time period for day in date_range.weekday: seg_point_added = np.concatenate((np.array([0]),self.seg_point[day], np.array([self.points_per_day]))) lam_vec = np.empty((self.points_per_day,)) lam_vec[:] = np.NAN mu_vec = np.empty((self.points_per_day,)) mu_vec[:] = np.NAN jmptimes_mc = [None]*iter_num # create an empty list of size iter_num syssize_mc = np.empty((self.points_per_day,iter_num)) syssize_mc[:] = np.NAN time_int = np.arange(self.points_per_day) nstart = 0 for i in range(len(seg_point_added)-1): lam = Model.parameters_data['lam'][day]['Value'].get_base_data()[i]; mu = Model.parameters_data['mu'][day]['Value'].get_base_data()[i]; lam_vec[seg_point_added[i]:seg_point_added[i+1]] = lam; mu_vec[seg_point_added[i]:seg_point_added[i+1]] = mu; for iter_idx in range(iter_num): jmptimes, syssize = simulate_queue(self.points_per_day, lam_vec, mu_vec, nstart, self.empty_time[day]) if syssize is None: jmptimes_mc[iter_idx] = None syssize_mc[:, iter_idx] = np.zeros((self.points_per_day,)) continue if np.any(syssize <0): pdb.set_trace() raise ValueError('negative syssize') if jmptimes is None: jmptimes_mc[iter_idx] = 0 syssize_mc[:, iter_idx] = 0 else: # round jmptimes to the nearest integer jmptimes_d, ia = unique_last(np.round(jmptimes)) syssize_d = syssize[ia] if jmptimes_d[0] != 0: jmptimes_int = np.insert(jmptimes_d, 0, 0) syssize_int = np.insert(syssize_d, 0, 0) else: jmptimes_int = jmptimes_d syssize_int = syssize_d vq = interp1(jmptimes_int, syssize_int, time_int) jmptimes_mc[iter_idx] = jmptimes_d syssize_mc[:, iter_idx] = vq prediction = np.mean(syssize_mc, axis=1); std = np.std(syssize_mc, axis=1); # Convert current prediction to pandas timeseries start_time = pd.datetime(Model.start_time.year,Model.start_time.month, Model.start_time.day)+timedelta(days=d); final_time = start_time+timedelta(days=1)-timedelta(seconds = Model.measurements[self.occ_key]['Sample'].get_base_data()); freq = str(int(Model.measurements[self.occ_key]['Sample'].get_base_data()))+'s'; index = pd.date_range(start_time, final_time, freq = freq); ts_pred_new = pd.Series(data = prediction, index = index); ts_std_new = pd.Series(data = std, index = index); # Join current day's prediction to past predictions ts_pred = pd.concat((ts_pred, ts_pred_new), axis = 0); ts_std = pd.concat((ts_std, ts_std_new), axis = 0); # Increment the day counter d = d + 1; # Store simulation results in Model measurement dictionary unit = Model.measurements[self.occ_key]['Measured'].get_base_unit(); Model.measurements[self.occ_key]['Simulated'] = variables.Timeseries('prediction', ts_pred, unit); Model.measurements[self.occ_key]['SimulatedError'] = variables.Timeseries('prediction', ts_std, unit);
Sim.moinfo_emu_ref = (os.path.join(Sim.mod_path, community, bldg,bldg+'_Models',bldg+'_House_PI.mo'), community+'.'+bldg+'.'+bldg+'_Models.'+bldg+'_House_PI', {} ) # Initialise exogenous data sources if i == 1: Sim.update_weather(init_start_str, opt_end_str) Sim.get_DRinfo(init_start_str,opt_end_str) index = pd.date_range(start, opt_end_str, freq = meas_sampl+'S', tz=Sim.weather.tz_name) Sim.price = load_namespace(os.path.join(Sim.simu_path, 'JournalPaper', 'drcases', 'decentr_costmin_30bldgs_'+mon, 'sim_price')) 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
def param_estimation(model_param, ADD_UNIT_EP_TZONE): # Simulation settings estimation_start_time = model_param['estimation_start_time'] estimation_stop_time = model_param['estimation_stop_time'] validation_start_time = model_param['validation_start_time'] validation_stop_time = model_param['validation_stop_time'] pat_wea = model_param['wea'] variable_map = eval(model_param['var_map']) con_fil = model_param['con_fil'] obs_var = model_param['obs_var'] step_size = model_param['emulator_step_size'] fmu_path = model_param['fmu_path'] param_fil = model_param['param_fil'] moinfo = model_param['rc_param'] # Setup for running the weather FMU weather = exodata.WeatherFromEPW(pat_wea) control = exodata.ControlFromCSV(con_fil, variable_map, tz_name=weather.tz_name) # Running the weather data FMU weather.collect_data(estimation_start_time, estimation_stop_time) # Collecting the data from the CSV file control.collect_data(estimation_start_time, estimation_stop_time) # Setting up parameters for emulator model (EnergyPlusFMU) from mpcpy import systems measurements = {obs_var: {}} measurements[obs_var]['Sample'] = variables.Static('sample_rate_Tzone', step_size, units.s) fmupath = fmu_path print("=========Run emulation model with FMU={!s}".format(fmu_path)) emulation = systems.EmulationFromFMU(measurements, fmupath=fmu_path, control_data=control.data, tz_name=weather.tz_name) # Running the emulator EnergyPlus FMU emulation.collect_measurements(estimation_start_time, estimation_stop_time) # Add units to EnergyPlus output variables if ((ADD_UNIT_EP_TZONE == True) and obs_var == 'Tzone'): print( "==========WARNING: When using E+FMU, if the output of E+ is the " "zone temperature, then the next lines will add the unit degC to the " "output results. This is only valid for E+ and an output which is Tzone." ) data = measurements[obs_var]["Measured"].display_data() name = measurements[obs_var]["Measured"].name # Set new variable with same data and name and units degC measurements[obs_var]["Measured"] = variables.Timeseries( name, data, units.degC) from mpcpy import models parameters = exodata.ParameterFromCSV(param_fil) parameters.collect_data() parameters.display_data() # Defning model to be use for parameter estimation model = models.Modelica(models.JModelica, models.RMSE, emulation.measurements, moinfo=moinfo, parameter_data=parameters.data, weather_data=weather.data, control_data=control.data, tz_name=weather.tz_name) #print("=========Simulate model with default parameters={!s}".format(moinfo)) #model.simulate('1/1/2017', '1/2/2017') #model.parameter_data['zone.T0']['Value'].set_data(model.get_base_measurements('Measured')['Tzone'].loc[start_time_est_utc]) #model.display_measurements('Simulated') print("=========Run parameter estimation for model={!s}".format(moinfo)) print("=========Start time={!s}, Stop time={!s}, Observed variable={!s}". format(estimation_start_time, estimation_stop_time, obs_var)) model.estimate(estimation_start_time, estimation_stop_time, [obs_var]) # Validate the estimation model by comparing measured vs. simulated data # IMPORTANT: The accuracy of the validation depends on the initial temperature set # in the Modelica models. A parameter T0 is defined to set the initial # temperatures of the room air or internal mass. this should be set to # to the initial temperatures measured from the emulator. model.validate(validation_start_time, validation_stop_time, 'validate_tra', plot=1) print("The Root Mean Square Error={!s}".format( model.RMSE['Tzone'].display_data())) # Printing simulation results for key in model.parameter_data.keys(): print(key, model.parameter_data[key]['Value'].display_data())
os.path.join(SimAggr.simu_path, 'ibpsa_paper', 'decentr_enemin_' + mon, 'other_input_' + bldg + '_' + model_id)) bldg_constraints = load_namespace( os.path.join(SimAggr.simu_path, 'ibpsa_paper', 'decentr_enemin_' + mon, 'constraints_' + bldg + '_' + model_id)) model_name = bldg + '_' + model_id pheat_min = pd.Series(0, index=index) pheat_max = pd.Series(1, index=index) bldg_constraints.data['HPPower'] = { 'GTE': variables.Timeseries('HPPower_GTE', pheat_min, units.W, tz_name=SimAggr.weather.tz_name), 'LTE': variables.Timeseries('HPPower_LTE', pheat_max, units.W, tz_name=SimAggr.weather.tz_name) } #print(SimAggr.start_temp) for key in bldg_params: SimAggr.parameters.data[model_name + '.' + key] = { 'Free': variables.Static('FreeOrNot', bldg_params[key]['Free'].data, units.boolean), 'Minimum':
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)
opt_end_str, freq=meas_sampl + 'S', tz=Sim.weather.tz_name) Sim.price = load_namespace( os.path.join(Sim.simu_path, 'JournalPaper', 'drcases', 'decentr_costmin_30bldgs_' + mon, 'sim_price')) load_profile_aggr = pd.Series(0, index) 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()
def _get_control_results(self, Optimization, **kwargs): '''Update the model control_data and optimization measurements. Also add the opt_input object as attribute to Optimization. ''' # Determine time interval if 'res_control_step' in kwargs: s_start = self.res_opt['time'][0] s_final = self.res_opt['time'][-1] res_control_step = kwargs['res_control_step'] time = np.linspace(s_start, s_final, (s_final - s_start) / res_control_step + 1) else: time = self.res_opt['time'] # Get fmu variables units fmu_variable_units = self._get_fmu_variable_units() # Update model control data for key in self.Model.control_data.keys(): # Get optimal control data opt_input = self.res_opt.get_opt_input() opt_input_traj = opt_input[1] i = opt_input[0].index(key) data = [] # Create data for t in time: data.append(opt_input_traj(t)[i]) timedelta = pd.to_timedelta(time, 's') timeindex = self._global_start_time_utc + timedelta ts_opt = pd.Series(data=data, index=timeindex).tz_localize('UTC') # Get old control data ts_old = self.Model.control_data[key].get_base_data() # Remove rows with updated data first = (ts_old.index == self.start_time_utc).tolist().index(True) if ts_old.index[-1] >= self.final_time_utc: # If final time is before end of timeseries, replace only # specific location last = ( ts_old.index == self.final_time_utc).tolist().index(True) drop_list = ts_old.index[first:last + 1] else: # If final time is after end of timeseries, add control to end drop_list = ts_old.index[first:] ts_old = ts_old.drop(drop_list) # Append opt to old ts = ts_old.append(ts_opt) # Sort by index ts = ts.sort_index() # Update control_data ts.name = key unit = self._get_unit_class_from_fmu_variable_units( 'mpc_model.' + key, fmu_variable_units) if not unit: unit = units.unit1 self.Model.control_data[key] = variables.Timeseries(key, ts, unit) # Get opt input object tuple (names, collocation polynomials f(t)) Optimization.opt_input = opt_input # Create optimization measurement dictionary Optimization.measurements = {} for key in Optimization.Model.measurements.keys(): # Add optimization results data Optimization.measurements[key] = {} data = self.res_opt['mpc_model.' + key] time = self.res_opt['time'] timedelta = pd.to_timedelta(time, 's') timeindex = self._global_start_time_utc + timedelta ts_opt = pd.Series(data=data, index=timeindex).tz_localize('UTC') # Get old measurement data ts_old = self.Model.measurements[key]['Simulated'].get_base_data() # Remove rows with updated data first = (ts_old.index == self.start_time_utc).tolist().index(True) last = (ts_old.index == self.final_time_utc).tolist().index(True) drop_list = ts_old.index[first:last + 1] ts_old = ts_old.drop(drop_list) # Append opt to old ts = ts_old.append(ts_opt) # Sort by index ts = ts.sort_index() # Update control_data ts.name = key unit = self._get_unit_class_from_fmu_variable_units( 'mpc_model.' + key, fmu_variable_units) if not unit: unit = units.unit1 Optimization.measurements[key]['Simulated'] = variables.Timeseries( key, ts, unit)
) Sim.moinfo_emu_ref = (os.path.join(Sim.mod_path, community, bldg,bldg+'_Models',bldg+'_House_PI.mo'), community+'.'+bldg+'.'+bldg+'_Models.'+bldg+'_House_PI', {} ) # Initialise exogenous data sources if i == 1: Sim.update_weather(init_start_str, opt_end_str) Sim.get_DRinfo(init_start_str,opt_end_str) 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