def test_FP_simpleMINLP(self): """Test the feasibility pump algorithm.""" with SolverFactory('mindtpy') as opt: model = SimpleMINLP() print('\n Solving 8PP problem using feasibility pump') results = opt.solve(model, strategy='FP', mip_solver=required_solvers[1], nlp_solver=required_solvers[0], bound_tolerance=1E-5) log_infeasible_constraints(model) self.assertTrue(is_feasible(model, self.get_config(opt)))
def test_ECP_MINLP_simple(self): """Test the extended cutting plane decomposition algorithm.""" with SolverFactory('mindtpy') as opt: model = SimpleMINLP() print('\n Solving MINLP_simple problem with extended cutting plane') results = opt.solve(model, strategy='ECP', init_strategy='initial_binary', mip_solver=required_solvers[1], nlp_solver=required_solvers[0]) self.assertIs(results.solver.termination_condition, TerminationCondition.optimal) self.assertAlmostEqual(value(model.cost.expr), 3.5, places=2)
def test_FP_OA_simpleMINLP(self): """Test the FP-OA algorithm.""" with SolverFactory('mindtpy') as opt: model = SimpleMINLP() print('\n Solving 8PP problem using FP-OA') results = opt.solve(model, strategy='OA', init_strategy='FP', mip_solver=required_solvers[1], nlp_solver=required_solvers[0], bound_tolerance=1E-5) self.assertIs(results.solver.termination_condition, TerminationCondition.optimal) self.assertAlmostEqual(value(model.cost.expr), 3.5, places=2)
def test_OA_MINLP_simple(self): """Test the outer approximation decomposition algorithm.""" with SolverFactory('mindtpy') as opt: model = SimpleMINLP() print('\n Solving problem with Outer Approximation') results = opt.solve(model, strategy='OA', init_strategy='initial_binary', mip_solver=required_solvers[1], nlp_solver=required_solvers[0], obj_bound=10) self.assertIs(results.solver.termination_condition, TerminationCondition.optimal) self.assertAlmostEqual(value(model.cost.expr), 3.5, places=2)
def test_initial_binary_add_slack(self): """Test the extended cutting plane decomposition algorithm.""" with SolverFactory('mindtpy') as opt: model = SimpleMINLP() print( '\n Test initial_binary initialize strategy and add_slack to improve code coverage') results = opt.solve(model, strategy='ECP', init_strategy='initial_binary', mip_solver=required_solvers[1], nlp_solver=required_solvers[0], add_slack=True) self.assertIs(results.solver.termination_condition, TerminationCondition.optimal) self.assertAlmostEqual(value(model.cost.expr), 3.5, places=2)
def test_GOA_MINLP_simple(self): """Test the global outer approximation decomposition algorithm.""" with SolverFactory('mindtpy') as opt: model = SimpleMINLP() print('\n Solving MINLP_simple problem with Outer Approximation') results = opt.solve(model, strategy='GOA', mip_solver=required_solvers[1], nlp_solver=required_solvers[0], obj_bound=10, add_nogood_cuts=True, single_tree=True) self.assertIs(results.solver.termination_condition, TerminationCondition.optimal) self.assertAlmostEqual(value(model.cost.expr), 3.5, places=2)
def test_handle_termination_condition(self): """Test the outer approximation decomposition algorithm.""" model = SimpleMINLP() config = _get_MindtPy_config() solve_data = set_up_solve_data(model, config) with time_code(solve_data.timing, 'total', is_main_timer=True), \ create_utility_block(solve_data.working_model, 'MindtPy_utils', solve_data): MindtPy = solve_data.working_model.MindtPy_utils MindtPy = solve_data.working_model.MindtPy_utils setup_results_object(solve_data, config) process_objective( solve_data, config, move_linear_objective=(config.init_strategy == 'FP' or config.add_regularization is not None), use_mcpp=config.use_mcpp, update_var_con_list=config.add_regularization is None) feas = MindtPy.feas_opt = Block() feas.deactivate() feas.feas_constraints = ConstraintList( doc='Feasibility Problem Constraints') lin = MindtPy.cuts = Block() lin.deactivate() if config.feasibility_norm == 'L1' or config.feasibility_norm == 'L2': feas.nl_constraint_set = RangeSet( len(MindtPy.nonlinear_constraint_list), doc='Integer index set over the nonlinear constraints.') # Create slack variables for feasibility problem feas.slack_var = Var(feas.nl_constraint_set, domain=NonNegativeReals, initialize=1) else: feas.slack_var = Var(domain=NonNegativeReals, initialize=1) # no-good cuts exclude particular discrete decisions lin.no_good_cuts = ConstraintList(doc='no-good cuts') fixed_nlp = solve_data.working_model.clone() TransformationFactory('core.fix_integer_vars').apply_to(fixed_nlp) MindtPy_initialize_main(solve_data, config) # test handle_subproblem_other_termination termination_condition = tc.maxIterations config.add_no_good_cuts = True handle_subproblem_other_termination(fixed_nlp, termination_condition, solve_data, config) self.assertEqual( len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts), 1) # test handle_main_other_conditions main_mip, main_mip_results = solve_main(solve_data, config) main_mip_results.solver.termination_condition = tc.infeasible handle_main_other_conditions(solve_data.mip, main_mip_results, solve_data, config) self.assertIs(solve_data.results.solver.termination_condition, tc.feasible) main_mip_results.solver.termination_condition = tc.unbounded handle_main_other_conditions(solve_data.mip, main_mip_results, solve_data, config) self.assertIn(main_mip.MindtPy_utils.objective_bound, main_mip.component_data_objects(ctype=Constraint)) main_mip.MindtPy_utils.del_component('objective_bound') main_mip_results.solver.termination_condition = tc.infeasibleOrUnbounded handle_main_other_conditions(solve_data.mip, main_mip_results, solve_data, config) self.assertIn(main_mip.MindtPy_utils.objective_bound, main_mip.component_data_objects(ctype=Constraint)) main_mip_results.solver.termination_condition = tc.maxTimeLimit handle_main_other_conditions(solve_data.mip, main_mip_results, solve_data, config) self.assertIs(solve_data.results.solver.termination_condition, tc.maxTimeLimit) main_mip_results.solver.termination_condition = tc.other main_mip_results.solution.status = SolutionStatus.feasible handle_main_other_conditions(solve_data.mip, main_mip_results, solve_data, config) for v1, v2 in zip( main_mip.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list): self.assertEqual(v1.value, v2.value) # test handle_feasibility_subproblem_tc feas_subproblem = solve_data.working_model.clone() add_feas_slacks(feas_subproblem, config) MindtPy = feas_subproblem.MindtPy_utils MindtPy.feas_opt.activate() if config.feasibility_norm == 'L1': MindtPy.feas_obj = Objective(expr=sum( s for s in MindtPy.feas_opt.slack_var[...]), sense=minimize) elif config.feasibility_norm == 'L2': MindtPy.feas_obj = Objective(expr=sum( s * s for s in MindtPy.feas_opt.slack_var[...]), sense=minimize) else: MindtPy.feas_obj = Objective(expr=MindtPy.feas_opt.slack_var, sense=minimize) handle_feasibility_subproblem_tc(tc.optimal, MindtPy, solve_data, config) handle_feasibility_subproblem_tc(tc.infeasible, MindtPy, solve_data, config) self.assertIs(solve_data.should_terminate, True) self.assertIs(solve_data.results.solver.status, SolverStatus.error) solve_data.should_terminate = False solve_data.results.solver.status = None handle_feasibility_subproblem_tc(tc.maxIterations, MindtPy, solve_data, config) self.assertIs(solve_data.should_terminate, True) self.assertIs(solve_data.results.solver.status, SolverStatus.error) solve_data.should_terminate = False solve_data.results.solver.status = None handle_feasibility_subproblem_tc(tc.solverFailure, MindtPy, solve_data, config) self.assertIs(solve_data.should_terminate, True) self.assertIs(solve_data.results.solver.status, SolverStatus.error) # test NLP subproblem infeasible solve_data.working_model.Y[1].value = 0 solve_data.working_model.Y[2].value = 0 solve_data.working_model.Y[3].value = 0 fixed_nlp, fixed_nlp_results = solve_subproblem(solve_data, config) solve_data.working_model.Y[1].value = None solve_data.working_model.Y[2].value = None solve_data.working_model.Y[3].value = None # test handle_nlp_subproblem_tc fixed_nlp_results.solver.termination_condition = tc.maxTimeLimit handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_results, solve_data, config) self.assertIs(solve_data.should_terminate, True) self.assertIs(solve_data.results.solver.termination_condition, tc.maxTimeLimit) fixed_nlp_results.solver.termination_condition = tc.maxEvaluations handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_results, solve_data, config) self.assertIs(solve_data.should_terminate, True) self.assertIs(solve_data.results.solver.termination_condition, tc.maxEvaluations) fixed_nlp_results.solver.termination_condition = tc.maxIterations handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_results, solve_data, config) self.assertIs(solve_data.should_terminate, True) self.assertIs(solve_data.results.solver.termination_condition, tc.maxEvaluations) # test handle_fp_main_tc config.init_strategy = 'FP' solve_data.fp_iter = 1 init_rNLP(solve_data, config) feas_main, feas_main_results = solve_main(solve_data, config, fp=True) feas_main_results.solver.termination_condition = tc.optimal fp_should_terminate = handle_fp_main_tc(feas_main_results, solve_data, config) self.assertIs(fp_should_terminate, False) feas_main_results.solver.termination_condition = tc.maxTimeLimit fp_should_terminate = handle_fp_main_tc(feas_main_results, solve_data, config) self.assertIs(fp_should_terminate, True) self.assertIs(solve_data.results.solver.termination_condition, tc.maxTimeLimit) feas_main_results.solver.termination_condition = tc.infeasible fp_should_terminate = handle_fp_main_tc(feas_main_results, solve_data, config) self.assertIs(fp_should_terminate, True) feas_main_results.solver.termination_condition = tc.unbounded fp_should_terminate = handle_fp_main_tc(feas_main_results, solve_data, config) self.assertIs(fp_should_terminate, True) feas_main_results.solver.termination_condition = tc.other feas_main_results.solution.status = SolutionStatus.feasible fp_should_terminate = handle_fp_main_tc(feas_main_results, solve_data, config) self.assertIs(fp_should_terminate, False) feas_main_results.solver.termination_condition = tc.solverFailure fp_should_terminate = handle_fp_main_tc(feas_main_results, solve_data, config) self.assertIs(fp_should_terminate, True) # test generate_norm_constraint fp_nlp = solve_data.working_model.clone() config.fp_main_norm = 'L1' generate_norm_constraint(fp_nlp, solve_data, config) self.assertIsNotNone( fp_nlp.MindtPy_utils.find_component('L1_norm_constraint')) config.fp_main_norm = 'L2' generate_norm_constraint(fp_nlp, solve_data, config) self.assertIsNotNone(fp_nlp.find_component('norm_constraint')) fp_nlp.del_component('norm_constraint') config.fp_main_norm = 'L_infinity' generate_norm_constraint(fp_nlp, solve_data, config) self.assertIsNotNone(fp_nlp.find_component('norm_constraint')) # test set_solver_options config.mip_solver = 'gams' config.threads = 1 opt = SolverFactory(config.mip_solver) set_solver_options(opt, solve_data, config, 'mip', regularization=False) config.mip_solver = 'gurobi' config.mip_regularization_solver = 'gurobi' config.regularization_mip_threads = 1 opt = SolverFactory(config.mip_solver) set_solver_options(opt, solve_data, config, 'mip', regularization=True) config.nlp_solver = 'gams' config.nlp_solver_args['solver'] = 'ipopt' set_solver_options(opt, solve_data, config, 'nlp', regularization=False) config.nlp_solver_args['solver'] = 'ipopth' set_solver_options(opt, solve_data, config, 'nlp', regularization=False) config.nlp_solver_args['solver'] = 'conopt' set_solver_options(opt, solve_data, config, 'nlp', regularization=False) config.nlp_solver_args['solver'] = 'msnlp' set_solver_options(opt, solve_data, config, 'nlp', regularization=False) config.nlp_solver_args['solver'] = 'baron' set_solver_options(opt, solve_data, config, 'nlp', regularization=False) # test algorithm_should_terminate solve_data.should_terminate = True solve_data.UB = float('inf') self.assertIs( algorithm_should_terminate(solve_data, config, check_cycling=False), True) self.assertIs(solve_data.results.solver.termination_condition, tc.noSolution) solve_data.UB = 100 self.assertIs( algorithm_should_terminate(solve_data, config, check_cycling=False), True) self.assertIs(solve_data.results.solver.termination_condition, tc.feasible) solve_data.objective_sense = maximize solve_data.LB = float('-inf') self.assertIs( algorithm_should_terminate(solve_data, config, check_cycling=False), True) self.assertIs(solve_data.results.solver.termination_condition, tc.noSolution) solve_data.LB = 100 self.assertIs( algorithm_should_terminate(solve_data, config, check_cycling=False), True) self.assertIs(solve_data.results.solver.termination_condition, tc.feasible)
required_nlp_solvers = 'ipopt' required_mip_solvers = ['cplex_persistent', 'gurobi_persistent'] available_mip_solvers = [ s for s in required_mip_solvers if SolverFactory(s).available(False) ] if SolverFactory(required_nlp_solvers).available( False) and available_mip_solvers: subsolvers_available = True else: subsolvers_available = False model_list = [ EightProcessFlowsheet(convex=True), ConstraintQualificationExample(), SimpleMINLP() ] @unittest.skipIf(not subsolvers_available, 'Required subsolvers %s are not available' % ([required_nlp_solvers] + required_mip_solvers)) @unittest.skipIf(not pyomo.core.base.symbolic.differentiate_available, 'Symbolic differentiation is not available') class TestMindtPy(unittest.TestCase): """Tests for the MindtPy solver plugin.""" @unittest.skipUnless('cplex_persistent' in available_mip_solvers, 'cplex_persistent solver is not available') def test_LPNLP_CPLEX(self): """Test the LP/NLP decomposition algorithm.""" with SolverFactory('mindtpy') as opt:
from pyomo.contrib.mindtpy.tests.MINLP2_simple import SimpleMINLP as SimpleMINLP2 from pyomo.contrib.mindtpy.tests.MINLP3_simple import SimpleMINLP as SimpleMINLP3 from pyomo.contrib.mindtpy.tests.MINLP4_simple import SimpleMINLP4 from pyomo.contrib.mindtpy.tests.MINLP5_simple import SimpleMINLP5 from pyomo.contrib.mindtpy.tests.from_proposal import ProposalModel from pyomo.contrib.mindtpy.tests.constraint_qualification_example import ConstraintQualificationExample from pyomo.contrib.mindtpy.tests.online_doc_example import OnlineDocExample from pyomo.environ import SolverFactory, value, maximize from pyomo.solvers.tests.models.LP_unbounded import LP_unbounded from pyomo.solvers.tests.models.QCP_simple import QCP_simple from pyomo.opt import TerminationCondition full_model_list = [EightProcessFlowsheet(convex=True), ConstraintQualificationExample(), SimpleMINLP(), SimpleMINLP2(), SimpleMINLP3(), SimpleMINLP4(), SimpleMINLP5(), ProposalModel(), OnlineDocExample() ] model_list = [EightProcessFlowsheet(convex=True), ConstraintQualificationExample(), SimpleMINLP2(), ] nonconvex_model_list = [EightProcessFlowsheet(convex=False)] obj_nonlinear_sum_model_list = [SimpleMINLP(), SimpleMINLP5()]