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())