def test_estimate_one_par(self): '''Test the estimation of one parameter 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) # 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() ] index = ['heatCapacitor.C'] df_test = pd.DataFrame(data=data, index=index, columns=['Value']) self.check_df(df_test, 'estimate_one_par.csv', timeseries=False)
def test_set_parameters(self): '''Test the dynamic setting of parameters. ''' modelpath = 'Simple.RC'; # Instantiate model parameter_data = {'heatCapacitor.C' : {'Free' : variables.Static('C_free', False, units.boolean), \ 'Value' : variables.Static('C_new', 1e5, units.J_K)}, \ 'To' : {'Free' : variables.Static('To_free', False, units.boolean), \ 'Value' : variables.Static('To', 24, units.degC)}}; 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); # Check references df_test = opt_problem.display_measurements('Simulated'); self.check_df(df_test, 'optimize_set_parameters_1.csv'); # Set new parameters of model parameter_data['heatCapacitor.C']['Value'] = variables.Static('C_new', 1e7, units.J_K); parameter_data['To']['Value'] = variables.Static('To', 22, units.degC); opt_problem.Model.parameter_data = parameter_data; # Solve optimization problem opt_problem.optimize(self.start_time, self.final_time); # Check references df_test = opt_problem.display_measurements('Simulated'); self.check_df(df_test, 'optimize_set_parameters_2.csv');
def test_estimate_and_validate(self): '''Test the estimation of a model's coefficients based on measured data.''' # Instantiate model self.model = models.Modelica(models.UKF, \ models.RMSE, \ self.system.measurements, \ moinfo = self.moinfo, \ parameter_data = self.parameters.data, \ control_data = self.controls.data, \ version = '1.0') # Estimate self.model.estimate(self.start_time, self.final_time, ['T_db']) # Validate self.model.validate(self.start_time, self.final_time, 'validate', plot=0) # Check references RMSE = {} for key in self.model.RMSE.keys(): RMSE[key] = {} RMSE[key]['Value'] = self.model.RMSE[key].display_data() df_test = pd.DataFrame(data=RMSE) self.check_df(df_test, 'validate_RMSE.csv', timeseries=False)
def test_estimate_and_validate(self): '''Test the estimation of a model's coefficients based on measured data.''' plt.close('all') # Exogenous collection time self.start_time_exodata = '1/1/2015' self.final_time_exodata = '1/30/2015' # Emulation time self.start_time_emulation = '1/1/2015' self.final_time_emulation = '1/4/2015' # Estimation time self.start_time_estimation = '1/1/2015' self.final_time_estimation = '1/4/2015' # Validation time self.start_time_validation = '1/4/2015' self.final_time_validation = '1/5/2015' # Measurement variables for estimate self.measurement_variable_list = ['wesTdb', 'easTdb', 'halTdb'] # Exodata self.weather.collect_data(self.start_time_exodata, self.final_time_exodata) self.internal.collect_data(self.start_time_exodata, self.final_time_exodata) self.control.collect_data(self.start_time_exodata, self.final_time_exodata) # Set exodata to building emulation self.building.weather_data = self.weather.data self.building.internal_data = self.internal.data self.building.control_data = self.control.data self.building.tz_name = self.weather.tz_name # Collect measurement data self.building.collect_measurements(self.start_time_emulation, self.final_time_emulation) # Instantiate model self.model = models.Modelica(self.estimate_method, \ self.validation_method, \ self.building.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) # Estimate model based on emulated data self.model.estimate(self.start_time_estimation, self.final_time_estimation, self.measurement_variable_list) # Check references df_test = self.model.display_measurements('Simulated') self.check_df_timeseries(df_test, 'simulate_estimated_parameters.csv') # Validate on validation data self.building.collect_measurements(self.start_time_validation, self.final_time_validation) self.model.measurements = self.building.measurements self.model.validate(self.start_time_validation, self.final_time_validation, \ os.path.join(self.MPCPyPath, 'unittests', 'resources', 'model_validation')) # Check references RMSE = {} for key in self.model.RMSE.keys(): RMSE[key] = {} RMSE[key]['Value'] = self.model.RMSE[key].display_data() df_test = pd.DataFrame(data=RMSE) self.check_df_general(df_test, 'validate_RMSE.csv')
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.JModelica, models.RMSE, {}, moinfo = (self.mopath, self.modelpath, {}), version = version); self.assertEqual(model.input_names, ['q_flow']);
def test_fmi_default(self): building = systems.EmulationFromFMU({}, moinfo = (self.mopath, self.modelpath, {})); self.assertEqual(building.fmu_version, '2.0'); model = models.Modelica(models.JModelica, models.RMSE, {}, moinfo = (self.mopath, self.modelpath, {})); self.assertEqual(model.fmu_version, '2.0');
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())
def setUp(self): ## Setup building fmu emulation self.building_source_file_path_est = os.path.join( self.get_unittest_path(), 'resources', 'building', 'RealMeasurements_est.csv') self.building_source_file_path_val = os.path.join( self.get_unittest_path(), 'resources', 'building', 'RealMeasurements_val.csv') self.building_source_file_path_val_missing = os.path.join( self.get_unittest_path(), 'resources', 'building', 'RealMeasurements_val_missing.csv') self.zone_names = ['wes', 'hal', 'eas'] self.weather_path = os.path.join( self.get_unittest_path(), 'resources', 'weather', 'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw') 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.control_path = os.path.join(self.get_unittest_path(), 'resources', 'building', '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) } self.measurement_variable_map = { 'wesTdb_mea': ('wesTdb', units.K), 'halTdb_mea': ('halTdb', units.K), 'easTdb_mea': ('easTdb', units.K), 'wesPhvac_mea': ('wesPhvac', units.W), 'halPhvac_mea': ('halPhvac', units.W), 'easPhvac_mea': ('easPhvac', units.W), 'Ptot_mea': ('Ptot', units.W) } ## 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 # 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( os.path.join(self.get_unittest_path(), 'resources', 'model', 'LBNL71T_Parameters.csv')) self.parameters.collect_data() self.parameters.data['lat'] = {} self.parameters.data['lat']['Value'] = self.weather.lat # Instantiate test building self.building_est = systems.RealFromCSV( self.building_source_file_path_est, self.measurements, self.measurement_variable_map, tz_name=self.weather.tz_name) # Exogenous collection time self.start_time_exodata = '1/1/2015' self.final_time_exodata = '1/30/2015' # Estimation time self.start_time_estimation = '1/1/2015' self.final_time_estimation = '1/4/2015' # Validation time self.start_time_validation = '1/4/2015' self.final_time_validation = '1/5/2015' # Measurement variables for estimate self.measurement_variable_list = ['wesTdb', 'easTdb', 'halTdb'] # Exodata self.weather.collect_data(self.start_time_exodata, self.final_time_exodata) self.internal.collect_data(self.start_time_exodata, self.final_time_exodata) self.control.collect_data(self.start_time_exodata, self.final_time_exodata) # Collect measurement data self.building_est.collect_measurements(self.start_time_estimation, self.final_time_estimation) # Instantiate model self.model = models.Modelica(self.estimate_method, \ self.validation_method, \ self.building_est.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) # Simulate model with initial guess self.model.simulate(self.start_time_estimation, self.final_time_estimation)
def test_estimate_and_validate(self): '''Test the estimation of a model's coefficients based on measured data.''' plt.close('all') # Exogenous collection time self.start_time_exodata = '1/1/2015' self.final_time_exodata = '1/30/2015' # Estimation time self.start_time_estimation = '1/1/2015' self.final_time_estimation = '1/4/2015' # Validation time self.start_time_validation = '1/4/2015' self.final_time_validation = '1/5/2015' # Measurement variables for estimate self.measurement_variable_list = ['wesTdb', 'easTdb', 'halTdb'] # Exodata self.weather.collect_data(self.start_time_exodata, self.final_time_exodata) self.internal.collect_data(self.start_time_exodata, self.final_time_exodata) self.control.collect_data(self.start_time_exodata, self.final_time_exodata) # Set exodata to building emulation self.building.weather_data = self.weather.data self.building.internal_data = self.internal.data self.building.control_data = self.control.data self.building.tz_name = self.weather.tz_name # Collect measurement data self.building.collect_measurements(self.start_time_estimation, self.final_time_estimation) # Instantiate model self.model = models.Modelica(self.estimate_method, \ self.validation_method, \ self.building.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, save_parameter_input_data=True) # Simulate model with initial guess self.model.simulate(self.start_time_estimation, self.final_time_estimation) # Check references df_test = self.model.display_measurements('Simulated') self.check_df(df_test, 'simulate_initial_parameters.csv') # Check parameter and input data were saved df_test = pd.read_csv('mpcpy_simulation_inputs_model.csv', index_col='Time') df_test.index = pd.to_datetime(df_test.index).tz_localize('UTC') self.check_df(df_test, 'mpcpy_simulation_inputs_model.csv') df_test = pd.read_csv('mpcpy_simulation_parameters_model.csv', index_col='parameter') self.check_df(df_test, 'mpcpy_simulation_parameters_model.csv', timeseries=False) # Estimate model based on emulated data self.model.estimate(self.start_time_estimation, self.final_time_estimation, self.measurement_variable_list) # Validate model based on estimation data self.model.validate(self.start_time_estimation, self.final_time_estimation, \ os.path.join(self.get_unittest_path(), 'outputs', 'model_estimation'), plot=0) # Check references RMSE = {} for key in self.model.RMSE.keys(): RMSE[key] = {} RMSE[key]['Value'] = self.model.RMSE[key].display_data() df_test = pd.DataFrame(data=RMSE) self.check_df(df_test, 'estimate_RMSE.csv', timeseries=False) # Validate on validation data self.building.collect_measurements(self.start_time_validation, self.final_time_validation) self.model.measurements = self.building.measurements self.model.validate(self.start_time_validation, self.final_time_validation, \ os.path.join(self.get_unittest_path(), 'outputs', 'model_validation'), plot=0) # Check references RMSE = {} for key in self.model.RMSE.keys(): RMSE[key] = {} RMSE[key]['Value'] = self.model.RMSE[key].display_data() df_test = pd.DataFrame(data=RMSE) self.check_df(df_test, 'validate_RMSE.csv', timeseries=False)
def test_optimize(self): '''Test the optimization of a model. ''' modelpath = 'Simple.RC' # Instantiate model model = models.Modelica(models.JModelica, \ models.RMSE, \ self.measurements, \ moinfo = (self.mopath, modelpath, {}), \ control_data = self.controls.data) # Instantiate optimization problem opt_problem = optimization.Optimization(model, \ optimization.EnergyMin, \ optimization.JModelica, \ 'q_flow', \ constraint_data = self.constraints.data) # Solve optimization problem with default res_control_step opt_problem.optimize(self.start_time, self.final_time) # Check references df_test = opt_problem.display_measurements('Simulated') self.check_df(df_test, 'optimize_measurements.csv') df_test = model.control_data['q_flow'].display_data().to_frame() df_test.index.name = 'Time' self.check_df(df_test, 'optimize_control_default.csv') # Simulate model with optimal control model.simulate(self.start_time, self.final_time) # Check references df_test = model.display_measurements('Simulated') self.check_df(df_test, 'simulate_optimal_default.csv') # Solve optimization problem with user-defined res_control_step opt_problem.optimize(self.start_time, self.final_time, res_control_step=60.0) # Check references df_test = opt_problem.display_measurements('Simulated') self.check_df(df_test, 'optimize_measurements.csv') df_test = model.control_data['q_flow'].display_data().to_frame() df_test.index.name = 'Time' self.check_df(df_test, 'optimize_control_userdefined.csv') # Simulate model with optimal control model.simulate(self.start_time, self.final_time) # Check references df_test = model.display_measurements('Simulated') self.check_df(df_test, 'simulate_optimal_userdefined.csv') # Get opt input object and create dataframe time = np.linspace(0, 3600, 3601) df_test = pd.DataFrame() data = [] opt_input_traj = opt_problem.opt_input[1] names = opt_problem.opt_input[0] # Create data for t in time: data.append(opt_input_traj(t)) # Create index timedelta = pd.to_timedelta(time, 's') index = pd.to_datetime(self.start_time) + timedelta df_test = pd.DataFrame(data=data, index=index, columns=names) df_test.index.name = 'Time' # Check references self.check_df(df_test, 'optimize_opt_input.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)