def recalibrate_visualization(single_trial):
V_plot = single_trial.optimization.V_opt
p_fix_num = single_trial.optimization.p_fix_num
output_vals = single_trial.optimization.output_vals
time_grids = single_trial.optimization.time_grids
integral_outputs_final = single_trial.optimization.integral_outputs_final
name = single_trial.name
parametric_options = single_trial.options
iterations = single_trial.optimization.iterations
return_status_numeric = single_trial.optimization.return_status_numeric
timings = single_trial.optimization.timings
cost_fun = single_trial.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, V_plot, p_fix_num)
V_ref = single_trial.optimization.V_ref
recalibrated_plot_dict = tools.recalibrate_visualization(
V_plot,
single_trial.visualization.plot_dict,
output_vals,
integral_outputs_final,
parametric_options,
time_grids,
cost,
name,
V_ref,
iterations=iterations,
return_status_numeric=return_status_numeric,
timings=timings)
return recalibrated_plot_dict
def generate_solution_dict(self):
solution_dict = {}
# seeding data
solution_dict['time_grids'] = self.__optimization.time_grids
solution_dict['name'] = self.__name
# parametric sweep data
solution_dict['V_opt'] = self.__optimization.V_opt
solution_dict['V_final'] = self.__optimization.V_final
solution_dict['options'] = self.__options
solution_dict['output_vals'] = [
copy.deepcopy(self.__optimization.output_vals[0]),
copy.deepcopy(self.__optimization.output_vals[1])
]
solution_dict['integral_outputs_final'] = self.__optimization.integral_outputs_final
solution_dict['stats'] = self.__optimization.stats
solution_dict['iterations'] = self.__optimization.iterations
solution_dict['timings'] = self.__optimization.timings
cost_fun = self.__nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, self.__optimization.V_opt, self.__optimization.p_fix_num)
solution_dict['cost'] = cost
# warmstart data
solution_dict['final_homotopy_step'] = self.__optimization.final_homotopy_step
solution_dict['Xdot_opt'] = self.__nlp.Xdot(self.__nlp.Xdot_fun(self.__optimization.V_opt))
solution_dict['g_opt'] = self.__nlp.g(self.__nlp.g_fun(self.__optimization.V_opt, self.__optimization.p_fix_num))
solution_dict['opt_arg'] = self.__optimization.arg
return solution_dict
def __make_debug_plot(self, V_plot, nlp, visualization, location):
if location == 'initial_guess':
self.generate_outputs(nlp, {'x': self.__V_init})
fig_name = 'debug_plot_' + location
sweep_toggle = False
cost_fun = nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, V_plot, self.__p_fix_num)
V_ref = self.__V_ref
visualization.plot(V_plot, visualization.options, [self.__outputs_init,
self.__outputs_opt, self.__outputs_ref],
self.__integral_outputs_opt, self.__debug_flags, self.__time_grids, cost, self.__name, sweep_toggle, V_ref, fig_name=fig_name)
return None
def __plot(self, flags, V_opt):
""" Plot MPC solution.
"""
# reference trajectory
V_ref = self.__trial.nlp.V(self.__p0['ref'])
# generate system outputs
[nlp_outputs, nlp_output_fun] = self.__trial.nlp.output_components
outputs_init = nlp_outputs(nlp_output_fun(self.__w0, self.__p_fix_num))
outputs_opt = nlp_outputs(nlp_output_fun(V_opt, self.__p_fix_num))
outputs_ref = nlp_outputs(nlp_output_fun(V_ref, self.__p_fix_num))
output_vals = [outputs_init, outputs_opt, outputs_ref]
# generate integral outputs
[nlp_integral_outputs, nlp_integral_outputs_fun] = self.__trial.nlp.integral_output_components
integral_outputs_final = nlp_integral_outputs(nlp_integral_outputs_fun(V_opt, self.__p_fix_num))
# time grids
time_grids = {}
for grid in self.__trial.nlp.time_grids:
time_grids[grid] = self.__trial.nlp.time_grids[grid](V_opt['theta','t_f'])
time_grids['ref'] = time_grids
# cost function
cost_fun = self.__trial.nlp.cost_components[0]
import awebox.tools.struct_operations as struct_op
cost = struct_op.evaluate_cost_dict(cost_fun, V_opt, self.__p_fix_num)
# reference trajectory
self.__trial.visualization.plot(
V_opt,
self.__trial.options,
output_vals,
integral_outputs_final,
flags,
time_grids,
cost,
'MPC solution',
False,
V_ref)
plt.show()
return None
def optimize(self, options = [], final_homotopy_step = 'final',
warmstart_file = None, debug_flags = [],
debug_locations = [], save_flag = False):
if not options:
options = self.__options
# get save_flag
self.__save_flag = save_flag
logging.info('Optimizing trial (%s) ...', self.__name)
logging.info('')
self.__optimization.solve(options['solver'], self.__nlp, self.__model,
self.__formulation, self.__visualization,
final_homotopy_step, warmstart_file,
debug_flags = debug_flags, debug_locations =
debug_locations)
self.__solution_dict = self.generate_solution_dict()
self.set_timings('optimization')
self.__return_status_numeric = self.__optimization.return_status_numeric['optimization']
if self.__optimization.solve_succeeded:
logging.info('Trial (%s) optimized.', self.__name)
logging.info('Trial optimization time: %s',print_op.print_single_timing(self.__timings['optimization']))
else:
logging.info('WARNING: Optimization of Trial (%s) failed.', self.__name)
cost_fun = self.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, self.optimization.V_opt, self.optimization.p_fix_num)
self.visualization.recalibrate(self.optimization.V_opt, self.visualization.plot_dict, self.optimization.output_vals, self.optimization.integral_outputs_final, self.options, self.optimization.time_grids, cost, self.name)
# perform quality check
self.__quality.check_quality(self)
# save trial if option is set
if self.__save_flag is True or self.__options['solver']['save_trial'] == True:
self.save()
logging.info('')
def interpolate_data(trial, freq):
"""
Interpolate data trial data with a given sampling frequency
:param trial: trial whose data is to be interpolated
:param freq: sampling frequency
:return: dictionary with trial data, interpolation time grid
"""
# extract info
tf = trial.optimization.V_final['theta', 't_f', 0] # TODO: phase fix tf
# number of interpolating points
N = int(freq * tf)
# recalibrate plot_dict
plot_dict = trial.visualization.plot_dict
V_plot = trial.optimization.V_opt
p_fix_num = trial.optimization.p_fix_num
output_vals = trial.optimization.output_vals
time_grids = trial.optimization.time_grids
integral_outputs_final = trial.optimization.integral_outputs_final
cost_fun = trial.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, V_plot, p_fix_num)
name = trial.name
parametric_options = trial.options
plot_dict = tools.recalibrate_visualization(V_plot,
plot_dict,
output_vals,
integral_outputs_final,
parametric_options,
time_grids,
cost,
name,
N=N)
return plot_dict
def interpolate_data(trial, freq):
"""
Interpolate data trial data with a given sampling frequency
:param trial: trial whose data is to be interpolated
:param freq: sampling frequency
:return: dictionary with trial data, interpolation time grid
"""
# extract info
tf = trial.optimization.V_final['theta', 't_f', 0] # TODO: phase fix tf
# number of interpolating points
N = int(freq * tf)
# recalibrate plot_dict
plot_dict = trial.visualization.plot_dict
V_plot = trial.optimization.V_opt
V_final = trial.optimization.V_final
# V_plot = V_final
# periodicity = V_final['xd', 0, 'v_sq'] - V_final['xd', -1, 'v_sq']
# print('v_sq_diff')
# print(periodicity)
# periodicity = V_final['xd', 0, 'v_sd'] - V_final['xd', -1, 'v_sd']
# print('v_sd_diff')
# print(periodicity)
# periodicity = V_final['xd', 0, 'i_sq'] - V_final['xd', -1, 'i_sq']
# print('i_sq_diff')
# print(periodicity)
# periodicity = V_final['xd', 0, 'i_sd'] - V_final['xd', -1, 'i_sd']
# print('i_sd_diff')
# print(periodicity)
name = trial.name
print(name)
print('diam_t')
print(V_final['theta', 'diam_t', 0])
print('k_gear')
print(V_final['theta', 'k_gear', 0])
# periodicity = V_final['xd', 0, 'v_sq']
# print('v_sq_diff_0')
# print(periodicity)
# periodicity = V_final['xd', 0, 'v_sd']
# print('v_sd_0')
#print(periodicity)
# periodicity = V_final['xd', 0, 'i_sq']
# print('i_sq_0')
# print(periodicity)
# periodicity = V_final['xd', 0, 'i_sd']
# print('i_sd_0')
# print(periodicity)
# periodicity = V_final['xd', -1, 'v_sq']
# print('v_sq_diff_T')
# print(periodicity)
# periodicity = V_final['xd', -1, 'v_sd']
# print('v_sd_T')
# print(periodicity)
# periodicity = V_final['xd', -1, 'i_sq']
# print('i_sq_T')
# print(periodicity)
# periodicity = V_final['xd', -1, 'i_sd']
# print('i_sd_T')
# print(periodicity)
p_fix_num = trial.optimization.p_fix_num
output_vals = trial.optimization.output_vals
time_grids = trial.optimization.time_grids
integral_outputs_final = trial.optimization.integral_outputs_final
cost_fun = trial.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, V_plot, p_fix_num)
name = trial.name
parametric_options = trial.options
V_ref = trial.optimization.V_ref
#plot_dict = tools.recalibrate_visualization(V_plot, plot_dict, output_vals, integral_outputs_final, parametric_options, time_grids, cost, name, V_ref, N=N)
return plot_dict
def optimize(self,
options=[],
final_homotopy_step='final',
warmstart_file=None,
vortex_linearization_file=None,
debug_flags=[],
debug_locations=[],
save_flag=False):
if not options:
options = self.__options
# get save_flag
self.__save_flag = save_flag
if self.__options['user_options']['trajectory']['type'] == 'mpc':
raise ValueError(
'Optimize method not supported for MPC trials. Use PMPC wrapper instead.'
)
awelogger.logger.info('Optimizing trial (%s) ...', self.__name)
awelogger.logger.info('')
self.__optimization.solve(options['solver'],
self.__nlp,
self.__model,
self.__formulation,
self.__visualization,
final_homotopy_step,
warmstart_file,
vortex_linearization_file,
debug_flags=debug_flags,
debug_locations=debug_locations)
self.__solution_dict = self.generate_solution_dict()
self.set_timings('optimization')
self.__return_status_numeric = self.__optimization.return_status_numeric[
'optimization']
if self.__optimization.solve_succeeded:
awelogger.logger.info('Trial (%s) optimized.', self.__name)
awelogger.logger.info(
'Trial optimization time: %s',
print_op.print_single_timing(self.__timings['optimization']))
else:
awelogger.logger.info(
'WARNING: Optimization of Trial (%s) failed.', self.__name)
cost_fun = self.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, self.optimization.V_opt,
self.optimization.p_fix_num)
self.visualization.recalibrate(
self.optimization.V_opt, self.visualization.plot_dict,
self.optimization.output_vals,
self.optimization.integral_outputs_final, self.options,
self.optimization.time_grids, cost, self.name,
self.__optimization.V_ref)
V_final = self.optimization.V_final
V_solution_scaled = self.nlp.V(self.optimization.solution['x'])
cost_fun = self.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, V_solution_scaled,
self.optimization.p_fix_num)
for cost_name in cost.keys():
print(cost_name + ': ' + str(cost[cost_name]))
f_fun_eval = self.nlp.f_fun(V_solution_scaled,
self.optimization.p_fix_num)
print('f_fun:' + str(f_fun_eval))
# perform quality check
self.__quality.check_quality(self)
# save trial if option is set
if self.__save_flag is True or self.__options['solver'][
'save_trial'] == True:
saving_method = self.__options['solver']['save_format']
self.save(saving_method=saving_method)
awelogger.logger.info('')
def run(self, final_homotopy_step = 'final', warmstart_file = None, debug_flags = [],
debug_locations = []):
# build sweep in order to run it
self.build()
logging.info('Running sweep (' + self.__name + ') containing ' + str(len(list(self.__trial_dict.keys()))) + ' trials...')
# for all trials, run a parametric sweep
for trial_to_run in list(self.__trial_dict.keys()):
# build trial once
single_trial = self.__trial_dict[trial_to_run]
single_trial.build(False)
self.__sweep_dict[trial_to_run] = OrderedDict()
self.__sweep_labels[trial_to_run] = OrderedDict()
self.__plot_dict[trial_to_run] = OrderedDict()
# run parametric sweep
for param in list(self.__param_dict.keys()):
logging.info('Optimize trial (%s) with parametric setting (%s)',trial_to_run, param)
if param == 'base_options':
# take the existing trial options for optimizing
param_options = single_trial.options
else:
# add parametric sweep options to trial options and re-build
param_options = sweep_funcs.set_single_trial_options(single_trial.options, self.__param_dict[param], 'param')[0]
param_options.build(single_trial.model.architecture)
self.__trial_dict[trial_to_run].formulation.generate_parameterization_settings(param_options['formulation'])
# optimize trial
single_trial.optimize(options = param_options,
final_homotopy_step =
final_homotopy_step, debug_flags =
debug_flags, debug_locations =
debug_locations, warmstart_file = warmstart_file)
# recalibrate visualization
V_plot = single_trial.optimization.V_opt
p_fix_num = single_trial.optimization.p_fix_num
output_vals = single_trial.optimization.output_vals
time_grids = single_trial.optimization.time_grids
integral_outputs_final = single_trial.optimization.integral_outputs_final
name = single_trial.name
parametric_options = single_trial.options
iterations = single_trial.optimization.iterations
return_status_numeric = single_trial.optimization.return_status_numeric
timings = single_trial.optimization.timings
cost_fun = single_trial.nlp.cost_components[0]
cost = struct_op.evaluate_cost_dict(cost_fun, V_plot, p_fix_num)
recalibrated_plot_dict = tools.recalibrate_visualization(V_plot, single_trial.visualization.plot_dict, output_vals, integral_outputs_final, parametric_options, time_grids, cost, name, iterations=iterations, return_status_numeric=return_status_numeric, timings=timings)
self.__plot_dict[trial_to_run][param] = copy.deepcopy(recalibrated_plot_dict)
# overwrite outputs to work around pickle bug
for key in recalibrated_plot_dict['outputs']:
self.__plot_dict[trial_to_run][param]['outputs'][key] = copy.deepcopy(recalibrated_plot_dict['outputs'][key])
# save result
single_trial_solution_dict = single_trial.generate_solution_dict()
self.__sweep_dict[trial_to_run][param] = copy.deepcopy(single_trial_solution_dict)
# overwrite outputs to work around pickle bug
for i in range(len(single_trial_solution_dict['output_vals'])):
self.__sweep_dict[trial_to_run][param]['output_vals'][i] = copy.deepcopy(single_trial_solution_dict['output_vals'][i])
self.__sweep_labels[trial_to_run][param] = trial_to_run + '_' + param
logging.info('Sweep (' + self.__name + ') completed.')