bool PDSearchDirCalculator::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("fast_step_computation", fast_step_computation_, prefix); options.GetBoolValue("mehrotra_algorithm", mehrotra_algorithm_, prefix); return pd_solver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); }
bool Ma27TSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("ma27_pivtol", pivtol_, prefix); if (options.GetNumericValue("ma27_pivtolmax", pivtolmax_, prefix)) { ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID, "Option \"ma27_pivtolmax\": This value must be between " "ma27_pivtol and 1."); } else { pivtolmax_ = Max(pivtolmax_, pivtol_); } options.GetNumericValue("ma27_liw_init_factor", liw_init_factor_, prefix); options.GetNumericValue("ma27_la_init_factor", la_init_factor_, prefix); options.GetNumericValue("ma27_meminc_factor", meminc_factor_, prefix); options.GetBoolValue("ma27_skip_inertia_check", skip_inertia_check_, prefix); options.GetBoolValue("ma27_ignore_singularity", ignore_singularity_, prefix); // The following option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); /* Set the default options for MA27 */ F77_FUNC(ma27id,MA27ID)(icntl_, cntl_); #if COIN_IPOPT_VERBOSITY == 0 icntl_[0] = 0; // Suppress error messages icntl_[1] = 0; // Suppress diagnostic messages #endif // Reset all private data initialized_=false; pivtol_changed_ = false; refactorize_ = false; la_increase_=false; liw_increase_=false; if (!warm_start_same_structure_) { dim_=0; nonzeros_=0; } else { ASSERT_EXCEPTION(dim_>0 && nonzeros_>0, INVALID_WARMSTART, "Ma27TSolverInterface called with warm_start_same_structure, but the problem is solved for the first time."); } return true; }
bool InexactLSAcceptor::InitializeImpl( const OptionsList& options, const std::string& prefix ) { options.GetBoolValue("flexible_penalty_function", flexible_penalty_function_, prefix); if( !options.GetNumericValue("nu_init", nu_init_, prefix) && flexible_penalty_function_ ) { nu_init_ = 1.; } options.GetNumericValue("nu_inc", nu_inc_, prefix); options.GetNumericValue("eta_phi", eta_, prefix); options.GetNumericValue("rho", rho_, prefix); options.GetNumericValue("tcc_theta", tcc_theta_, prefix); options.GetNumericValue("nu_update_inf_skip_tol", nu_update_inf_skip_tol_, prefix); if( flexible_penalty_function_ ) { options.GetNumericValue("nu_low_init", nu_low_init_, prefix); ASSERT_EXCEPTION(nu_low_init_ <= nu_init_, OPTION_INVALID, "Option \"nu_low_init\" must be smaller or equal to \"nu_init\""); options.GetNumericValue("nu_low_fact", nu_low_fact_, prefix); } options.GetNumericValue("inexact_decomposition_activate_tol", inexact_decomposition_activate_tol_, prefix); options.GetNumericValue("inexact_decomposition_inactivate_tol", inexact_decomposition_inactivate_tol_, prefix); // The following options have been declared in FilterLSAcceptor Index max_soc; options.GetIntegerValue("max_soc", max_soc, prefix); ASSERT_EXCEPTION(max_soc == 0, OPTION_INVALID, "Option \"max_soc\" must be zero for inexact version."); Reset(); return true; }
bool PDFullSpaceSolver::InitializeImpl(const OptionsList& options, const std::string& prefix) { // Check for the algorithm options options.GetIntegerValue("min_refinement_steps", min_refinement_steps_, prefix); options.GetIntegerValue("max_refinement_steps", max_refinement_steps_, prefix); ASSERT_EXCEPTION(max_refinement_steps_ >= min_refinement_steps_, OPTION_INVALID, "Option \"max_refinement_steps\": This value must be larger than or equal to min_refinement_steps (default 1)"); options.GetNumericValue("residual_ratio_max", residual_ratio_max_, prefix); options.GetNumericValue("residual_ratio_singular", residual_ratio_singular_, prefix); ASSERT_EXCEPTION(residual_ratio_singular_ >= residual_ratio_max_, OPTION_INVALID, "Option \"residual_ratio_singular\": This value must be not smaller than residual_ratio_max."); options.GetNumericValue("residual_improvement_factor", residual_improvement_factor_, prefix); options.GetNumericValue("neg_curv_test_tol", neg_curv_test_tol_, prefix); options.GetBoolValue("neg_curv_test_reg", neg_curv_test_reg_, prefix); // Reset internal flags and data augsys_improved_ = false; if (!augSysSolver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix)) { return false; } return perturbHandler_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); }
bool MonotoneMuUpdate::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("mu_init", mu_init_, prefix); options.GetNumericValue("barrier_tol_factor", barrier_tol_factor_, prefix); options.GetNumericValue("mu_linear_decrease_factor", mu_linear_decrease_factor_, prefix); options.GetNumericValue("mu_superlinear_decrease_power", mu_superlinear_decrease_power_, prefix); options.GetBoolValue("mu_allow_fast_monotone_decrease", mu_allow_fast_monotone_decrease_, prefix); options.GetNumericValue("tau_min", tau_min_, prefix); options.GetNumericValue("compl_inf_tol", compl_inf_tol_, prefix); IpData().Set_mu(mu_init_); Number tau = Max(tau_min_, 1.0 - mu_init_); IpData().Set_tau(tau); initialized_ = false; //TODO we need to clean up the mu-update for the restoration phase if (prefix=="resto.") { first_iter_resto_ = true; } else { first_iter_resto_ = false; } return true; }
bool OrigIterationOutput::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("print_info_string", print_info_string_, prefix); return true; }
bool StdStepCalculator::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("sens_bound_eps", bound_eps_, prefix); options.GetBoolValue("sens_kkt_residuals", kkt_residuals_, prefix); SensitivityStepCalculator::InitializeImpl(options, prefix); return true; }
bool OrigIterationOutput::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("print_info_string", print_info_string_, prefix); Index enum_int; options.GetEnumValue("inf_pr_output", enum_int, prefix); inf_pr_output_ = InfPrOutput(enum_int); return true; }
bool CGPenaltyLSAcceptor::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("never_use_piecewise_penalty_ls", never_use_piecewise_penalty_ls_, prefix); options.GetNumericValue("eta_penalty", eta_penalty_, prefix); options.GetNumericValue("penalty_update_infeasibility_tol", penalty_update_infeasibility_tol_, prefix); options.GetNumericValue("eta_min", eta_min_, prefix); options.GetNumericValue("penalty_update_compl_tol", penalty_update_compl_tol_, prefix); options.GetNumericValue("chi_hat", chi_hat_, prefix); options.GetNumericValue("chi_tilde", chi_tilde_, prefix); options.GetNumericValue("chi_cup", chi_cup_, prefix); options.GetNumericValue("gamma_hat", gamma_hat_, prefix); options.GetNumericValue("gamma_tilde", gamma_tilde_, prefix); options.GetNumericValue("epsilon_c", epsilon_c_, prefix); options.GetNumericValue("piecewisepenalty_gamma_obj", piecewisepenalty_gamma_obj_, prefix); options.GetNumericValue("piecewisepenalty_gamma_infeasi", piecewisepenalty_gamma_infeasi_, prefix); options.GetNumericValue("pen_theta_max_fact", pen_theta_max_fact_, prefix); options.GetNumericValue("min_alpha_primal", min_alpha_primal_, prefix); options.GetNumericValue("theta_min", theta_min_, prefix); options.GetNumericValue("mult_diverg_feasibility_tol", mult_diverg_feasibility_tol_, prefix); options.GetNumericValue("mult_diverg_y_tol", mult_diverg_y_tol_, prefix); // The following option has been registered by FilterLSAcceptor options.GetIntegerValue("max_soc", max_soc_, prefix); // The following option has been registered by CGSearhDirCalc options.GetNumericValue("penalty_max", penalty_max_, prefix); if (max_soc_>0) { ASSERT_EXCEPTION(IsValid(pd_solver_), OPTION_INVALID, "Option \"max_soc\": This option is non-negative, but no linear solver for computing the SOC given to FilterLSAcceptor object."); } options.GetNumericValue("kappa_soc", kappa_soc_, prefix); pen_theta_max_ = -1.; pen_curr_mu_ = IpData().curr_mu(); counter_first_type_penalty_updates_ = 0; counter_second_type_penalty_updates_ = 0; curr_eta_ = -1.; CGPenData().SetPenaltyUninitialized(); ls_counter_ = 0; best_KKT_error_ = -1.; accepted_by_Armijo_ = true; //never_do_restor_ = true; jump_for_tiny_step_ = 0; return true; }
bool RestoIterationOutput::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("print_info_string", print_info_string_, prefix); Index enum_int; options.GetEnumValue("inf_pr_output", enum_int, prefix); inf_pr_output_ = InfPrOutput(enum_int); bool retval = true; if (IsValid(resto_orig_iteration_output_)) { retval = resto_orig_iteration_output_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); } return retval; }
bool RestoIpoptNLP::Initialize( const Journalist& jnlst, const OptionsList& options, const std::string& prefix ) { options.GetBoolValue("evaluate_orig_obj_at_resto_trial", evaluate_orig_obj_at_resto_trial_, prefix); options.GetNumericValue("resto_penalty_parameter", rho_, prefix); Index enum_int; options.GetEnumValue("hessian_approximation", enum_int, prefix); hessian_approximation_ = HessianApproximationType(enum_int); options.GetNumericValue("resto_proximity_weight", eta_factor_, prefix); initialized_ = true; return IpoptNLP::Initialize(jnlst, options, prefix); }
bool GenAugSystemSolver::InitializeImpl(const OptionsList& options, const std::string& prefix) { // This option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); if (!warm_start_same_structure_) { delete [] dx_vals_copy_; delete [] ds_vals_copy_; delete [] dc_vals_copy_; delete [] dd_vals_copy_; } return solver_interface_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); }
bool MinC_1NrmRestorationPhase::InitializeImpl(const OptionsList& options, const std::string& prefix) { // keep a copy of these options to use when setting up the // restoration phase resto_options_ = new OptionsList(options); options.GetNumericValue("constr_mult_reset_threshold", constr_mult_reset_threshold_, prefix); options.GetNumericValue("bound_mult_reset_threshold", bound_mult_reset_threshold_, prefix); options.GetBoolValue("expect_infeasible_problem", expect_infeasible_problem_, prefix); // This is registered in OptimalityErrorConvergenceCheck options.GetNumericValue("constr_viol_tol", constr_viol_tol_, prefix); // Avoid that the restoration phase is trigged by user option in // first iteration of the restoration phase resto_options_->SetStringValue("resto.start_with_resto", "no"); // We want the default for the theta_max_fact in the restoration // phase higher than for the regular phase Number theta_max_fact; if (!options.GetNumericValue("resto.theta_max_fact", theta_max_fact, "")) { resto_options_->SetNumericValue("resto.theta_max_fact", 1e8); } if (!options.GetNumericValue("resto_failure_feasibility_threshold", resto_failure_feasibility_threshold_, prefix)) { resto_failure_feasibility_threshold_ = 1e2*IpData().tol(); } count_restorations_ = 0; bool retvalue = true; if (IsValid(eq_mult_calculator_)) { retvalue = eq_mult_calculator_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); } return retvalue; }
bool WarmStartIterateInitializer::InitializeImpl(const OptionsList& options, const std::string& prefix) { if (!options.GetNumericValue("warm_start_bound_push", warm_start_bound_push_, prefix)) { options.GetNumericValue("bound_push", warm_start_bound_push_, prefix); } if (!options.GetNumericValue("warm_start_bound_frac", warm_start_bound_frac_, prefix)) { options.GetNumericValue("bound_frac", warm_start_bound_frac_, prefix); } if (!options.GetNumericValue("warm_start_slack_bound_push", warm_start_slack_bound_push_, prefix)) { if (!options.GetNumericValue("bound_push", warm_start_slack_bound_push_, prefix)) { if (!options.GetNumericValue("warm_start_slack_bound_push", warm_start_slack_bound_push_, prefix)) { options.GetNumericValue("bound_push", warm_start_slack_bound_push_, prefix); } } } if (!options.GetNumericValue("warm_start_slack_bound_frac", warm_start_slack_bound_frac_, prefix)) { if (!options.GetNumericValue("bound_frac", warm_start_slack_bound_frac_, prefix)) { if (!options.GetNumericValue("warm_start_slack_bound_frac", warm_start_slack_bound_frac_, prefix)) { options.GetNumericValue("bound_frac", warm_start_slack_bound_frac_, prefix); } } } options.GetNumericValue("warm_start_mult_bound_push", warm_start_mult_bound_push_, prefix); options.GetNumericValue("warm_start_mult_init_max", warm_start_mult_init_max_, prefix); options.GetNumericValue("warm_start_target_mu", warm_start_target_mu_, prefix); options.GetBoolValue("warm_start_entire_iterate", warm_start_entire_iterate_, prefix); return true; }
bool MumpsSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("mumps_pivtol", pivtol_, prefix); if (options.GetNumericValue("mumps_pivtolmax", pivtolmax_, prefix)) { ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID, "Option \"mumps_pivtolmax\": This value must be between " "mumps_pivtol and 1."); } else { pivtolmax_ = Max(pivtolmax_, pivtol_); } options.GetIntegerValue("mumps_mem_percent", mem_percent_, prefix); // The following option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); options.GetIntegerValue("mumps_permuting_scaling", mumps_permuting_scaling_, prefix); options.GetIntegerValue("mumps_pivot_order", mumps_pivot_order_, prefix); options.GetIntegerValue("mumps_scaling", mumps_scaling_, prefix); options.GetNumericValue("mumps_dep_tol", mumps_dep_tol_, prefix); // Reset all private data initialized_ = false; pivtol_changed_ = false; refactorize_ = false; have_symbolic_factorization_ = false; DMUMPS_STRUC_C* mumps_ = (DMUMPS_STRUC_C*)mumps_ptr_; if (!warm_start_same_structure_) { mumps_->n = 0; mumps_->nz = 0; } else { ASSERT_EXCEPTION(mumps_->n>0 && mumps_->nz>0, INVALID_WARMSTART, "MumpsSolverInterface called with warm_start_same_structure, but the problem is solved for the first time."); } return true; }
bool CGPerturbationHandler::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("max_hessian_perturbation", delta_xs_max_, prefix); options.GetNumericValue("min_hessian_perturbation", delta_xs_min_, prefix); options.GetNumericValue("perturb_inc_fact_first", delta_xs_first_inc_fact_, prefix); options.GetNumericValue("perturb_inc_fact", delta_xs_inc_fact_, prefix); options.GetNumericValue("perturb_dec_fact", delta_xs_dec_fact_, prefix); options.GetNumericValue("first_hessian_perturbation", delta_xs_init_, prefix); options.GetNumericValue("jacobian_regularization_value", delta_cd_val_, prefix); options.GetNumericValue("jacobian_regularization_exponent", delta_cd_exp_, prefix); options.GetBoolValue("perturb_always_cd", perturb_always_cd_, prefix); // The following option has been registered from CGSearchDirCalc options.GetNumericValue("penalty_max", penalty_max_, prefix); // The following option has been registered from CGPenaltyLSAccepter options.GetNumericValue("mult_diverg_feasibility_tol", mult_diverg_feasibility_tol_, prefix); hess_degenerate_ = NOT_YET_DETERMINED; if (!perturb_always_cd_) { jac_degenerate_ = NOT_YET_DETERMINED; } else { jac_degenerate_ = NOT_DEGENERATE; } degen_iters_ = 0; delta_x_curr_ = 0.; delta_s_curr_ = 0.; delta_c_curr_ = 0.; delta_d_curr_ = 0.; delta_x_last_ = 0.; delta_s_last_ = 0.; delta_c_last_ = 0.; delta_d_last_ = 0.; test_status_ = NO_TEST; return PDPerturbationHandler::InitializeImpl(options, prefix); }
SmartPtr<MuUpdate> AlgorithmBuilder::BuildMuUpdate( const Journalist& jnlst, const OptionsList& options, const std::string& prefix ) { DBG_ASSERT(IsValid(LineSearch_)); bool mehrotra_algorithm; options.GetBoolValue("mehrotra_algorithm", mehrotra_algorithm, prefix); // Create the mu update that will be used by the main algorithm SmartPtr<MuUpdate> MuUpdate; std::string smuupdate; if( !options.GetStringValue("mu_strategy", smuupdate, prefix) ) { // Change default for quasi-Newton option (then we use adaptive) Index enum_int; if( options.GetEnumValue("hessian_approximation", enum_int, prefix) ) { HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if( hessian_approximation == LIMITED_MEMORY ) { smuupdate = "adaptive"; } } if( mehrotra_algorithm ) { smuupdate = "adaptive"; } } ASSERT_EXCEPTION(!mehrotra_algorithm || smuupdate == "adaptive", OPTION_INVALID, "If mehrotra_algorithm=yes, mu_strategy must be \"adaptive\"."); std::string smuoracle; std::string sfixmuoracle; if( smuupdate == "adaptive" ) { if( !options.GetStringValue("mu_oracle", smuoracle, prefix) ) { if( mehrotra_algorithm ) { smuoracle = "probing"; } } options.GetStringValue("fixed_mu_oracle", sfixmuoracle, prefix); ASSERT_EXCEPTION(!mehrotra_algorithm || smuoracle == "probing", OPTION_INVALID, "If mehrotra_algorithm=yes, mu_oracle must be \"probing\"."); } if( smuupdate == "monotone" ) { MuUpdate = new MonotoneMuUpdate(GetRawPtr(LineSearch_)); } else if( smuupdate == "adaptive" ) { SmartPtr<MuOracle> muOracle; if( smuoracle == "loqo" ) { muOracle = new LoqoMuOracle(); } else if( smuoracle == "probing" ) { muOracle = new ProbingMuOracle(GetPDSystemSolver(jnlst, options, prefix)); } else if( smuoracle == "quality-function" ) { muOracle = new QualityFunctionMuOracle(GetPDSystemSolver(jnlst, options, prefix)); } SmartPtr<MuOracle> FixMuOracle; if( sfixmuoracle == "loqo" ) { FixMuOracle = new LoqoMuOracle(); } else if( sfixmuoracle == "probing" ) { FixMuOracle = new ProbingMuOracle(GetPDSystemSolver(jnlst, options, prefix)); } else if( sfixmuoracle == "quality-function" ) { FixMuOracle = new QualityFunctionMuOracle(GetPDSystemSolver(jnlst, options, prefix)); } else { FixMuOracle = NULL; } MuUpdate = new AdaptiveMuUpdate(GetRawPtr(LineSearch_), muOracle, FixMuOracle); } return MuUpdate; }
bool IterativePardisoSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { Index enum_int; options.GetEnumValue("pardiso_matching_strategy", enum_int, prefix); match_strat_ = PardisoMatchingStrategy(enum_int); options.GetBoolValue("pardiso_redo_symbolic_fact_only_if_inertia_wrong", pardiso_redo_symbolic_fact_only_if_inertia_wrong_, prefix); options.GetBoolValue("pardiso_repeated_perturbation_means_singular", pardiso_repeated_perturbation_means_singular_, prefix); Index pardiso_out_of_core_power; options.GetIntegerValue("pardiso_out_of_core_power", pardiso_out_of_core_power, prefix); options.GetBoolValue("pardiso_skip_inertia_check", skip_inertia_check_, prefix); // PD system options.GetIntegerValue("pardiso_max_iter", pardiso_max_iter_, prefix); options.GetNumericValue("pardiso_iter_relative_tol", pardiso_iter_relative_tol_, prefix); options.GetIntegerValue("pardiso_iter_coarse_size", pardiso_iter_coarse_size_, prefix); options.GetIntegerValue("pardiso_iter_max_levels", pardiso_iter_max_levels_, prefix); options.GetNumericValue("pardiso_iter_dropping_factor", pardiso_iter_dropping_factor_, prefix); options.GetNumericValue("pardiso_iter_dropping_schur", pardiso_iter_dropping_schur_, prefix); options.GetIntegerValue("pardiso_iter_max_row_fill", pardiso_iter_max_row_fill_, prefix); options.GetNumericValue("pardiso_iter_inverse_norm_factor", pardiso_iter_inverse_norm_factor_, prefix); // Normal system options.GetIntegerValue("pardiso_max_iter", normal_pardiso_max_iter_, prefix+"normal."); options.GetNumericValue("pardiso_iter_relative_tol", normal_pardiso_iter_relative_tol_, prefix+"normal."); options.GetIntegerValue("pardiso_iter_coarse_size", normal_pardiso_iter_coarse_size_, prefix+"normal."); options.GetIntegerValue("pardiso_iter_max_levels", normal_pardiso_iter_max_levels_, prefix+"normal."); options.GetNumericValue("pardiso_iter_dropping_factor", normal_pardiso_iter_dropping_factor_, prefix+"normal."); options.GetNumericValue("pardiso_iter_dropping_schur", normal_pardiso_iter_dropping_schur_, prefix+"normal."); options.GetIntegerValue("pardiso_iter_max_row_fill", normal_pardiso_iter_max_row_fill_, prefix+"normal."); options.GetNumericValue("pardiso_iter_inverse_norm_factor", normal_pardiso_iter_inverse_norm_factor_, prefix+"normal."); int pardiso_msglvl; options.GetIntegerValue("pardiso_msglvl", pardiso_msglvl, prefix); options.GetIntegerValue("pardiso_max_droptol_corrections", pardiso_max_droptol_corrections_, prefix); // Number value = 0.0; // Tell Pardiso to release all memory if it had been used before if (initialized_) { ipfint PHASE = -1; ipfint N = dim_; ipfint NRHS = 0; ipfint ERROR; ipfint idmy; double ddmy; F77_FUNC(pardiso,PARDISO)(PT_, &MAXFCT_, &MNUM_, &MTYPE_, &PHASE, &N, &ddmy, &idmy, &idmy, &idmy, &NRHS, IPARM_, &MSGLVL_, &ddmy, &ddmy, &ERROR, DPARM_) ; DBG_ASSERT(ERROR==0); } // Reset all private data dim_=0; nonzeros_=0; have_symbolic_factorization_=false; initialized_=false; delete[] a_; a_ = NULL; #ifdef HAVE_PARDISO_OLDINTERFACE THROW_EXCEPTION(OPTION_INVALID, "The inexact version works only with a new version of Pardiso (at least 4.0)"); #endif // Call Pardiso's initialization routine IPARM_[0] = 0; // Tell it to fill IPARM with default values(?) ipfint ERROR = 0; ipfint SOLVER = 1; // initialze only direct solver F77_FUNC(pardisoinit,PARDISOINIT)(PT_, &MTYPE_, &SOLVER, IPARM_, DPARM_, &ERROR); // Set some parameters for Pardiso IPARM_[0] = 1; // Don't use the default values #if defined(HAVE_PARDISO_PARALLEL) || ! defined(HAVE_PARDISO) // Obtain the numbers of processors from the value of OMP_NUM_THREADS char *var = getenv("OMP_NUM_THREADS"); int num_procs = 1; if (var != NULL) { sscanf( var, "%d", &num_procs ); if (num_procs < 1) { Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA, "Invalid value for OMP_NUM_THREADS (\"%s\").\n", var); return false; } Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Using environment OMP_NUM_THREADS = %d as the number of processors.\n", num_procs); } #ifdef HAVE_PARDISO // If we run Pardiso through the linear solver loader, // we do not know whether it is the parallel version, so we do not report an error if OMP_NUM_THREADS is not set. else { Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA, "You need to set environment variable OMP_NUM_THREADS to the number of processors used in Pardiso (e.g., 1).\n\n"); return false; } #endif IPARM_[2] = num_procs; // Set the number of processors #else IPARM_[2] = 1; #endif IPARM_[1] = 5; IPARM_[5] = 1; // Overwrite right-hand side // ToDo: decide if we need iterative refinement in Pardiso. For // now, switch it off ? IPARM_[7] = 0; // Options suggested by Olaf Schenk IPARM_[9] = 12; IPARM_[10] = 2; // Results in better scaling // Matching information: IPARM_[12] = 1 seems ok, but results in a // large number of pivot perturbation // Matching information: IPARM_[12] = 2 robust, but more expensive method IPARM_[12] = (int)match_strat_; Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Pardiso matching strategy (IPARM(13)): %d\n", IPARM_[12]); IPARM_[20] = 3; // Results in better accuracy IPARM_[23] = 1; // parallel fac IPARM_[24] = 1; // parallel solve IPARM_[28] = 0; // 32-bit factorization IPARM_[29] = 1; // we need this for IPOPT interface IPARM_[31] = 1 ; // iterative solver MSGLVL_ = pardiso_msglvl; pardiso_iter_dropping_factor_used_ = pardiso_iter_dropping_factor_; pardiso_iter_dropping_schur_used_ = pardiso_iter_dropping_schur_; normal_pardiso_iter_dropping_factor_used_ = normal_pardiso_iter_dropping_factor_; normal_pardiso_iter_dropping_schur_used_ = normal_pardiso_iter_dropping_schur_; // TODO Make option decr_factor_ = 1./3.; // Option for the out of core variant // IPARM_[49] = pardiso_out_of_core_power; SetIpoptCallbackFunction(&IpoptTerminationTest); bool retval = normal_tester_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); if (retval) { retval = pd_tester_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); } return retval; }
bool AdaptiveMuUpdate::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("mu_max_fact", mu_max_fact_, prefix); if (!options.GetNumericValue("mu_max", mu_max_, prefix)) { // Set to a negative value as a hint that this value still has // to be computed mu_max_ = -1.; } options.GetNumericValue("tau_min", tau_min_, prefix); options.GetNumericValue("adaptive_mu_safeguard_factor", adaptive_mu_safeguard_factor_, prefix); options.GetNumericValue("adaptive_mu_kkterror_red_fact", refs_red_fact_, prefix); options.GetIntegerValue("adaptive_mu_kkterror_red_iters", num_refs_max_, prefix); Index enum_int; options.GetEnumValue("adaptive_mu_globalization", enum_int, prefix); adaptive_mu_globalization_ = AdaptiveMuGlobalizationEnum(enum_int); options.GetNumericValue("filter_max_margin", filter_max_margin_, prefix); options.GetNumericValue("filter_margin_fact", filter_margin_fact_, prefix); options.GetBoolValue("adaptive_mu_restore_previous_iterate", restore_accepted_iterate_, prefix); bool retvalue = free_mu_oracle_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); if (!retvalue) { return retvalue; } if (IsValid(fix_mu_oracle_)) { retvalue = fix_mu_oracle_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); if (!retvalue) { return retvalue; } } options.GetNumericValue("adaptive_mu_monotone_init_factor", adaptive_mu_monotone_init_factor_, prefix); options.GetNumericValue("barrier_tol_factor", barrier_tol_factor_, prefix); options.GetNumericValue("mu_linear_decrease_factor", mu_linear_decrease_factor_, prefix); options.GetNumericValue("mu_superlinear_decrease_power", mu_superlinear_decrease_power_, prefix); options.GetEnumValue("quality_function_norm_type", enum_int, prefix); adaptive_mu_kkt_norm_ = QualityFunctionMuOracle::NormEnum(enum_int); options.GetEnumValue("quality_function_centrality", enum_int, prefix); adaptive_mu_kkt_centrality_ = QualityFunctionMuOracle::CentralityEnum(enum_int); options.GetEnumValue("quality_function_balancing_term", enum_int, prefix); adaptive_mu_kkt_balancing_term_ = QualityFunctionMuOracle::BalancingTermEnum(enum_int); options.GetNumericValue("compl_inf_tol", compl_inf_tol_, prefix); if (prefix == "resto.") { if (!options.GetNumericValue("mu_min", mu_min_, prefix)) { // For restoration phase, we choose a more conservative mu_min mu_min_ = 1e2*mu_min_; // Compute mu_min based on tolerance (once the NLP scaling is known) mu_min_default_ = true; } else { mu_min_default_ = false; } } else { if (!options.GetNumericValue("mu_min", mu_min_, prefix)) { // Compute mu_min based on tolerance (once the NLP scaling is known) mu_min_default_ = true; } else { mu_min_default_ = false; } } options.GetNumericValue("mu_target", mu_target_, prefix); init_dual_inf_ = -1.; init_primal_inf_ = -1.; refs_vals_.clear(); check_if_no_bounds_ = false; no_bounds_ = false; filter_.Clear(); IpData().SetFreeMuMode(true); accepted_point_ = NULL; // The following lines are only here so that // IpoptCalculatedQuantities::CalculateSafeSlack and the first // output line have something to work with IpData().Set_mu(1.); IpData().Set_tau(0.); return retvalue; }
bool IpoptAlgorithm::InitializeImpl(const OptionsList& options, const std::string& prefix) { DBG_START_METH("IpoptAlgorithm::InitializeImpl", dbg_verbosity); SmartPtr<const OptionsList> my_options; options.GetBoolValue("mehrotra_algorithm", mehrotra_algorithm_, prefix); if (mehrotra_algorithm_) { // Verify a few options and set a few new ones. But we better // make a copy of the incoming options. SmartPtr<OptionsList> new_options = new OptionsList(options); // Check required options are set correctly std::string string_option; if (new_options->GetStringValue("adaptive_mu_globalization", string_option, prefix)) { ASSERT_EXCEPTION(string_option=="never-monotone-mode", OPTION_INVALID, "If mehrotra_algorithm=yes, adaptive_mu_globalization must be \"never-monotone-mode\"."); } else { new_options->SetStringValue("adaptive_mu_globalization", "never-monotone-mode", false); } // The corrector step is already taken case of in // ComputeSearchDirection below if (new_options->GetStringValue("corrector_type", string_option, prefix)) { ASSERT_EXCEPTION(string_option=="none", OPTION_INVALID, "If mehrotra_algorithm=yes, corrector_type must be \"none\"."); } else { new_options->SetStringValue("corrector_type", "none", false); } if (new_options->GetStringValue("accept_every_trial_step", string_option, prefix)) { ASSERT_EXCEPTION(string_option=="yes", OPTION_INVALID, "If mehrotra_algorithm=yes, accept_every_trial_step must be \"yes\"."); } else { new_options->SetStringValue("accept_every_trial_step", "yes", false); } // Change some default options new_options->SetNumericValueIfUnset("bound_push", 10.); new_options->SetNumericValueIfUnset("bound_frac", 0.2); new_options->SetNumericValueIfUnset("bound_mult_init_val", 10.); new_options->SetNumericValueIfUnset("constr_mult_init_max", 0.); new_options->SetStringValueIfUnset("alpha_for_y", "bound_mult"); new_options->SetStringValueIfUnset("least_square_init_primal", "yes"); my_options = ConstPtr(new_options); } else { my_options = &options; } bool bval; options.GetBoolValue("sb", bval, prefix); if (bval) { copyright_message_printed = true; } // Store which linear solver is chosen for later output options.GetStringValue("linear_solver", linear_solver_, prefix); // Read the IpoptAlgorithm options // Initialize the Data object bool retvalue = IpData().Initialize(Jnlst(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the IpIpoptData object failed to initialize."); // Initialize the CQ object retvalue = IpCq().Initialize(Jnlst(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the IpIpoptCalculatedQuantities object failed to initialize."); // Initialize the NLP object retvalue = IpNLP().Initialize(Jnlst(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the IpIpoptNLP object failed to initialize."); // Initialize all the strategies retvalue = iterate_initializer_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the iterate_initializer strategy failed to initialize."); retvalue = mu_update_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the mu_update strategy failed to initialize."); retvalue = search_dir_calculator_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options,prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the search_direction_calculator strategy failed to initialize."); retvalue = line_search_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), *my_options,prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the line_search strategy failed to initialize."); retvalue = conv_check_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the conv_check strategy failed to initialize."); retvalue = iter_output_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the iter_output strategy failed to initialize."); retvalue = hessian_updater_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), *my_options, prefix); ASSERT_EXCEPTION(retvalue, FAILED_INITIALIZATION, "the hessian_updater strategy failed to initialize."); my_options->GetNumericValue("kappa_sigma", kappa_sigma_, prefix); if (!my_options->GetBoolValue("recalc_y", recalc_y_, prefix)) { Index enum_int; if (my_options->GetEnumValue("hessian_approximation", enum_int, prefix)) { HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { recalc_y_ = true; } } } if (recalc_y_) { my_options->GetNumericValue("recalc_y_feas_tol", recalc_y_feas_tol_, prefix); } if (prefix=="resto.") { skip_print_problem_stats_ = true; } else { skip_print_problem_stats_ = false; } return true; }
SmartPtr<SymLinearSolver> AlgorithmBuilder::SymLinearSolverFactory( const Journalist& jnlst, const OptionsList& options, const std::string& prefix ) { SmartPtr<SparseSymLinearSolverInterface> SolverInterface; std::string linear_solver; options.GetStringValue("linear_solver", linear_solver, prefix); if( linear_solver == "ma27" ) { #ifndef COINHSL_HAS_MA27 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma27TSolverInterface(); if (!LSL_isMA27available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver MA27 not available.\nTried to obtain MA27 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MA27 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma27TSolverInterface(); #endif } else if( linear_solver == "ma57" ) { #ifndef COINHSL_HAS_MA57 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma57TSolverInterface(); if (!LSL_isMA57available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver MA57 not available.\nTried to obtain MA57 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MA57 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma57TSolverInterface(); #endif } else if( linear_solver == "ma77" ) { #ifndef COINHSL_HAS_MA77 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma77SolverInterface(); if (!LSL_isMA77available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA77 not available.\nTried to obtain HSL_MA77 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA77 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma77SolverInterface(); #endif } else if( linear_solver == "ma86" ) { #ifndef COINHSL_HAS_MA86 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma86SolverInterface(); if (!LSL_isMA86available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA86 not available.\nTried to obtain HSL_MA86 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA86 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma86SolverInterface(); #endif } else if( linear_solver == "pardiso" ) { #ifndef HAVE_PARDISO # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new PardisoSolverInterface(); char buf[256]; int rc = LSL_loadPardisoLib(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver Pardiso not available.\nTried to obtain Pardiso from shared library \""; errmsg += LSL_PardisoLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } # else THROW_EXCEPTION(OPTION_INVALID, "Support for Pardiso has not been compiled into Ipopt."); # endif #else SolverInterface = new PardisoSolverInterface(); #endif } else if( linear_solver == "ma97" ) { #ifndef COINHSL_HAS_MA97 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma97SolverInterface(); if (!LSL_isMA97available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA97 not available.\nTried to obtain HSL_MA97 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA97 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma97SolverInterface(); #endif } else if( linear_solver == "wsmp" ) { #ifdef HAVE_WSMP bool wsmp_iterative; options.GetBoolValue("wsmp_iterative", wsmp_iterative, prefix); if (wsmp_iterative) { SolverInterface = new IterativeWsmpSolverInterface(); } else { SolverInterface = new WsmpSolverInterface(); } #else THROW_EXCEPTION(OPTION_INVALID, "Selected linear solver WSMP not available."); #endif } else if( linear_solver == "mumps" ) { #ifdef COIN_HAS_MUMPS SolverInterface = new MumpsSolverInterface(); #else THROW_EXCEPTION(OPTION_INVALID, "Selected linear solver MUMPS not available."); #endif } else if( linear_solver == "custom" ) { SolverInterface = NULL; } SmartPtr<TSymScalingMethod> ScalingMethod; std::string linear_system_scaling; if( !options.GetStringValue("linear_system_scaling", linear_system_scaling, prefix) ) { // By default, don't use mc19 for non-HSL solvers, or HSL_MA97 if( linear_solver != "ma27" && linear_solver != "ma57" && linear_solver != "ma77" && linear_solver != "ma86" ) { linear_system_scaling = "none"; } } if( linear_system_scaling == "mc19" ) { #ifndef COINHSL_HAS_MC19 # ifdef HAVE_LINEARSOLVERLOADER ScalingMethod = new Mc19TSymScalingMethod(); if (!LSL_isMC19available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear system scaling method MC19 not available.\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MC19 has not been compiled into Ipopt."); # endif #else ScalingMethod = new Mc19TSymScalingMethod(); #endif } else if( linear_system_scaling == "slack-based" ) { ScalingMethod = new SlackBasedTSymScalingMethod(); } SmartPtr<SymLinearSolver> ScaledSolver = new TSymLinearSolver(SolverInterface, ScalingMethod); return ScaledSolver; }
bool TSymLinearSolver::InitializeImpl(const OptionsList& options, const std::string& prefix) { if (IsValid(scaling_method_)) { options.GetBoolValue("linear_scaling_on_demand", linear_scaling_on_demand_, prefix); } else { linear_scaling_on_demand_ = false; } // This option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); bool retval; if (HaveIpData()) { retval = solver_interface_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); } else { retval = solver_interface_->ReducedInitialize(Jnlst(), options, prefix); } if (!retval) { return false; } if (!warm_start_same_structure_) { // Reset all private data atag_=TaggedObject::Tag(); dim_=0; nonzeros_triplet_=0; nonzeros_compressed_=0; have_structure_=false; matrix_format_ = solver_interface_->MatrixFormat(); switch (matrix_format_) { case SparseSymLinearSolverInterface::CSR_Format_0_Offset: triplet_to_csr_converter_ = new TripletToCSRConverter(0); break; case SparseSymLinearSolverInterface::CSR_Format_1_Offset: triplet_to_csr_converter_ = new TripletToCSRConverter(1); break; case SparseSymLinearSolverInterface::CSR_Full_Format_0_Offset: triplet_to_csr_converter_ = new TripletToCSRConverter(0, TripletToCSRConverter::Full_Format); break; case SparseSymLinearSolverInterface::CSR_Full_Format_1_Offset: triplet_to_csr_converter_ = new TripletToCSRConverter(1, TripletToCSRConverter::Full_Format); break; case SparseSymLinearSolverInterface::Triplet_Format: triplet_to_csr_converter_ = NULL; break; default: DBG_ASSERT(false && "Invalid MatrixFormat returned from solver interface."); return false; } } else { ASSERT_EXCEPTION(have_structure_, INVALID_WARMSTART, "TSymLinearSolver called with warm_start_same_structure, but the internal structures are not initialized."); } // reset the initialize flag to make sure that InitializeStructure // is called for the linear solver initialized_=false; if (IsValid(scaling_method_) && !linear_scaling_on_demand_) { use_scaling_ = true; } else { use_scaling_ = false; } just_switched_on_scaling_ = false; if (IsValid(scaling_method_)) { if (HaveIpData()) { IpData().TimingStats().LinearSystemScaling().Start(); retval = scaling_method_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); IpData().TimingStats().LinearSystemScaling().End(); } else { retval = scaling_method_->ReducedInitialize(Jnlst(), options, prefix); } } return retval; }
bool WsmpSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetIntegerValue("wsmp_num_threads", wsmp_num_threads_, prefix); Index wsmp_ordering_option; options.GetIntegerValue("wsmp_ordering_option", wsmp_ordering_option, prefix); Index wsmp_ordering_option2; options.GetIntegerValue("wsmp_ordering_option2", wsmp_ordering_option2, prefix); options.GetNumericValue("wsmp_pivtol", wsmp_pivtol_, prefix); if (options.GetNumericValue("wsmp_pivtolmax", wsmp_pivtolmax_, prefix)) { ASSERT_EXCEPTION(wsmp_pivtolmax_>=wsmp_pivtol_, OPTION_INVALID, "Option \"wsmp_pivtolmax\": This value must be between " "wsmp_pivtol and 1."); } else { wsmp_pivtolmax_ = Max(wsmp_pivtolmax_, wsmp_pivtol_); } options.GetNumericValue("wsmp_singularity_threshold", wsmp_singularity_threshold_, prefix); options.GetIntegerValue("wsmp_scaling", wsmp_scaling_, prefix); options.GetIntegerValue("wsmp_write_matrix_iteration", wsmp_write_matrix_iteration_, prefix); options.GetBoolValue("wsmp_skip_inertia_check", skip_inertia_check_, prefix); options.GetBoolValue("wsmp_no_pivoting", wsmp_no_pivoting_, prefix); // Reset all private data dim_=0; initialized_=false; printed_num_threads_ = false; pivtol_changed_ = false; have_symbolic_factorization_ = false; factorizations_since_recomputed_ordering_ = -1; delete[] a_; a_ = NULL; delete[] PERM_; PERM_ = NULL; delete[] INVP_; INVP_ = NULL; delete[] MRP_; MRP_ = NULL; #ifdef PARDISO_MATCHING_PREPROCESS delete[] ia2; ia2 = NULL; delete[] ja2; ja2 = NULL; delete[] a2_; a2_ = NULL; delete[] perm2; perm2 = NULL; delete[] scale2; scale2 = NULL; #endif // Set the number of threads ipfint NTHREADS = wsmp_num_threads_; F77_FUNC(wsetmaxthrds,WSETMAXTHRDS)(&NTHREADS); Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "WSMP will use %d threads.\n", wsmp_num_threads_); // Get WSMP's default parameters and set the ones we want differently IPARM_[0] = 0; IPARM_[1] = 0; IPARM_[2] = 0; ipfint idmy; double ddmy; F77_FUNC(wssmp,WSSMP)(&idmy, &idmy, &idmy, &ddmy, &ddmy, &idmy, &idmy, &ddmy, &idmy, &idmy, &ddmy, &idmy, &idmy, IPARM_, DPARM_); IPARM_[15] = wsmp_ordering_option; // ordering option IPARM_[17] = 0; // use local minimum fill-in ordering IPARM_[19] = wsmp_ordering_option2; // for ordering in IP methods? if (wsmp_no_pivoting_) { IPARM_[30] = 1; // want L D L^T factorization with diagonal no pivoting IPARM_[26] = 1; } else { IPARM_[30] = 2; // want L D L^T factorization with diagonal with pivoting } // pivoting (Bunch/Kaufman) //IPARM_[31] = 1; // need D to see where first negative eigenvalue occurs // if we change this, we need DIAG arguments below! IPARM_[10] = 2; // Mark bad pivots // Set WSMP's scaling option IPARM_[9] = wsmp_scaling_; DPARM_[9] = wsmp_singularity_threshold_; matrix_file_number_ = 0; // Check for SPINLOOPTIME and YIELDLOOPTIME? return true; }
SmartPtr<IpoptAlgorithm> AlgorithmBuilder::BuildBasicAlgorithm(const Journalist& jnlst, const OptionsList& options, const std::string& prefix) { DBG_START_FUN("AlgorithmBuilder::BuildBasicAlgorithm", dbg_verbosity); bool mehrotra_algorithm; options.GetBoolValue("mehrotra_algorithm", mehrotra_algorithm, prefix); // Create the convergence check SmartPtr<ConvergenceCheck> convCheck = new OptimalityErrorConvergenceCheck(); // Create the solvers that will be used by the main algorithm SmartPtr<SparseSymLinearSolverInterface> SolverInterface; std::string linear_solver; options.GetStringValue("linear_solver", linear_solver, prefix); bool use_custom_solver = false; if (linear_solver=="ma27") { #ifndef COINHSL_HAS_MA27 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma27TSolverInterface(); if (!LSL_isMA27available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver MA27 not available.\nTried to obtain MA27 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MA27 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma27TSolverInterface(); #endif } else if (linear_solver=="ma57") { #ifndef COINHSL_HAS_MA57 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma57TSolverInterface(); if (!LSL_isMA57available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver MA57 not available.\nTried to obtain MA57 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MA57 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma57TSolverInterface(); #endif } else if (linear_solver=="ma77") { #ifndef COINHSL_HAS_MA77 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma77SolverInterface(); if (!LSL_isMA77available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA77 not available.\nTried to obtain HSL_MA77 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA77 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma77SolverInterface(); #endif } else if (linear_solver=="ma86") { #ifndef COINHSL_HAS_MA86 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma86SolverInterface(); if (!LSL_isMA86available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA86 not available.\nTried to obtain HSL_MA86 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA86 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma86SolverInterface(); #endif } else if (linear_solver=="pardiso") { #ifndef HAVE_PARDISO # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new PardisoSolverInterface(); char buf[256]; int rc = LSL_loadPardisoLib(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver Pardiso not available.\nTried to obtain Pardiso from shared library \""; errmsg += LSL_PardisoLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } # else THROW_EXCEPTION(OPTION_INVALID, "Support for Pardiso has not been compiled into Ipopt."); # endif #else SolverInterface = new PardisoSolverInterface(); #endif } else if (linear_solver=="ma97") { #ifndef COINHSL_HAS_MA97 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma97SolverInterface(); if (!LSL_isMA97available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA97 not available.\nTried to obtain HSL_MA97 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA97 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma97SolverInterface(); #endif } else if (linear_solver=="wsmp") { #ifdef HAVE_WSMP bool wsmp_iterative; options.GetBoolValue("wsmp_iterative", wsmp_iterative, prefix); if (wsmp_iterative) { SolverInterface = new IterativeWsmpSolverInterface(); } else { SolverInterface = new WsmpSolverInterface(); } #else THROW_EXCEPTION(OPTION_INVALID, "Selected linear solver WSMP not available."); #endif } else if (linear_solver=="mumps") { #ifdef COIN_HAS_MUMPS SolverInterface = new MumpsSolverInterface(); #else THROW_EXCEPTION(OPTION_INVALID, "Selected linear solver MUMPS not available."); #endif } else if (linear_solver=="custom") { ASSERT_EXCEPTION(IsValid(custom_solver_), OPTION_INVALID, "Selected linear solver CUSTOM not available."); use_custom_solver = true; } SmartPtr<AugSystemSolver> AugSolver; if (use_custom_solver) { AugSolver = custom_solver_; } else { SmartPtr<TSymScalingMethod> ScalingMethod; std::string linear_system_scaling; if (!options.GetStringValue("linear_system_scaling", linear_system_scaling, prefix)) { // By default, don't use mc19 for non-HSL solvers, or HSL_MA97 if (linear_solver!="ma27" && linear_solver!="ma57" && linear_solver!="ma77" && linear_solver!="ma86") { linear_system_scaling="none"; } } if (linear_system_scaling=="mc19") { #ifndef COINHSL_HAS_MC19 # ifdef HAVE_LINEARSOLVERLOADER ScalingMethod = new Mc19TSymScalingMethod(); if (!LSL_isMC19available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear system scaling method MC19 not available.\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MC19 has not been compiled into Ipopt."); # endif #else ScalingMethod = new Mc19TSymScalingMethod(); #endif } else if (linear_system_scaling=="slack-based") { ScalingMethod = new SlackBasedTSymScalingMethod(); } SmartPtr<SymLinearSolver> ScaledSolver = new TSymLinearSolver(SolverInterface, ScalingMethod); AugSolver = new StdAugSystemSolver(*ScaledSolver); } Index enum_int; options.GetEnumValue("hessian_approximation", enum_int, prefix); HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { std::string lm_aug_solver; options.GetStringValue("limited_memory_aug_solver", lm_aug_solver, prefix); if (lm_aug_solver == "sherman-morrison") { AugSolver = new LowRankAugSystemSolver(*AugSolver); } else if (lm_aug_solver == "extended") { Index lm_history; options.GetIntegerValue("limited_memory_max_history", lm_history, prefix); Index max_rank; std::string lm_type; options.GetStringValue("limited_memory_update_type", lm_type, prefix); if (lm_type == "bfgs") { max_rank = 2*lm_history; } else if (lm_type == "sr1") { max_rank = lm_history; } else { THROW_EXCEPTION(OPTION_INVALID, "Unknown value for option \"limited_memory_update_type\"."); } AugSolver = new LowRankSSAugSystemSolver(*AugSolver, max_rank); } else { THROW_EXCEPTION(OPTION_INVALID, "Unknown value for option \"limited_memory_aug_solver\"."); } } SmartPtr<PDPerturbationHandler> pertHandler; std::string lsmethod; options.GetStringValue("line_search_method", lsmethod, prefix); if (lsmethod=="cg-penalty") { pertHandler = new CGPerturbationHandler(); } else { pertHandler = new PDPerturbationHandler(); } SmartPtr<PDSystemSolver> PDSolver = new PDFullSpaceSolver(*AugSolver, *pertHandler); // Create the object for initializing the iterates Initialization // object. We include both the warm start and the defaut // initializer, so that the warm start options can be activated // without having to rebuild the algorithm SmartPtr<EqMultiplierCalculator> EqMultCalculator = new LeastSquareMultipliers(*AugSolver); SmartPtr<IterateInitializer> WarmStartInitializer = new WarmStartIterateInitializer(); SmartPtr<IterateInitializer> IterInitializer = new DefaultIterateInitializer(EqMultCalculator, WarmStartInitializer, AugSolver); SmartPtr<RestorationPhase> resto_phase; SmartPtr<RestoConvergenceCheck> resto_convCheck; // We only need a restoration phase object if we use the filter // line search if (lsmethod=="filter" || lsmethod=="penalty") { // Solver for the restoration phase SmartPtr<AugSystemSolver> resto_AugSolver = new AugRestoSystemSolver(*AugSolver); SmartPtr<PDPerturbationHandler> resto_pertHandler = new PDPerturbationHandler(); SmartPtr<PDSystemSolver> resto_PDSolver = new PDFullSpaceSolver(*resto_AugSolver, *resto_pertHandler); // Convergence check in the restoration phase if (lsmethod=="filter") { resto_convCheck = new RestoFilterConvergenceCheck(); } else if (lsmethod=="penalty") { resto_convCheck = new RestoPenaltyConvergenceCheck(); } // Line search method for the restoration phase SmartPtr<RestoRestorationPhase> resto_resto = new RestoRestorationPhase(); SmartPtr<BacktrackingLSAcceptor> resto_LSacceptor; std::string resto_lsacceptor; options.GetStringValue("line_search_method", resto_lsacceptor, "resto."+prefix); if (resto_lsacceptor=="filter") { resto_LSacceptor = new FilterLSAcceptor(GetRawPtr(resto_PDSolver)); } else if (resto_lsacceptor=="cg-penalty") { resto_LSacceptor = new CGPenaltyLSAcceptor(GetRawPtr(resto_PDSolver)); } else if (resto_lsacceptor=="penalty") { resto_LSacceptor = new PenaltyLSAcceptor(GetRawPtr(resto_PDSolver)); } SmartPtr<LineSearch> resto_LineSearch = new BacktrackingLineSearch(resto_LSacceptor, GetRawPtr(resto_resto), GetRawPtr(resto_convCheck)); // Create the mu update that will be used by the restoration phase // algorithm SmartPtr<MuUpdate> resto_MuUpdate; std::string resto_smuupdate; if (!options.GetStringValue("mu_strategy", resto_smuupdate, "resto."+prefix)) { // Change default for quasi-Newton option (then we use adaptive) Index enum_int; if (options.GetEnumValue("hessian_approximation", enum_int, prefix)) { HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { resto_smuupdate = "adaptive"; } } } std::string resto_smuoracle; std::string resto_sfixmuoracle; if (resto_smuupdate=="adaptive" ) { options.GetStringValue("mu_oracle", resto_smuoracle, "resto."+prefix); options.GetStringValue("fixed_mu_oracle", resto_sfixmuoracle, "resto."+prefix); } if (resto_smuupdate=="monotone" ) { resto_MuUpdate = new MonotoneMuUpdate(GetRawPtr(resto_LineSearch)); } else if (resto_smuupdate=="adaptive") { SmartPtr<MuOracle> resto_MuOracle; if (resto_smuoracle=="loqo") { resto_MuOracle = new LoqoMuOracle(); } else if (resto_smuoracle=="probing") { resto_MuOracle = new ProbingMuOracle(resto_PDSolver); } else if (resto_smuoracle=="quality-function") { resto_MuOracle = new QualityFunctionMuOracle(resto_PDSolver); } SmartPtr<MuOracle> resto_FixMuOracle; if (resto_sfixmuoracle=="loqo") { resto_FixMuOracle = new LoqoMuOracle(); } else if (resto_sfixmuoracle=="probing") { resto_FixMuOracle = new ProbingMuOracle(resto_PDSolver); } else if (resto_sfixmuoracle=="quality-function") { resto_FixMuOracle = new QualityFunctionMuOracle(resto_PDSolver); } else { resto_FixMuOracle = NULL; } resto_MuUpdate = new AdaptiveMuUpdate(GetRawPtr(resto_LineSearch), resto_MuOracle, resto_FixMuOracle); } // Initialization of the iterates for the restoration phase SmartPtr<EqMultiplierCalculator> resto_EqMultCalculator = new LeastSquareMultipliers(*resto_AugSolver); SmartPtr<IterateInitializer> resto_IterInitializer = new RestoIterateInitializer(resto_EqMultCalculator); // Create the object for the iteration output during restoration SmartPtr<OrigIterationOutput> resto_OrigIterOutput = NULL; // new OrigIterationOutput(); SmartPtr<IterationOutput> resto_IterOutput = new RestoIterationOutput(resto_OrigIterOutput); // Get the Hessian updater for the restoration phase SmartPtr<HessianUpdater> resto_HessUpdater; switch (hessian_approximation) { case EXACT: resto_HessUpdater = new ExactHessianUpdater(); break; case LIMITED_MEMORY: // ToDo This needs to be replaced! resto_HessUpdater = new LimMemQuasiNewtonUpdater(true); break; } // Put together the overall restoration phase IP algorithm SmartPtr<SearchDirectionCalculator> resto_SearchDirCalc; if (resto_lsacceptor=="cg-penalty") { resto_SearchDirCalc = new CGSearchDirCalculator(GetRawPtr(resto_PDSolver)); } else { resto_SearchDirCalc = new PDSearchDirCalculator(GetRawPtr(resto_PDSolver)); } SmartPtr<IpoptAlgorithm> resto_alg = new IpoptAlgorithm(resto_SearchDirCalc, GetRawPtr(resto_LineSearch), GetRawPtr(resto_MuUpdate), GetRawPtr(resto_convCheck), resto_IterInitializer, resto_IterOutput, resto_HessUpdater, resto_EqMultCalculator); // Set the restoration phase resto_phase = new MinC_1NrmRestorationPhase(*resto_alg, EqMultCalculator); } // Create the line search to be used by the main algorithm SmartPtr<BacktrackingLSAcceptor> LSacceptor; if (lsmethod=="filter") { LSacceptor = new FilterLSAcceptor(GetRawPtr(PDSolver)); } else if (lsmethod=="cg-penalty") { LSacceptor = new CGPenaltyLSAcceptor(GetRawPtr(PDSolver)); } else if (lsmethod=="penalty") { LSacceptor = new PenaltyLSAcceptor(GetRawPtr(PDSolver)); } SmartPtr<LineSearch> lineSearch = new BacktrackingLineSearch(LSacceptor, GetRawPtr(resto_phase), convCheck); // The following cross reference is not good: We have to store a // pointer to the lineSearch object in resto_convCheck as a // non-SmartPtr to make sure that things are properly deleted when // the IpoptAlgorithm return by the Builder is destructed. if (IsValid(resto_convCheck)) { resto_convCheck->SetOrigLSAcceptor(*LSacceptor); } // Create the mu update that will be used by the main algorithm SmartPtr<MuUpdate> MuUpdate; std::string smuupdate; if (!options.GetStringValue("mu_strategy", smuupdate, prefix)) { // Change default for quasi-Newton option (then we use adaptive) Index enum_int; if (options.GetEnumValue("hessian_approximation", enum_int, prefix)) { HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { smuupdate = "adaptive"; } } if (mehrotra_algorithm) smuupdate = "adaptive"; } ASSERT_EXCEPTION(!mehrotra_algorithm || smuupdate=="adaptive", OPTION_INVALID, "If mehrotra_algorithm=yes, mu_strategy must be \"adaptive\"."); std::string smuoracle; std::string sfixmuoracle; if (smuupdate=="adaptive" ) { if (!options.GetStringValue("mu_oracle", smuoracle, prefix)) { if (mehrotra_algorithm) smuoracle = "probing"; } options.GetStringValue("fixed_mu_oracle", sfixmuoracle, prefix); ASSERT_EXCEPTION(!mehrotra_algorithm || smuoracle=="probing", OPTION_INVALID, "If mehrotra_algorithm=yes, mu_oracle must be \"probing\"."); } if (smuupdate=="monotone" ) { MuUpdate = new MonotoneMuUpdate(GetRawPtr(lineSearch)); } else if (smuupdate=="adaptive") { SmartPtr<MuOracle> muOracle; if (smuoracle=="loqo") { muOracle = new LoqoMuOracle(); } else if (smuoracle=="probing") { muOracle = new ProbingMuOracle(PDSolver); } else if (smuoracle=="quality-function") { muOracle = new QualityFunctionMuOracle(PDSolver); } SmartPtr<MuOracle> FixMuOracle; if (sfixmuoracle=="loqo") { FixMuOracle = new LoqoMuOracle(); } else if (sfixmuoracle=="probing") { FixMuOracle = new ProbingMuOracle(PDSolver); } else if (sfixmuoracle=="quality-function") { FixMuOracle = new QualityFunctionMuOracle(PDSolver); } else { FixMuOracle = NULL; } MuUpdate = new AdaptiveMuUpdate(GetRawPtr(lineSearch), muOracle, FixMuOracle); } // Create the object for the iteration output SmartPtr<IterationOutput> IterOutput = new OrigIterationOutput(); // Get the Hessian updater for the main algorithm SmartPtr<HessianUpdater> HessUpdater; switch (hessian_approximation) { case EXACT: HessUpdater = new ExactHessianUpdater(); break; case LIMITED_MEMORY: // ToDo This needs to be replaced! HessUpdater = new LimMemQuasiNewtonUpdater(false); break; } // Create the main algorithm SmartPtr<SearchDirectionCalculator> SearchDirCalc; if (lsmethod=="cg-penalty") { SearchDirCalc = new CGSearchDirCalculator(GetRawPtr(PDSolver)); } else { SearchDirCalc = new PDSearchDirCalculator(GetRawPtr(PDSolver)); } SmartPtr<IpoptAlgorithm> alg = new IpoptAlgorithm(SearchDirCalc, GetRawPtr(lineSearch), MuUpdate, convCheck, IterInitializer, IterOutput, HessUpdater, EqMultCalculator); return alg; }
bool Ma57TSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { // Obtain the options settings options.GetNumericValue("ma57_pivtol", pivtol_, prefix); if (options.GetNumericValue("ma57_pivtolmax", pivtolmax_, prefix)) { ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID, "Option \"pivtolmax\": This value must be between " "pivtol and 1."); } else { pivtolmax_ = Max(pivtolmax_, pivtol_); } options.GetNumericValue("ma57_pre_alloc", ma57_pre_alloc_, prefix); Index ma57_pivot_order; options.GetIntegerValue("ma57_pivot_order", ma57_pivot_order, prefix); // The following option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); DBG_ASSERT(!warm_start_same_structure_ && "warm_start_same_structure not yet implemented"); bool ma57_automatic_scaling; options.GetBoolValue("ma57_automatic_scaling", ma57_automatic_scaling, prefix); // CET 04-29-2010 Index ma57_block_size; options.GetIntegerValue("ma57_block_size", ma57_block_size, prefix); Index ma57_node_amalgamation; options.GetIntegerValue("ma57_node_amalgamation", ma57_node_amalgamation, prefix); Index ma57_small_pivot_flag; options.GetIntegerValue("ma57_small_pivot_flag", ma57_small_pivot_flag, prefix); // CET 04-29-2010 /* Initialize. */ F77_FUNC (ma57id, MA57ID) (wd_cntl_, wd_icntl_); /* Custom settings for MA57. */ wd_icntl_[1-1] = 0; /* Error stream */ wd_icntl_[2-1] = 0; /* Warning stream. */ wd_icntl_[4-1] = 1; /* Print statistics. NOT Used. */ wd_icntl_[5-1] = 0; /* Print error. */ wd_icntl_[6-1] = ma57_pivot_order; /* Pivoting order. */ wd_cntl_[1-1] = pivtol_; /* Pivot threshold. */ wd_icntl_[7-1] = 1; /* Pivoting strategy. */ // CET: Added 04-29-2010 at suggestion of Jonathan Hogg of HSL wd_icntl_[11-1] = ma57_block_size; /* Block size used by Level 3 BLAS in MA57BD - should be a multiple of 8. Default is 16. */ wd_icntl_[12-1] = ma57_node_amalgamation; /* Two nodes of the assembly tree are merged only if both involve less than ICNTL(12) eliminations. Default is 16. */ // CET: 04-29-2010 if (ma57_automatic_scaling) { wd_icntl_[15-1] = 1; } else { wd_icntl_[15-1] = 0; } // CET: Added 04-29-2010 at suggestion of Jonathan Hogg of HSL wd_icntl_[16-1] = ma57_small_pivot_flag; /* If set to 1, small entries are removed and corresponding pivots are placed at the end of factorization. May be useful for highly rank deficient matrices. Default is 0. */ // CET: 04-29-2010 // wd_icntl[8-1] = 0; /* Retry factorization. */ if (!warm_start_same_structure_) { dim_=0; nonzeros_=0; delete [] a_; a_ = NULL; delete [] wd_fact_; wd_fact_ = NULL; delete [] wd_ifact_; wd_ifact_ = NULL; delete [] wd_iwork_; wd_iwork_ = NULL; delete [] wd_keep_; wd_keep_ = NULL; } else { ASSERT_EXCEPTION(dim_>0 && nonzeros_>0, INVALID_WARMSTART, "Ma57TSolverInterface called with warm_start_same_structure, " "but the problem is solved for the first time."); } return true; }
virtual bool InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("sens_boundcheck", do_boundcheck_, prefix); return true; }
bool PardisoSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { Index enum_int; options.GetEnumValue("pardiso_matching_strategy", enum_int, prefix); match_strat_ = PardisoMatchingStrategy(enum_int); options.GetBoolValue("pardiso_redo_symbolic_fact_only_if_inertia_wrong", pardiso_redo_symbolic_fact_only_if_inertia_wrong_, prefix); options.GetBoolValue("pardiso_repeated_perturbation_means_singular", pardiso_repeated_perturbation_means_singular_, prefix); //Index pardiso_out_of_core_power; //options.GetIntegerValue("pardiso_out_of_core_power", // pardiso_out_of_core_power, prefix); options.GetBoolValue("pardiso_skip_inertia_check", skip_inertia_check_, prefix); int pardiso_msglvl; options.GetIntegerValue("pardiso_msglvl", pardiso_msglvl, prefix); int max_iterref_steps; options.GetIntegerValue("pardiso_max_iterative_refinement_steps", max_iterref_steps, prefix); int order; options.GetEnumValue("pardiso_order", order, prefix); #if !defined(HAVE_PARDISO_OLDINTERFACE) && !defined(HAVE_PARDISO_MKL) options.GetBoolValue("pardiso_iterative", pardiso_iterative_, prefix); int pardiso_max_iter; options.GetIntegerValue("pardiso_max_iter", pardiso_max_iter, prefix); Number pardiso_iter_relative_tol; options.GetNumericValue("pardiso_iter_relative_tol", pardiso_iter_relative_tol, prefix); Index pardiso_iter_coarse_size; options.GetIntegerValue("pardiso_iter_coarse_size", pardiso_iter_coarse_size, prefix); Index pardiso_iter_max_levels; options.GetIntegerValue("pardiso_iter_max_levels", pardiso_iter_max_levels, prefix); Number pardiso_iter_dropping_factor; options.GetNumericValue("pardiso_iter_dropping_factor", pardiso_iter_dropping_factor, prefix); Number pardiso_iter_dropping_schur; options.GetNumericValue("pardiso_iter_dropping_schur", pardiso_iter_dropping_schur, prefix); Index pardiso_iter_max_row_fill; options.GetIntegerValue("pardiso_iter_max_row_fill", pardiso_iter_max_row_fill, prefix); Number pardiso_iter_inverse_norm_factor; options.GetNumericValue("pardiso_iter_inverse_norm_factor", pardiso_iter_inverse_norm_factor, prefix); options.GetIntegerValue("pardiso_max_droptol_corrections", pardiso_max_droptol_corrections_, prefix); #else pardiso_iterative_ = false; #endif // Number value = 0.0; // Tell Pardiso to release all memory if it had been used before if (initialized_) { ipfint PHASE = -1; ipfint N = dim_; ipfint NRHS = 0; ipfint ERROR; ipfint idmy; double ddmy; PARDISO_FUNC(PT_, &MAXFCT_, &MNUM_, &MTYPE_, &PHASE, &N, &ddmy, &idmy, &idmy, &idmy, &NRHS, IPARM_, &MSGLVL_, &ddmy, &ddmy, &ERROR, DPARM_); DBG_ASSERT(ERROR==0); } // Reset all private data dim_=0; nonzeros_=0; have_symbolic_factorization_=false; initialized_=false; delete[] a_; a_ = NULL; #ifdef PARDISO_MATCHING_PREPROCESS delete[] ia2; ia2 = NULL; delete[] ja2; ja2 = NULL; delete[] a2_; a2_ = NULL; delete[] perm2; perm2 = NULL; delete[] scale2; scale2 = NULL; #endif // Call Pardiso's initialization routine IPARM_[0] = 0; // Tell it to fill IPARM with default values(?) #if ! defined(HAVE_PARDISO_OLDINTERFACE) && ! defined(HAVE_PARDISO_MKL) ipfint ERROR = 0; ipfint SOLVER = 0; // initialize only direct solver PARDISOINIT_FUNC(PT_, &MTYPE_, &SOLVER, IPARM_, DPARM_, &ERROR); #else PARDISOINIT_FUNC(PT_, &MTYPE_, IPARM_); #endif // Set some parameters for Pardiso IPARM_[0] = 1; // Don't use the default values int num_procs = 1; #if defined(HAVE_PARDISO_PARALLEL) || ! defined(HAVE_PARDISO) // Obtain the numbers of processors from the value of OMP_NUM_THREADS char* var = getenv("OMP_NUM_THREADS"); if (var != NULL) { sscanf( var, "%d", &num_procs ); if (num_procs < 1) { Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA, "Invalid value for OMP_NUM_THREADS (\"%s\").\n", var); return false; } Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Using environment OMP_NUM_THREADS = %d as the number of processors for PARDISO.\n", num_procs); } #if defined(HAVE_PARDISO) && ! defined(HAVE_PARDISO_MKL) // If we run Pardiso through the linear solver loader, // we do not know whether it is the parallel version, so we do not report a warning if OMP_NUM_THREADS is not set. // If we run Pardiso from MKL, then OMP_NUM_THREADS does not need to be set, so no warning. else { Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "You should set the environment variable OMP_NUM_THREADS to the number of processors used in Pardiso (e.g., 1).\n\n"); } #endif #endif #ifdef HAVE_PARDISO_MKL IPARM_[1] = order; // For MKL PARDSIO, the documentation says, "iparm(3) Reserved. Set to zero.", so we don't set IPARM_[2] IPARM_[5] = 1; // Overwrite right-hand side IPARM_[7] = max_iterref_steps; IPARM_[9] = 12; // pivot perturbation (as higher as less perturbation) IPARM_[10] = 2; // enable scaling (recommended for interior-point indefinite matrices) IPARM_[12] = (int)match_strat_; // enable matching (recommended, as above) IPARM_[20] = 3; // bunch-kaufman pivoting IPARM_[23] = 1; // parallel fac IPARM_[24] = 1; // parallel solve //IPARM_[26] = 1; // matrix checker #else IPARM_[1] = order; IPARM_[2] = num_procs; // Set the number of processors IPARM_[5] = 1; // Overwrite right-hand side IPARM_[7] = max_iterref_steps; // Options suggested by Olaf Schenk IPARM_[9] = 12; IPARM_[10] = 2; // Results in better scaling // Matching information: IPARM_[12] = 1 seems ok, but results in a // large number of pivot perturbation // Matching information: IPARM_[12] = 2 robust, but more expensive method IPARM_[12] = (int)match_strat_; IPARM_[20] = 3; // Results in better accuracy IPARM_[23] = 1; // parallel fac IPARM_[24] = 1; // parallel solve IPARM_[28] = 0; // 32-bit factorization IPARM_[29] = 1; //we need this for IPOPT interface //IPARM_[33] = 1; // bit-by-bit identical results in parallel run #endif Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Pardiso matrix ordering (IPARM(2)): %d\n", IPARM_[1]); Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Pardiso max. iterref. steps (IPARM(8)): %d\n", IPARM_[7]); Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Pardiso matching strategy (IPARM(13)): %d\n", IPARM_[12]); if (pardiso_iterative_) { #if defined(HAVE_PARDISO_OLDINTERFACE) || defined(HAVE_PARDISO_MKL) THROW_EXCEPTION(OPTION_INVALID, "You chose to use the iterative version of Pardiso, but you need to use a Pardiso version of at least 4.0."); #else IPARM_[31] = 1 ; // active direct solver DPARM_[ 0] = pardiso_max_iter; // maximum number of Krylov-Subspace Iteration // Default is 300 // 1 <= value <= e.g. 1000 DPARM_[ 1] = pardiso_iter_relative_tol; // Relative Residual Convergence // e.g. pardiso_iter_tol // Default is 1e-6 // 1e-16 <= value < 1 DPARM_[ 2] = pardiso_iter_coarse_size; // Maximum Size of Coarse Grid Matrix // e.g. pardiso_coarse_grid // Default is 5000 // 1 <= value < number of equations DPARM_[ 3] = pardiso_iter_max_levels; // Maximum Number of Grid Levels // e.g. pardiso_max_grid // Default is 10000 // 1 <= value < number of equations DPARM_[ 4] = pardiso_iter_dropping_factor; // dropping value for incomplete factor // e.g. pardiso_dropping_factor // Default is 0.5 // 1e-16 <= value < 1 DPARM_[ 5] = pardiso_iter_dropping_schur; // dropping value for sparsify schur complementfactor // e.g. pardiso_dropping_schur // Default is 0.1 // 1e-16 <= value < 1 DPARM_[ 6] = pardiso_iter_max_row_fill; // max fill for each row // e.g. pardiso_max_fill // Default is 1000 // 1 <= value < 100000 DPARM_[ 7] = pardiso_iter_inverse_norm_factor; // dropping value for sparsify schur complementfactor // e.g. pardiso_inverse_norm_factor // Default is 500 // 2 <= value < 50000 DPARM_[ 8] = 25; // maximum number of non-improvement steps #endif } MSGLVL_ = pardiso_msglvl; // Option for the out of core variant //IPARM_[49] = pardiso_out_of_core_power; return true; }