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