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