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
