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 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.csv')
def test_set_options_error(self): '''Test the setting of optimization options cannot occur with auto options. ''' 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) for key in ['external_data', 'init_traj', 'nominal_traj']: # Get initial options opt_options = opt_problem.get_optimization_options() # Set new options and check KeyError raised with self.assertRaises(KeyError): opt_options[key] = 2 opt_problem.set_optimization_options(opt_options)
def _estimate(self, Model): '''Perform estimation using JModelica optimization. ''' self.opt_problem = optimization.Optimization(Model, optimization._ParameterEstimate, optimization.JModelica, {}); self.opt_problem.optimize(Model.start_time, Model.final_time, measurement_variable_list = Model.measurement_variable_list);
def __init__(self, Model): '''Constructor of JModelica estimation method. ''' self.name = 'Jmo'; self.opt_problem = optimization.Optimization(Model, optimization._ParameterEstimate, optimization.JModelica, {});
def test_get_statistics(self): '''Test the getting of optimization result statistics. ''' 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 opt_problem.optimize(self.start_time, self.final_time) # Get statistics opt_statistics = opt_problem.get_optimization_statistics() # Check references (except execution time) json_test = opt_statistics[:-1] self.check_json(json_test, 'statistics.txt')
def test_optimize_long(self): '''Test update of control data with opt horizon longer than initial. ''' 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 opt_problem.optimize('1/10/2017 00:00:00', '1/11/2017 02:00:00') # Check references df_test = opt_problem.display_measurements('Simulated') self.check_df(df_test, 'optimize_long_measurements.csv') df_test = model.control_data['q_flow'].display_data().to_frame() df_test.index.name = 'Time' self.check_df(df_test, 'optimize_long_control.csv')
def test_initial_constraint(self): '''Test the optimization of a model with an initial constraint. ''' modelpath = 'Simple.RC_nostart' # Instantiate model model = models.Modelica(models.JModelica, \ models.RMSE, \ self.measurements, \ moinfo = (self.mopath, modelpath, {}), \ control_data = self.controls.data) # Add initial constraint self.constraints.data['T_db']['Initial'] = variables.Static( 'T_db_initial', 21, units.degC) # 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_initial_constraint.csv') opt_statistics = opt_problem.get_optimization_statistics() # Check references (except execution time) df_test = pd.DataFrame(columns=['message', 'iterations', 'objective'], index=[0]) df_test.loc[0] = opt_statistics[:-1] self.check_df(df_test, 'statistics_initial_constraint.csv', timeseries=False)
def test_get_statistics(self): '''Test the getting of optimization result statistics. ''' 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 opt_problem.optimize(self.start_time, self.final_time) # Get statistics opt_statistics = opt_problem.get_optimization_statistics() # Check references (except execution time) df_test = pd.DataFrame(columns=['message', 'iterations', 'objective'], index=[0]) df_test.loc[0] = opt_statistics[:-1] self.check_df(df_test, 'statistics.csv', timeseries=False)
def test_set_options(self): '''Test the setting of optimization options. ''' 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) # Get initial options opt_options = opt_problem.get_optimization_options() # Set new options opt_options['IPOPT_options']['max_iter'] = 2 opt_options['n_e'] = 2 opt_options['result_mode'] = 'mesh_points' opt_problem.set_optimization_options(opt_options) # Get new options opt_options = opt_problem.get_optimization_options() # Check references json_test = opt_options self.check_json(json_test, 'new_options.txt') # 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_new_options.csv')
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 test_extra_control_data(self): '''Test the optimization of a model where there is extra control data. ''' modelpath = 'Simple.RC'; # Gather inputs with extra data start_time_exo = '1/1/2017'; final_time_exo = '1/10/2017'; control_csv_filepath = os.path.join(self.get_unittest_path(), 'resources', 'model', 'SimpleRC_Input.csv'); control_variable_map = {'q_flow_csv' : ('q_flow', units.W), 'extra_input' : ('not_input', units.W)}; self.controls = exodata.ControlFromCSV(control_csv_filepath, control_variable_map); self.controls.collect_data(start_time_exo, final_time_exo); # 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');
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 test_energycostmin(self): '''Test energy cost minimization of a model.''' plt.close('all'); # Instanatiate optimization problem opt_problem = optimization.Optimization(self.model, \ optimization.EnergyCostMin, \ optimization.JModelica, \ 'Ptot', \ constraint_data = self.constraints.data) # Optimize opt_problem.optimize(self.start_time_optimization, self.final_time_optimization, price_data = self.prices.data); # Check references df_test = opt_problem.display_measurements('Simulated'); self.check_df(df_test, 'energycostmin.csv');
def test_update_constraints(self): '''Test the updating of constraints in the optimization. ''' 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 constraints 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') # Update constraints and control data self.constraints.collect_data('1/11/2017', '1/12/2017') opt_problem.constraint_data = self.constraints.data self.controls.collect_data('1/11/2017', '1/12/2017') # Solve optimization problem with updated constraints opt_problem.optimize('1/11/2017', '1/12/2017') # Check references df_test = opt_problem.display_measurements('Simulated') self.check_df(df_test, 'optimize_measurements_updated_constraints.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_updated_constraints.csv') # Check new constraint key raises error self.constraints.data['New_Constraint'] = opt_problem.constraint_data[ 'q_flow'] opt_problem.constraint_data = self.constraints.data with self.assertRaises(ValueError): opt_problem.optimize('1/11/2017', '1/12/2017')
def test_energymin(self): '''Test energy minimization of a model.''' plt.close('all') # Instanatiate optimization problem self.opt_problem = optimization.Optimization( self.model, optimization.EnergyMin, optimization.JModelica, 'Ptot', constraint_data=self.constraints.data) # Optimize self.opt_problem.optimize(self.start_time_optimization, self.final_time_optimization) # Update model self.model = self.opt_problem.Model # Check references df_test = self.model.display_measurements('Simulated') self.check_df_timeseries(df_test, 'energymin.csv')
def test_continue_error(self): '''Test a ValueError is raised if try to use the "continue" keyword. ''' modelpath = 'Simple.RC_nostart' # 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) # Check ValueError raised with self.assertRaises(ValueError): opt_problem.optimize('continue', self.final_time)
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_get_options(self): '''Test the getting of optimization options. ''' 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) # Get options opt_options = opt_problem.get_optimization_options() # Check references json_test = opt_options self.check_json(json_test, 'initial_options.txt')