def build(self, options, model):
logging.info('Building formulation...')
if self.__status == 'I am a formulation.':
logging.info('Formulation already built.')
return None
elif model.status == 'I am a model.':
timer = time.time()
self.determine_operation_conditions(options)
self.generate_parameters(options)
self.generate_variables(options)
self.generate_variable_bounds(options)
self.generate_parameter_bounds(options)
self.generate_parameterization_settings(options)
self.generate_constraints(options, model)
self.generate_outputs(options)
self.__status = 'I am a formulation.'
self.__timings['overall'] = time.time() - timer
logging.info('Formulation built.')
logging.info(
'Formulation construction time: %s',
print_op.print_single_timing(self.__timings['overall']))
logging.info('')
else:
raise ValueError(
'Cannot build formulation without building model.')
def build(self, options, nlp, model, formulation, name):
awelogger.logger.info('Building optimization...')
self.__name = name
if self.__status == 'I am an optimization.':
awelogger.logger.info('Optimization already built.')
return None
elif nlp.status == 'I am an NLP.':
timer = time.time()
# prepare callback
awe_callback = self.initialize_callback('awebox_callback', nlp, model, options)
# generate solvers
self.generate_solvers(model, nlp, formulation, options, awe_callback)
# record set-up time
self.__timings['setup'] = time.time() - timer
self.__status = 'I am an optimization.'
awelogger.logger.info('Optimization built.')
awelogger.logger.info('Optimization construction time: %s', print_op.print_single_timing(self.__timings['setup']))
awelogger.logger.info('')
else:
raise ValueError('Cannot build optimization without building NLP.')
return None
def build(self, options, architecture):
print("op")
print(options)
print("op")
awelogger.logger.info('Building model...')
if self.__status == 'I am a model.':
awelogger.logger.info('Model already built.')
return None
else:
self.__timings = {}
timer = time.time()
self.__architecture = architecture
self.__generate_system_parameters(options)
self.__generate_atmosphere(options['atmosphere'])
self.__generate_wind(options['wind'])
self.__generate_system_dynamics(options)
self.__generate_scaled_variable_bounds(options)
self.__generate_parameter_bounds(options)
self.__options = options
self.__timings['overall'] = time.time()-timer
self.__status = 'I am a model.'
awelogger.logger.info('Model built.')
awelogger.logger.info('Model construction time: %s', print_op.print_single_timing(self.__timings['overall']))
awelogger.logger.info('')
def build(self, nlp_options, model, formulation):
awelogger.logger.info('Building NLP...')
if self.__status == 'I am an NLP.':
awelogger.logger.info('NLP already built.')
return None
elif model.status == 'I am a model.' and formulation.status == 'I am a formulation.':
timer = time.time()
self.__generate_discretization(nlp_options, model, formulation)
self.__generate_variable_bounds(nlp_options, model)
self.__generate_objective(nlp_options, model)
self.__status = 'I am an NLP.'
awelogger.logger.info('NLP built.')
self.__timings['overall'] = time.time() - timer
awelogger.logger.info(
'NLP construction time: %s',
print_op.print_single_timing(self.__timings['overall']))
awelogger.logger.info('')
else:
raise ValueError(
'Cannot build NLP without first building model and formulation.'
)
def build(self, is_standalone_trial=True):
if is_standalone_trial:
print_op.log_license_info()
if self.__options['user_options']['trajectory']['type'] == 'mpc':
raise ValueError(
'Build method not supported for MPC trials. Use PMPC wrapper instead.'
)
awelogger.logger.info('')
awelogger.logger.info('Building trial (%s) ...', self.__name)
awelogger.logger.info('')
architecture = archi.Architecture(
self.__options['user_options']['system_model']['architecture'])
self.__options.build(architecture)
self.__model.build(self.__options['model'], architecture)
self.__formulation.build(self.__options['formulation'], self.__model)
self.__nlp.build(self.__options['nlp'], self.__model,
self.__formulation)
self.__optimization.build(self.__options['solver'], self.__nlp,
self.__model, self.__formulation,
self.__name)
self.__visualization.build(self.__model, self.__nlp, self.__name,
self.__options)
self.__quality.build(self.__options['quality'], self.__name)
self.set_timings('construction')
awelogger.logger.info('Trial (%s) built.', self.__name)
awelogger.logger.info(
'Trial construction time: %s',
print_op.print_single_timing(self.__timings['construction']))
awelogger.logger.info('')
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 build(self, is_standalone_trial=True):
if is_standalone_trial:
print_op.log_license_info()
logging.info('')
logging.info('Building trial (%s) ...', self.__name)
logging.info('')
architecture = archi.Architecture(self.__options['user_options']['system_model']['architecture'])
self.__options.build(architecture)
self.__model.build(self.__options['model'], architecture)
self.__formulation.build(self.__options['formulation'], self.__model)
self.__nlp.build(self.__options['nlp'], self.__model, self.__formulation)
self.__optimization.build(self.__options['solver'], self.__nlp, self.__model, self.__formulation, self.__name)
self.__visualization.build(self.__model, self.__nlp, self.__name, self.__options)
self.__quality.build(self.__options['quality'], self.__name)
self.set_timings('construction')
logging.info('Trial (%s) built.', self.__name)
logging.info('Trial construction time: %s',print_op.print_single_timing(self.__timings['construction']))
logging.info('')
def solve(self, options, nlp, model, formulation, visualization,
final_homotopy_step='final', warmstart_file = None, vortex_linearization_file = None, debug_flags =
[], debug_locations = []):
self.__debug_flags = debug_flags
if debug_flags != [] and debug_locations == []:
self.__debug_locations = 'all'
else:
self.__debug_locations = debug_locations
if self.__status in ['I am an optimization.','I am a solved optimization.', 'I am a failed optimization.']:
awelogger.logger.info('Solving optimization...')
# save final homotopy step
self.__final_homotopy_step = final_homotopy_step
# reset timings / iteration counters
self.reset_timings_and_counters()
# schedule the homotopy steps
self.define_homotopy_update_schedule(model, formulation, nlp, options['cost'])
# prepare problem
self.define_standard_args(nlp, formulation, model, options, visualization)
# restart the counter through the homotopy steps
self.define_update_counter(nlp, formulation, model)
# classifications
use_warmstart = not (warmstart_file == None)
use_vortex_linearization = 'lin' in model.parameters_dict.keys()
make_steps = not (final_homotopy_step == 'initial_guess')
# solve the problem
if make_steps:
if use_warmstart:
self.solve_from_warmstart(nlp, formulation, model, options, warmstart_file, final_homotopy_step, visualization)
else:
if use_vortex_linearization:
self.solve_with_vortex_linearization(nlp, model, formulation, options, vortex_linearization_file, final_homotopy_step, visualization)
else:
self.solve_homotopy(nlp, model, options, final_homotopy_step, visualization)
else:
self.__generate_outputs_from_V(nlp, self.__V_init)
self.__solve_succeeded = True
self.__stats = None
# process the solution
self.process_solution(options, nlp, model, final_homotopy_step)
if self.solve_succeeded:
awelogger.logger.info('Optimization solved.')
self.__status = 'I am a solved optimization.'
awelogger.logger.info('Optimization solving time: %s', print_op.print_single_timing(self.__timings['optimization']))
else:
self.__status = 'I am a failed optimization.'
awelogger.logger.info('')
else:
raise ValueError('Cannot solve optimization without building it.')
return None
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 solve(self,
options,
nlp,
model,
formulation,
visualization,
final_homotopy_step='final',
warmstart_file=None,
debug_flags=[],
debug_locations=[]):
self.__debug_flags = debug_flags
if debug_flags != [] and debug_locations == []:
self.__debug_locations = 'all'
else:
self.__debug_locations = debug_locations
if self.__status in [
'I am an optimization.', 'I am a solved optimization.',
'I am a failed optimization.'
]:
logging.info('Solving optimization...')
# save final homotopy step
self.__final_homotopy_step = final_homotopy_step
# reset timings / iteration counters
self.__timings['optimization'] = 0.
self.__iterations['optimization'] = 0
self.__return_status_numeric['optimization'] = 17
# schedule the homotopy steps
self.define_homotopy_update_schedule(model, formulation, nlp,
options['cost'])
# restart counting homotopy updates
self.__bound_update_counter = scheduling.initialize_bound_update_counter(
model, self.__schedule, formulation)
# prepare problem
self.initialize_args_and_updates(nlp, formulation, model, options,
visualization)
# solve the problem
if final_homotopy_step != 'initial_guess':
if warmstart_file == None:
self.solve_homotopy(nlp, model, options,
final_homotopy_step, visualization)
else:
self.solve_from_warmstart(nlp, model, options,
warmstart_file,
final_homotopy_step,
visualization)
else:
self.__generate_outputs_from_V(nlp, self.__V_init)
self.__solve_succeeded = 'True'
self.__stats = None
# process the solution
self.process_solution(options, nlp, model, final_homotopy_step)
if self.solve_succeeded:
logging.info('Optimization solved.')
self.__status = 'I am a solved optimization.'
logging.info(
'Optimization solving time: %s',
print_op.print_single_timing(
self.__timings['optimization']))
else:
self.__status = 'I am a failed optimization.'
logging.info('')
else:
raise ValueError('Cannot solve optimization without building it.')
return None
