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;
}
