def test_fmi_compile(self):
mopath = os.path.join(self.get_unittest_path(), 'resources', 'model',
'Simple.mo')
modelpath = 'Simple.RC'
for target in ['default', 'cs', 'me']:
if target == 'default':
building = systems.EmulationFromFMU({},
moinfo=(mopath, modelpath,
{}))
self.assertEqual(building.fmu_target, 'me')
model = models.Modelica(models.JModelicaParameter,
models.RMSE, {},
moinfo=(mopath, modelpath, {}))
self.assertEqual(model.fmu_target, 'me')
else:
building = systems.EmulationFromFMU({},
moinfo=(mopath, modelpath,
{}),
target=target)
self.assertEqual(building.fmu_target, target)
model = models.Modelica(models.JModelicaParameter,
models.RMSE, {},
moinfo=(mopath, modelpath, {}),
target=target)
self.assertEqual(model.fmu_target, target)
def setUp(self):
self.parameter_data = {};
self.parameter_data['par'] = {};
self.parameter_data['par']['Value'] = 1;
# instantiate building fmu v1.0
fmupath_1 = os.path.join(self.get_unittest_path(), 'resources', 'building', 'LBNL71T_Emulation_JModelica_v1.fmu');
self.building_1 = systems.EmulationFromFMU({}, fmupath = fmupath_1, parameter_data = self.parameter_data);
# instantiate building fmu v2.0
fmupath_2 = os.path.join(self.get_unittest_path(), 'resources', 'building', 'LBNL71T_Emulation_JModelica_v2.fmu');
self.building_2 = systems.EmulationFromFMU({}, fmupath = fmupath_2, parameter_data = self.parameter_data);
def test_fmi_given(self):
for target in ['1.0', 'me', 'cs']:
if target == '1.0':
fmupath = os.path.join(self.get_unittest_path(), 'resources',
'building',
'LBNL71T_Emulation_JModelica_v1.fmu')
building = systems.EmulationFromFMU({}, fmupath=fmupath)
self.assertEqual(building.fmu_target, None)
else:
fmupath = os.path.join(self.get_unittest_path(), 'resources',
'model',
'Simple_RC_{0}_2.fmu'.format(target))
building = systems.EmulationFromFMU({}, fmupath=fmupath)
self.assertEqual(building.fmu_target, target)
def test_collect_measurements_continue(self):
start_time = '1/1/2015'
final_time = '1/4/2015'
# Collect exodata
self.weather.collect_data(start_time, final_time)
self.internal.collect_data(start_time, final_time)
self.control.collect_data(start_time, final_time)
# Instantiate building source
building = systems.EmulationFromFMU(self.measurements, \
fmupath = self.building_source_file_path, \
zone_names = self.zone_names, \
weather_data = self.weather.data, \
internal_data = self.internal.data, \
control_data = self.control.data, \
parameter_data = self.parameter_data, \
tz_name = self.weather.tz_name)
# Collect measurements in daily chunks
sim_steps = pd.date_range(start_time, final_time, freq=str('1d'))
for i in range(len(sim_steps) - 1):
if i == 0:
building.collect_measurements(sim_steps[i], sim_steps[i + 1])
else:
building.collect_measurements('continue', sim_steps[i + 1])
# Check references
df_test = building.display_measurements('Measured')
self.check_df(
df_test, 'collect_measurements_continue_step{0}.csv'.format(i))
def setUp(self):
self.start_time = '1/1/2017'
self.final_time = '1/10/2017'
# Set measurements
self.measurements = {}
self.measurements['T_db'] = {
'Sample': variables.Static('T_db_sample', 1800, units.s)
}
# Set model paths
mopath = os.path.join(self.get_unittest_path(), 'resources', 'model',
'Simple.mo')
modelpath = 'Simple.RC_nostart'
self.moinfo = (mopath, modelpath, {})
# Gather parameters
parameter_csv_filepath = os.path.join(self.get_unittest_path(),
'resources', 'model',
'SimpleRC_Parameters.csv')
self.parameters = exodata.ParameterFromCSV(parameter_csv_filepath)
self.parameters.collect_data()
# Gather control inputs
control_csv_filepath = os.path.join(self.get_unittest_path(),
'resources', 'model',
'SimpleRC_Input.csv')
variable_map = {
'q_flow_csv': ('q_flow', units.W)
}
self.controls = exodata.ControlFromCSV(control_csv_filepath,
variable_map)
self.controls.collect_data(self.start_time, self.final_time)
# Instantiate system
self.system = systems.EmulationFromFMU(self.measurements, \
moinfo = self.moinfo, \
control_data = self.controls.data)
# Get measurements
self.system.collect_measurements(self.start_time, self.final_time)
def setUp(self):
self.parameter_data = {}
self.parameter_data['par'] = {}
self.parameter_data['par']['Value'] = 1
# instantiate building fmu v1.0
self.building_1 = systems.EmulationFromFMU(
{},
fmupath=utility.get_MPCPy_path() + os.sep + 'resources' + os.sep +
'building' + os.sep + 'LBNL71T_Emulation_JModelica_v1.fmu',
parameter_data=self.parameter_data)
# instantiate building fmu v2.0
self.building_2 = systems.EmulationFromFMU(
{},
fmupath=utility.get_MPCPy_path() + os.sep + 'resources' + os.sep +
'building' + os.sep + 'LBNL71T_Emulation_JModelica_v2.fmu',
parameter_data=self.parameter_data)
def test_collect_measurements_save_parameter_input_data(self):
start_time = '1/1/2015'
final_time = '1/4/2015'
# Collect exodata
self.weather.collect_data(start_time, final_time)
self.internal.collect_data(start_time, final_time)
self.control.collect_data(start_time, final_time)
# Instantiate building source
building = systems.EmulationFromFMU(self.measurements, \
fmupath = self.building_source_file_path, \
zone_names = self.zone_names, \
weather_data = self.weather.data, \
internal_data = self.internal.data, \
control_data = self.control.data, \
parameter_data = self.parameter_data, \
tz_name = self.weather.tz_name,
save_parameter_input_data=True)
# Collect measurements
building.collect_measurements(start_time, final_time)
# Check references
df_test = building.display_measurements('Measured')
self.check_df(df_test, 'collect_measurements_display.csv')
df_test = building.get_base_measurements('Measured')
self.check_df(df_test, 'collect_measurements_base.csv')
# Check parameter and input data was saved
df_test = pd.read_csv('mpcpy_simulation_inputs_system.csv',
index_col='Time')
df_test.index = pd.to_datetime(df_test.index).tz_localize('UTC')
self.check_df(df_test, 'mpcpy_simulation_inputs_system.csv')
df_test = pd.read_csv('mpcpy_simulation_parameters_system.csv',
index_col='parameter')
self.check_df(df_test,
'mpcpy_simulation_parameters_system.csv',
timeseries=False)
def test_fmi_default(self):
building = systems.EmulationFromFMU({},
moinfo=(self.mopath,
self.modelpath, {}))
self.assertEqual(building.fmu_version, '2.0')
model = models.Modelica(models.JModelicaParameter,
models.RMSE, {},
moinfo=(self.mopath, self.modelpath, {}))
self.assertEqual(model.fmu_version, '2.0')
def test_fmi_version(self):
for version in ['1.0', '2.0']:
building = systems.EmulationFromFMU({},
moinfo=(self.mopath,
self.modelpath, {}),
version=version)
self.assertEqual(building.input_names, ['q_flow'])
model = models.Modelica(models.JModelicaParameter,
models.RMSE, {},
moinfo=(self.mopath, self.modelpath, {}),
version=version)
self.assertEqual(model.input_names, ['q_flow'])
def setUp(self):
self.MPCPyPath = utility.get_MPCPy_path();
## Setup building fmu emulation
self.building_source_file_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'building' + os.sep + 'LBNL71T_Emulation_JModelica_v2.fmu';
self.zone_names = ['wes', 'hal', 'eas'];
self.weather_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'weather' + os.sep + 'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw';
self.internal_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'internal' + os.sep + '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.control_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'building' + os.sep + 'ControlCSV_0.csv';
self.control_variable_map = {'conHeat_wes' : ('conHeat_wes', units.unit1), \
'conHeat_hal' : ('conHeat_hal', units.unit1), \
'conHeat_eas' : ('conHeat_eas', units.unit1)};
# 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)};
## Setup model
self.mopath = self.MPCPyPath + os.sep + 'resources' + os.sep + 'model' + os.sep + 'LBNL71T_MPC.mo';
self.modelpath = 'LBNL71T_MPC.MPC';
self.libraries = os.environ.get('MODELICAPATH');
self.estimate_method = models.JModelica;
self.validation_method = models.RMSE;
# Instantiate exo data sources
self.weather = exodata.WeatherFromEPW(self.weather_path);
self.internal = exodata.InternalFromCSV(self.internal_path, self.internal_variable_map, tz_name = self.weather.tz_name);
self.control = exodata.ControlFromCSV(self.control_path, self.control_variable_map, tz_name = self.weather.tz_name);
# Parameters
self.parameters = exodata.ParameterFromCSV(self.MPCPyPath + os.sep + 'resources' + os.sep + 'model' + os.sep + 'LBNL71T_Parameters.csv');
self.parameters.collect_data();
self.parameters.data['lat'] = {};
self.parameters.data['lat']['Value'] = self.weather.lat;
# Instantiate building
building_parameters_data = {};
building_parameters_data['lat'] = {};
building_parameters_data['lat']['Value'] = self.weather.lat;
self.building = systems.EmulationFromFMU(self.measurements, \
fmupath = self.building_source_file_path, \
zone_names = self.zone_names, \
parameter_data = building_parameters_data);
def test_estimate_two_par(self):
'''Test the estimation of two parameters of a model.'''
# Set model paths
mopath = os.path.join(self.get_unittest_path(), 'resources', 'model',
'Simple.mo')
modelpath = 'Simple.RC_noinputs'
# Instantiate system
system = systems.EmulationFromFMU(self.measurements, \
moinfo = (mopath, modelpath, {}))
system.collect_measurements(self.start_time, self.final_time)
# Define parameters
parameter_data = {}
parameter_data['heatCapacitor.C'] = {}
parameter_data['heatCapacitor.C']['Value'] = variables.Static(
'C_Value', 55000, units.J_K)
parameter_data['heatCapacitor.C']['Minimum'] = variables.Static(
'C_Min', 10000, units.J_K)
parameter_data['heatCapacitor.C']['Maximum'] = variables.Static(
'C_Max', 1000000, units.J_K)
parameter_data['heatCapacitor.C']['Free'] = variables.Static(
'C_Free', True, units.boolean)
parameter_data['thermalResistor.R'] = {}
parameter_data['thermalResistor.R']['Value'] = variables.Static(
'R_Value', 0.02, units.K_W)
parameter_data['thermalResistor.R']['Minimum'] = variables.Static(
'R_Min', 0.001, units.K_W)
parameter_data['thermalResistor.R']['Maximum'] = variables.Static(
'R_Max', 0.1, units.K_W)
parameter_data['thermalResistor.R']['Free'] = variables.Static(
'R_Free', True, units.boolean)
# Instantiate model
self.model = models.Modelica(models.JModelica, \
models.RMSE, \
self.measurements, \
moinfo = (mopath, modelpath, {}), \
parameter_data = parameter_data)
# Estimate models
self.model.estimate(self.start_time, self.final_time, ['T_db'])
# Check references
data = [
self.model.parameter_data['heatCapacitor.C']
['Value'].display_data(),
self.model.parameter_data['thermalResistor.R']
['Value'].display_data(),
]
index = ['heatCapacitor.C', 'thermalResistor.R']
df_test = pd.DataFrame(data=data, index=index, columns=['Value'])
self.check_df(df_test, 'estimate_two_par.csv', timeseries=False)
def test_collect_measurements_continue_cs_2(self):
start_time = '1/1/2017'
final_time = '1/2/2017'
# Set measurements
measurements = {}
measurements['T_db'] = {
'Sample': variables.Static('T_db_sample', 1800, units.s)
}
# Set model paths
mopath = os.path.join(self.get_unittest_path(), 'resources', 'model',
'Simple.mo')
modelpath = 'Simple.RC_nostart'
moinfo = (mopath, modelpath, {})
# Gather control inputs
control_csv_filepath = os.path.join(self.get_unittest_path(),
'resources', 'model',
'SimpleRC_Input.csv')
variable_map = {
'q_flow_csv': ('q_flow', units.W)
}
controls = exodata.ControlFromCSV(control_csv_filepath, variable_map)
controls.collect_data(start_time, final_time)
# Instantiate model
building = systems.EmulationFromFMU(measurements, \
moinfo = moinfo, \
control_data = controls.data,
version = '2.0',
target = 'cs')
# Simulate model
building.collect_measurements(start_time, final_time)
# Check references
df_test = building.display_measurements('Simulated')
self.check_df(df_test, 'collect_measurements_display_cs.csv')
# Simulate model in 4-hour chunks
sim_steps = pd.date_range(start_time, final_time, freq=str('8H'))
for i in range(len(sim_steps) - 1):
if i == 0:
building.collect_measurements(sim_steps[i], sim_steps[i + 1])
else:
building.collect_measurements('continue', sim_steps[i + 1])
# Check references
df_test = building.display_measurements('Simulated')
self.check_df(df_test,
'collect_measurements_step_cs{0}.csv'.format(i))
def test_collect_measurements_dst_start(self):
# Test simulation through the start of daylight savings time
start_time = '3/6/2015'
final_time = '3/10/2015'
self.weather.collect_data(start_time, final_time)
self.internal.collect_data(start_time, final_time)
self.control.collect_data(start_time, final_time)
# Instantiate building source
building = systems.EmulationFromFMU(self.measurements, \
fmupath = self.building_source_file_path, \
zone_names = self.zone_names, \
weather_data = self.weather.data, \
internal_data = self.internal.data, \
control_data = self.control.data, \
parameter_data = self.parameter_data, \
tz_name = self.weather.tz_name)
# Collect measurements
building.collect_measurements(start_time, final_time)
# Check references
df_test = building.display_measurements('Measured')
self.check_df(df_test, 'collect_measurements_dst_start.csv')
def test_collect_measurements(self):
start_time = '1/1/2015'
final_time = '1/4/2015'
# Collect exodata
self.weather.collect_data(start_time, final_time)
self.internal.collect_data(start_time, final_time)
self.control.collect_data(start_time, final_time)
# Instantiate building source
building = systems.EmulationFromFMU(self.measurements, \
fmupath = self.building_source_file_path, \
zone_names = self.zone_names, \
weather_data = self.weather.data, \
internal_data = self.internal.data, \
control_data = self.control.data, \
parameter_data = self.parameter_data, \
tz_name = self.weather.tz_name)
# Collect measurements
building.collect_measurements(start_time, final_time)
# Check references
df_test = building.display_measurements('Measured')
self.check_df(df_test, 'collect_measurements_display.csv')
df_test = building.get_base_measurements('Measured')
self.check_df(df_test, 'collect_measurements_base.csv')
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())
