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_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 setUp(self):
csv_filepath = os.path.join(self.get_unittest_path(), 'resources',
'optimization', 'PriceCSV.csv')
variable_map = {
'pi_e': ('pi_e', units.unit1)
}
# Instantiate weather object
self.prices = exodata.PriceFromCSV(csv_filepath, \
variable_map)
def test_set_problem_type(self):
'''Test the dynamic setting of a problem type.
'''
modelpath = 'Simple.RC'
# Instantiate model
parameter_data = {}
parameter_data['heatCapacitor.C'] = {}
parameter_data['heatCapacitor.C']['Free'] = variables.Static(
'C_free', False, units.boolean)
parameter_data['heatCapacitor.C']['Value'] = variables.Static(
'C_value', 3e6, units.boolean)
model = models.Modelica(models.JModelica, \
models.RMSE, \
self.measurements, \
moinfo = (self.mopath, modelpath, {}), \
control_data = self.controls.data, \
parameter_data = parameter_data)
# Instantiate optimization problem
opt_problem = optimization.Optimization(model, \
optimization.EnergyMin, \
optimization.JModelica, \
'q_flow', \
constraint_data = self.constraints.data)
# Solve optimization problem
opt_problem.optimize(self.start_time, self.final_time)
# Update model
model = opt_problem.Model
# Check references
df_test = model.display_measurements('Simulated')
self.check_df_timeseries(df_test, 'optimize_energy.csv')
# Set new problem type
opt_problem.set_problem_type(optimization.EnergyCostMin)
# Gather prices
price_csv_filepath = os.path.join(utility.get_MPCPy_path(),
'resources', 'optimization',
'SimpleRC_Prices.csv')
price_variable_map = {
'energy': ('pi_e', units.unit1)
}
price = exodata.PriceFromCSV(price_csv_filepath, price_variable_map)
price.collect_data(self.start_time, self.final_time)
opt_problem.optimize(self.start_time,
self.final_time,
price_data=price.data)
# Update model
model = opt_problem.Model
# Check references
df_test = model.display_measurements('Simulated')
self.check_df_timeseries(df_test, 'optimize_energycost.csv')
def setUp(self):
## Setup model
self.mopath = os.path.join(self.get_unittest_path(), 'resources',
'model', 'LBNL71T_MPC.mo')
self.modelpath = 'LBNL71T_MPC.MPC'
self.libraries = os.environ.get('MODELICAPATH')
self.estimate_method = models.JModelica
self.validation_method = models.RMSE
self.zone_names = ['wes', 'hal', 'eas']
# Measurements
self.measurements = {}
self.measurements['wesTdb'] = {
'Sample': variables.Static('wesTdb_sample', 1800, units.s)
}
self.measurements['halTdb'] = {
'Sample': variables.Static('halTdb_sample', 1800, units.s)
}
self.measurements['easTdb'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['wesPhvac'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['halPhvac'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['easPhvac'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['Ptot'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
## Exodata
# Exogenous collection time
self.start_time_exodata = '1/1/2015'
self.final_time_exodata = '1/30/2015'
# Optimization time
self.start_time_optimization = '1/2/2015'
self.final_time_optimization = '1/3/2015'
# Weather
self.weather_path = os.path.join(
self.get_unittest_path(), 'resources', 'weather',
'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw')
self.weather = exodata.WeatherFromEPW(self.weather_path)
self.weather.collect_data(self.start_time_exodata,
self.final_time_exodata)
# Internal
self.internal_path = os.path.join(self.get_unittest_path(),
'resources', 'internal',
'sampleCSV.csv')
self.internal_variable_map = {'intRad_wes' : ('wes', 'intRad', units.W_m2), \
'intCon_wes' : ('wes', 'intCon', units.W_m2), \
'intLat_wes' : ('wes', 'intLat', units.W_m2), \
'intRad_hal' : ('hal', 'intRad', units.W_m2), \
'intCon_hal' : ('hal', 'intCon', units.W_m2), \
'intLat_hal' : ('hal', 'intLat', units.W_m2), \
'intRad_eas' : ('eas', 'intRad', units.W_m2), \
'intCon_eas' : ('eas', 'intCon', units.W_m2), \
'intLat_eas' : ('eas', 'intLat', units.W_m2)}
self.internal = exodata.InternalFromCSV(self.internal_path,
self.internal_variable_map,
tz_name=self.weather.tz_name)
self.internal.collect_data(self.start_time_exodata,
self.final_time_exodata)
# Control (as initialization)
self.control_path = os.path.join(self.get_unittest_path(), 'resources',
'optimization', 'ControlCSV.csv')
self.control_variable_map = {'conHeat_wes' : ('conHeat_wes', units.unit1), \
'conHeat_hal' : ('conHeat_hal', units.unit1), \
'conHeat_eas' : ('conHeat_eas', units.unit1)}
self.control = exodata.ControlFromCSV(self.control_path,
self.control_variable_map,
tz_name=self.weather.tz_name)
self.control.collect_data(self.start_time_exodata,
self.final_time_exodata)
# Parameters
self.parameters_path = os.path.join(self.get_unittest_path(),
'outputs', 'model_parameters.txt')
self.parameters = exodata.ParameterFromCSV(self.parameters_path)
self.parameters.collect_data()
# Constraints
self.constraints_path = os.path.join(
self.get_unittest_path(), 'resources', 'optimization',
'sampleConstraintCSV_Constant.csv')
self.constraints_variable_map = {'wesTdb_min' : ('wesTdb', 'GTE', units.degC), \
'wesTdb_max' : ('wesTdb', 'LTE', units.degC), \
'easTdb_min' : ('easTdb', 'GTE', units.degC), \
'easTdb_max' : ('easTdb', 'LTE', units.degC), \
'halTdb_min' : ('halTdb', 'GTE', units.degC), \
'halTdb_max' : ('halTdb', 'LTE', units.degC), \
'der_wesTdb_min' : ('wesTdb', 'dGTE', units.K), \
'der_wesTdb_max' : ('wesTdb', 'dLTE', units.K), \
'der_easTdb_min' : ('easTdb', 'dGTE', units.K), \
'der_easTdb_max' : ('easTdb', 'dLTE', units.K), \
'der_halTdb_min' : ('halTdb', 'dGTE', units.K), \
'der_halTdb_max' : ('halTdb', 'dLTE', units.K), \
'conHeat_wes_min' : ('conHeat_wes', 'GTE', units.unit1), \
'conHeat_wes_max' : ('conHeat_wes', 'LTE', units.unit1), \
'conHeat_hal_min' : ('conHeat_hal', 'GTE', units.unit1), \
'conHeat_hal_max' : ('conHeat_hal', 'LTE', units.unit1), \
'conHeat_eas_min' : ('conHeat_eas', 'GTE', units.unit1), \
'conHeat_eas_max' : ('conHeat_eas', 'LTE', units.unit1)}
self.constraints = exodata.ConstraintFromCSV(
self.constraints_path,
self.constraints_variable_map,
tz_name=self.weather.tz_name)
self.constraints.collect_data(self.start_time_exodata,
self.final_time_exodata)
self.constraints.data['wesTdb']['Cyclic'] = variables.Static(
'wesTdb_cyclic', 1, units.boolean_integer)
self.constraints.data['easTdb']['Cyclic'] = variables.Static(
'easTdb_cyclic', 1, units.boolean_integer)
self.constraints.data['halTdb']['Cyclic'] = variables.Static(
'halTdb_cyclic', 1, units.boolean_integer)
# Prices
self.prices_path = os.path.join(self.get_unittest_path(), 'resources',
'optimization', 'PriceCSV.csv')
self.price_variable_map = {
'pi_e': ('pi_e', units.unit1)
}
self.prices = exodata.PriceFromCSV(self.prices_path,
self.price_variable_map,
tz_name=self.weather.tz_name)
self.prices.collect_data(self.start_time_exodata,
self.final_time_exodata)
## Parameters
self.parameters.data['lat'] = {}
self.parameters.data['lat']['Value'] = self.weather.lat
## Instantiate model
self.model = models.Modelica(self.estimate_method, \
self.validation_method, \
self.measurements, \
moinfo = (self.mopath, self.modelpath, self.libraries), \
zone_names = self.zone_names, \
weather_data = self.weather.data, \
internal_data = self.internal.data, \
control_data = self.control.data, \
parameter_data = self.parameters.data, \
tz_name = self.weather.tz_name)
