def handle_subproblem_infeasible(fixed_nlp, solve_data, config, cb_opt=None): """Solves feasibility problem and adds cut according to the specified strategy. This function handles the result of the latest iteration of solving the NLP subproblem given an infeasible solution and copies the solution of the feasibility problem to the working model. Parameters ---------- fixed_nlp : Pyomo model Integer-variable-fixed NLP model. solve_data : MindtPySolveData Data container that holds solve-instance data. config : ConfigBlock The specific configurations for MindtPy. cb_opt : SolverFactory, optional The gurobi_persistent solver, by default None. """ # TODO try something else? Reinitialize with different initial # value? config.logger.info('NLP subproblem was locally infeasible.') solve_data.nlp_infeasible_counter += 1 if config.calculate_dual: for c in fixed_nlp.MindtPy_utils.constraint_list: rhs = value(c.upper) if c.has_ub() else value(c.lower) c_geq = -1 if c.has_ub() else 1 fixed_nlp.dual[c] = (c_geq * max(0, c_geq * (rhs - value(c.body)))) dual_values = list(fixed_nlp.dual[c] for c in fixed_nlp.MindtPy_utils.constraint_list) else: dual_values = None # if config.strategy == 'PSC' or config.strategy == 'GBD': # for var in fixed_nlp.component_data_objects(ctype=Var, descend_into=True): # fixed_nlp.ipopt_zL_out[var] = 0 # fixed_nlp.ipopt_zU_out[var] = 0 # if var.has_ub() and abs(var.ub - value(var)) < config.absolute_bound_tolerance: # fixed_nlp.ipopt_zL_out[var] = 1 # elif var.has_lb() and abs(value(var) - var.lb) < config.absolute_bound_tolerance: # fixed_nlp.ipopt_zU_out[var] = -1 if config.strategy in {'OA', 'GOA'}: config.logger.info('Solving feasibility problem') feas_subproblem, feas_subproblem_results = solve_feasibility_subproblem( solve_data, config) # TODO: do we really need this? if solve_data.should_terminate: return copy_var_list_values(feas_subproblem.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) if config.strategy == 'OA': add_oa_cuts(solve_data.mip, dual_values, solve_data, config, cb_opt) elif config.strategy == 'GOA': add_affine_cuts(solve_data, config) # Add a no-good cut to exclude this discrete option var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list) if config.add_no_good_cuts: # excludes current discrete option add_no_good_cuts(var_values, solve_data, config)
def handle_NLP_subproblem_infeasible(fixed_nlp, solve_data, config): """ Solves feasibility problem and adds cut according to the specified strategy This function handles the result of the latest iteration of solving the NLP subproblem given an infeasible solution and copies the solution of the feasibility problem to the working model. Parameters ---------- solve_data: MindtPy Data Container data container that holds solve-instance data config: ConfigBlock contains the specific configurations for the algorithm """ # TODO try something else? Reinitialize with different initial # value? config.logger.info('NLP subproblem was locally infeasible.') if config.use_dual: for c in fixed_nlp.component_data_objects(ctype=Constraint): rhs = c.upper if c.has_ub() else c.lower c_geq = -1 if c.has_ub() else 1 fixed_nlp.dual[c] = (c_geq * max(0, c_geq * (rhs - value(c.body)))) dual_values = list(fixed_nlp.dual[c] for c in fixed_nlp.MindtPy_utils.constraint_list) else: dual_values = None # if config.strategy == 'PSC' or config.strategy == 'GBD': # for var in fixed_nlp.component_data_objects(ctype=Var, descend_into=True): # fixed_nlp.ipopt_zL_out[var] = 0 # fixed_nlp.ipopt_zU_out[var] = 0 # if var.has_ub() and abs(var.ub - value(var)) < config.bound_tolerance: # fixed_nlp.ipopt_zL_out[var] = 1 # elif var.has_lb() and abs(value(var) - var.lb) < config.bound_tolerance: # fixed_nlp.ipopt_zU_out[var] = -1 if config.strategy in {'OA', 'GOA'}: config.logger.info('Solving feasibility problem') if config.initial_feas: # add_feas_slacks(fixed_nlp, solve_data) # config.initial_feas = False feas_NLP, feas_NLP_results = solve_NLP_feas(solve_data, config) copy_var_list_values(feas_NLP.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) if config.strategy == "OA": add_oa_cuts(solve_data.mip, dual_values, solve_data, config) elif config.strategy == "GOA": add_affine_cuts(solve_data, config) # Add an integer cut to exclude this discrete option var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list) if config.add_nogood_cuts: # excludes current discrete option add_nogood_cuts(var_values, solve_data, config)
def init_rNLP(solve_data, config): """Initialize the problem by solving the relaxed NLP and then store the optimal variable values obtained from solving the rNLP. Parameters ---------- solve_data : MindtPySolveData Data container that holds solve-instance data. config : ConfigBlock The specific configurations for MindtPy. Raises ------ ValueError MindtPy unable to handle the termination condition of the relaxed NLP. """ m = solve_data.working_model.clone() config.logger.debug('Relaxed NLP: Solve relaxed integrality') MindtPy = m.MindtPy_utils TransformationFactory('core.relax_integer_vars').apply_to(m) nlp_args = dict(config.nlp_solver_args) nlpopt = SolverFactory(config.nlp_solver) set_solver_options(nlpopt, solve_data, config, solver_type='nlp') with SuppressInfeasibleWarning(): results = nlpopt.solve(m, tee=config.nlp_solver_tee, **nlp_args) subprob_terminate_cond = results.solver.termination_condition if subprob_terminate_cond in {tc.optimal, tc.feasible, tc.locallyOptimal}: main_objective = MindtPy.objective_list[-1] if subprob_terminate_cond == tc.optimal: update_dual_bound(solve_data, value(main_objective.expr)) else: config.logger.info('relaxed NLP is not solved to optimality.') update_suboptimal_dual_bound(solve_data, results) dual_values = list( m.dual[c] for c in MindtPy.constraint_list) if config.calculate_dual else None config.logger.info( solve_data.log_formatter.format( '-', 'Relaxed NLP', value(main_objective.expr), solve_data.LB, solve_data.UB, solve_data.rel_gap, get_main_elapsed_time(solve_data.timing))) # Add OA cut if config.strategy in {'OA', 'GOA', 'FP'}: copy_var_list_values(m.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config, ignore_integrality=True) if config.init_strategy == 'FP': copy_var_list_values( m.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list, config, ignore_integrality=True) if config.strategy in {'OA', 'FP'}: add_oa_cuts(solve_data.mip, dual_values, solve_data, config) elif config.strategy == 'GOA': add_affine_cuts(solve_data, config) for var in solve_data.mip.MindtPy_utils.discrete_variable_list: # We don't want to trigger the reset of the global stale # indicator, so we will set this variable to be "stale", # knowing that set_value will switch it back to "not # stale" var.stale = True var.set_value(int(round(var.value)), skip_validation=True) elif subprob_terminate_cond in {tc.infeasible, tc.noSolution}: # TODO fail? try something else? config.logger.info('Initial relaxed NLP problem is infeasible. ' 'Problem may be infeasible.') elif subprob_terminate_cond is tc.maxTimeLimit: config.logger.info( 'NLP subproblem failed to converge within time limit.') solve_data.results.solver.termination_condition = tc.maxTimeLimit elif subprob_terminate_cond is tc.maxIterations: config.logger.info( 'NLP subproblem failed to converge within iteration limit.') else: raise ValueError( 'MindtPy unable to handle relaxed NLP termination condition ' 'of %s. Solver message: %s' % (subprob_terminate_cond, results.solver.message))
def handle_subproblem_optimal(fixed_nlp, solve_data, config, cb_opt=None, fp=False): """This function copies the result of the NLP solver function ('solve_subproblem') to the working model, updates the bounds, adds OA and no-good cuts, and then stores the new solution if it is the new best solution. This function handles the result of the latest iteration of solving the NLP subproblem given an optimal solution. Parameters ---------- fixed_nlp : Pyomo model Integer-variable-fixed NLP model. solve_data : MindtPySolveData Data container that holds solve-instance data. config : ConfigBlock The specific configurations for MindtPy. cb_opt : SolverFactory, optional The gurobi_persistent solver, by default None. fp : bool, optional Whether it is in the loop of feasibility pump, by default False. """ copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list, config) if config.calculate_dual: for c in fixed_nlp.tmp_duals: if fixed_nlp.dual.get(c, None) is None: fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c] dual_values = list(fixed_nlp.dual[c] for c in fixed_nlp.MindtPy_utils.constraint_list) else: dual_values = None main_objective = fixed_nlp.MindtPy_utils.objective_list[-1] update_primal_bound(solve_data, value(main_objective.expr)) if solve_data.primal_bound_improved: solve_data.best_solution_found = fixed_nlp.clone() solve_data.best_solution_found_time = get_main_elapsed_time( solve_data.timing) if config.strategy == 'GOA': solve_data.num_no_good_cuts_added.update({ solve_data.primal_bound: len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts) }) # add obj increasing constraint for fp if fp: solve_data.mip.MindtPy_utils.cuts.del_component( 'improving_objective_cut') if solve_data.objective_sense == minimize: solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint( expr=sum(solve_data.mip.MindtPy_utils.objective_value[:]) <= solve_data.primal_bound - config.fp_cutoffdecr * max(1, abs(solve_data.primal_bound))) else: solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint( expr=sum(solve_data.mip.MindtPy_utils.objective_value[:]) >= solve_data.primal_bound + config.fp_cutoffdecr * max(1, abs(solve_data.primal_bound))) # Add the linear cut if config.strategy == 'OA' or fp: copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) add_oa_cuts(solve_data.mip, dual_values, solve_data, config, cb_opt) elif config.strategy == 'GOA': copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) add_affine_cuts(solve_data, config) # elif config.strategy == 'PSC': # # !!THIS SEEMS LIKE A BUG!! - mrmundt # # add_psc_cut(solve_data, config) # elif config.strategy == 'GBD': # # !!THIS SEEMS LIKE A BUG!! - mrmundt # # add_gbd_cut(solve_data, config) var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list) if config.add_no_good_cuts: add_no_good_cuts(var_values, solve_data, config) config.call_after_subproblem_feasible(fixed_nlp, solve_data) config.logger.info( solve_data.fixed_nlp_log_formatter.format( '*' if solve_data.primal_bound_improved else ' ', solve_data.nlp_iter if not fp else solve_data.fp_iter, 'Fixed NLP', value(main_objective.expr), solve_data.primal_bound, solve_data.dual_bound, solve_data.rel_gap, get_main_elapsed_time(solve_data.timing)))
def handle_subproblem_optimal(fixed_nlp, solve_data, config, fp=False): """ This function copies the result of the NLP solver function ('solve_subproblem') to the working model, updates the bounds, adds OA and no-good cuts, and then stores the new solution if it is the new best solution. This function handles the result of the latest iteration of solving the NLP subproblem given an optimal solution. Parameters ---------- fixed_nlp: Pyomo model Fixed-NLP from the model solve_data: MindtPy Data Container data container that holds solve-instance data config: ConfigBlock contains the specific configurations for the algorithm """ copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list, config) if config.calculate_dual: for c in fixed_nlp.tmp_duals: if fixed_nlp.dual.get(c, None) is None: fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c] dual_values = list(fixed_nlp.dual[c] for c in fixed_nlp.MindtPy_utils.constraint_list) else: dual_values = None main_objective = fixed_nlp.MindtPy_utils.objective_list[-1] if solve_data.objective_sense == minimize: solve_data.UB = min(value(main_objective.expr), solve_data.UB) solve_data.solution_improved = solve_data.UB < solve_data.UB_progress[ -1] solve_data.UB_progress.append(solve_data.UB) else: solve_data.LB = max(value(main_objective.expr), solve_data.LB) solve_data.solution_improved = solve_data.LB > solve_data.LB_progress[ -1] solve_data.LB_progress.append(solve_data.LB) config.logger.info( 'Fixed-NLP {}: OBJ: {} LB: {} UB: {} TIME: {}s'.format( solve_data.nlp_iter if not fp else solve_data.fp_iter, value(main_objective.expr), solve_data.LB, solve_data.UB, round(get_main_elapsed_time(solve_data.timing), 2))) if solve_data.solution_improved: solve_data.best_solution_found = fixed_nlp.clone() solve_data.best_solution_found_time = get_main_elapsed_time( solve_data.timing) if config.strategy == 'GOA': if solve_data.objective_sense == minimize: solve_data.num_no_good_cuts_added.update({ solve_data.UB: len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts) }) else: solve_data.num_no_good_cuts_added.update({ solve_data.LB: len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts) }) # add obj increasing constraint for fp if fp: solve_data.mip.MindtPy_utils.cuts.del_component( 'improving_objective_cut') if solve_data.objective_sense == minimize: solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint( expr=solve_data.mip.MindtPy_utils.objective_value <= solve_data.UB - config.fp_cutoffdecr * max(1, abs(solve_data.UB))) else: solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint( expr=solve_data.mip.MindtPy_utils.objective_value >= solve_data.LB + config.fp_cutoffdecr * max(1, abs(solve_data.UB))) # Add the linear cut if config.strategy == 'OA' or fp: copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) add_oa_cuts(solve_data.mip, dual_values, solve_data, config) elif config.strategy == 'GOA': copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) add_affine_cuts(solve_data, config) # elif config.strategy == 'PSC': # # !!THIS SEEMS LIKE A BUG!! - mrmundt # # add_psc_cut(solve_data, config) # elif config.strategy == 'GBD': # # !!THIS SEEMS LIKE A BUG!! - mrmundt # # add_gbd_cut(solve_data, config) var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list) if config.add_no_good_cuts: add_no_good_cuts(var_values, solve_data, config, feasible=True) config.call_after_subproblem_feasible(fixed_nlp, solve_data)
def handle_NLP_subproblem_optimal(fixed_nlp, solve_data, config): """ This function copies the result of the NLP solver function ('solve_NLP_subproblem') to the working model, updates the bounds, adds OA and integer cuts, and then stores the new solution if it is the new best solution. This function handles the result of the latest iteration of solving the NLP subproblem given an optimal solution. Parameters ---------- fixed_nlp: Pyomo model fixed NLP from the model solve_data: MindtPy Data Container data container that holds solve-instance data config: ConfigBlock contains the specific configurations for the algorithm """ copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list, config) if config.use_dual: for c in fixed_nlp.tmp_duals: if fixed_nlp.dual.get(c, None) is None: fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c] dual_values = list(fixed_nlp.dual[c] for c in fixed_nlp.MindtPy_utils.constraint_list) else: dual_values = None main_objective = next( fixed_nlp.component_data_objects(Objective, active=True)) if main_objective.sense == minimize: solve_data.UB = min(value(main_objective.expr), solve_data.UB) solve_data.solution_improved = solve_data.UB < solve_data.UB_progress[ -1] solve_data.UB_progress.append(solve_data.UB) else: solve_data.LB = max(value(main_objective.expr), solve_data.LB) solve_data.solution_improved = solve_data.LB > solve_data.LB_progress[ -1] solve_data.LB_progress.append(solve_data.LB) config.logger.info('NLP {}: OBJ: {} LB: {} UB: {}'.format( solve_data.nlp_iter, value(main_objective.expr), solve_data.LB, solve_data.UB)) if solve_data.solution_improved: solve_data.best_solution_found = fixed_nlp.clone() solve_data.best_solution_found_time = get_main_elapsed_time( solve_data.timing) if config.strategy == 'GOA': if solve_data.results.problem.sense == ProblemSense.minimize: solve_data.num_no_good_cuts_added.update({ solve_data.UB: len(solve_data.mip.MindtPy_utils.MindtPy_linear_cuts. integer_cuts) }) else: solve_data.num_no_good_cuts_added.update({ solve_data.LB: len(solve_data.mip.MindtPy_utils.MindtPy_linear_cuts. integer_cuts) }) # Add the linear cut if config.strategy == 'OA': copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) add_oa_cuts(solve_data.mip, dual_values, solve_data, config) elif config.strategy == "GOA": copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config) add_affine_cuts(solve_data, config) elif config.strategy == 'PSC': # !!THIS SEEMS LIKE A BUG!! - mrmundt # add_psc_cut(solve_data, config) elif config.strategy == 'GBD': # !!THIS SEEMS LIKE A BUG!! - mrmundt # add_gbd_cut(solve_data, config) # This adds an integer cut to the feasible_integer_cuts # ConstraintList, which is not activated by default. However, it # may be activated as needed in certain situations or for certain # values of option flags. var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list) if config.add_nogood_cuts: add_nogood_cuts(var_values, solve_data, config, feasible=True) config.call_after_subproblem_feasible(fixed_nlp, solve_data)
def init_rNLP(solve_data, config): """ Initialize the problem by solving the relaxed NLP and then store the optimal variable values obtained from solving the rNLP Parameters ---------- solve_data: MindtPy Data Container data container that holds solve-instance data config: ConfigBlock contains the specific configurations for the algorithm """ m = solve_data.working_model.clone() config.logger.info('Relaxed NLP: Solve relaxed integrality') MindtPy = m.MindtPy_utils TransformationFactory('core.relax_integer_vars').apply_to(m) nlp_args = dict(config.nlp_solver_args) nlpopt = SolverFactory(config.nlp_solver) set_solver_options(nlpopt, solve_data, config, solver_type='nlp') with SuppressInfeasibleWarning(): results = nlpopt.solve(m, tee=config.nlp_solver_tee, **nlp_args) subprob_terminate_cond = results.solver.termination_condition if subprob_terminate_cond in {tc.optimal, tc.feasible, tc.locallyOptimal}: if subprob_terminate_cond in {tc.feasible, tc.locallyOptimal}: config.logger.info('relaxed NLP is not solved to optimality.') dual_values = list( m.dual[c] for c in MindtPy.constraint_list) if config.calculate_dual else None # Add OA cut # This covers the case when the Lower bound does not exist. # TODO: should we use the bound of the rNLP here? if solve_data.objective_sense == minimize: if not math.isnan(results.problem.lower_bound): solve_data.LB = results.problem.lower_bound solve_data.bound_improved = solve_data.LB > solve_data.LB_progress[ -1] solve_data.LB_progress.append(results.problem.lower_bound) elif not math.isnan(results.problem.upper_bound): solve_data.UB = results.problem.upper_bound solve_data.bound_improved = solve_data.UB < solve_data.UB_progress[ -1] solve_data.UB_progress.append(results.problem.upper_bound) main_objective = MindtPy.objective_list[-1] config.logger.info( 'Relaxed NLP: OBJ: %s LB: %s UB: %s TIME:%ss' % (value(main_objective.expr), solve_data.LB, solve_data.UB, round(get_main_elapsed_time(solve_data.timing), 2))) if config.strategy in {'OA', 'GOA', 'FP'}: copy_var_list_values(m.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config, ignore_integrality=True) if config.init_strategy == 'FP': copy_var_list_values( m.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list, config, ignore_integrality=True) if config.strategy == 'OA': add_oa_cuts(solve_data.mip, dual_values, solve_data, config) elif config.strategy == 'GOA': add_affine_cuts(solve_data, config) # TODO check if value of the binary or integer varibles is 0/1 or integer value. for var in solve_data.mip.MindtPy_utils.discrete_variable_list: var.value = int(round(var.value)) elif subprob_terminate_cond in {tc.infeasible, tc.noSolution}: # TODO fail? try something else? config.logger.info('Initial relaxed NLP problem is infeasible. ' 'Problem may be infeasible.') elif subprob_terminate_cond is tc.maxTimeLimit: config.logger.info( 'NLP subproblem failed to converge within time limit.') solve_data.results.solver.termination_condition = tc.maxTimeLimit elif subprob_terminate_cond is tc.maxIterations: config.logger.info( 'NLP subproblem failed to converge within iteration limit.') else: raise ValueError( 'MindtPy unable to handle relaxed NLP termination condition ' 'of %s. Solver message: %s' % (subprob_terminate_cond, results.solver.message))
def init_rNLP(solve_data, config): """ Initialize the problem by solving the relaxed NLP (fixed binary variables) and then store the optimal variable values obtained from solving the rNLP Parameters ---------- solve_data: MindtPy Data Container data container that holds solve-instance data config: ConfigBlock contains the specific configurations for the algorithm """ solve_data.nlp_iter += 1 m = solve_data.working_model.clone() config.logger.info( "NLP %s: Solve relaxed integrality" % (solve_data.nlp_iter,)) MindtPy = m.MindtPy_utils TransformationFactory('core.relax_integer_vars').apply_to(m) nlp_args = dict(config.nlp_solver_args) elapsed = get_main_elapsed_time(solve_data.timing) remaining = int(max(config.time_limit - elapsed, 1)) if config.nlp_solver == 'gams': nlp_args['add_options'] = nlp_args.get('add_options', []) nlp_args['add_options'].append('option reslim=%s;' % remaining) with SuppressInfeasibleWarning(): results = SolverFactory(config.nlp_solver).solve( m, tee=config.solver_tee, **nlp_args) subprob_terminate_cond = results.solver.termination_condition if subprob_terminate_cond in {tc.optimal, tc.feasible, tc.locallyOptimal}: if subprob_terminate_cond in {tc.feasible, tc.locallyOptimal}: config.logger.info( 'relaxed NLP is not solved to optimality.') main_objective = next(m.component_data_objects(Objective, active=True)) nlp_solution_values = list(v.value for v in MindtPy.variable_list) dual_values = list( m.dual[c] for c in MindtPy.constraint_list) if config.use_dual else None # Add OA cut if main_objective.sense == minimize and not math.isnan(results['Problem'][0]['Lower bound']): solve_data.LB = results['Problem'][0]['Lower bound'] elif not math.isnan(results['Problem'][0]['Upper bound']): solve_data.UB = results['Problem'][0]['Upper bound'] config.logger.info( 'NLP %s: OBJ: %s LB: %s UB: %s' % (solve_data.nlp_iter, value(main_objective.expr), solve_data.LB, solve_data.UB)) if config.strategy in {'OA', 'GOA'}: copy_var_list_values(m.MindtPy_utils.variable_list, solve_data.mip.MindtPy_utils.variable_list, config, ignore_integrality=True) if config.strategy == 'OA': add_oa_cuts(solve_data.mip, dual_values, solve_data, config) elif config.strategy == 'GOA': add_affine_cuts(solve_data, config) # TODO check if value of the binary or integer varibles is 0/1 or integer value. for var in solve_data.mip.component_data_objects(ctype=Var): if var.is_integer(): var.value = int(round(var.value)) elif subprob_terminate_cond is tc.infeasible: # TODO fail? try something else? config.logger.info( 'Initial relaxed NLP problem is infeasible. ' 'Problem may be infeasible.') elif subprob_terminate_cond is tc.maxTimeLimit: config.logger.info( 'NLP subproblem failed to converge within time limit.') elif subprob_terminate_cond is tc.maxIterations: config.logger.info( 'NLP subproblem failed to converge within iteration limit.') else: raise ValueError( 'MindtPy unable to handle relaxed NLP termination condition ' 'of %s. Solver message: %s' % (subprob_terminate_cond, results.solver.message))