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