OptimumOptions.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright (C) 2014-2018 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library. If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// Reaktoro includes
#include <Reaktoro/Common/Outputter.hpp>
#include <Reaktoro/Math/LU.hpp>
#include <Reaktoro/Optimization/KktSolver.hpp>
#include <Reaktoro/Optimization/Regularizer.hpp>
 
namespace Reaktoro {
 
enum StepMode
{
    Conservative,
 
    Aggressive
};
 
struct OptimumParamsActNewton
{
    double threshold = 1.0e-14;
};
 
struct OptimumParamsIpAction
{
    double mu = 1.0e-20;
 
    double tau = 0.99;
 
    StepMode step = Aggressive;
};
 
struct OptimumParamsIpNewton
{
    double mu = 1.0e-20;
 
    double tau = 0.99;
 
    StepMode step = Aggressive;
};
 
struct OptimumParamsIpActive
{
    double epsilon = 1e-20;
 
    double tau = 1e-5;
};
 
struct OptimumParamsIpOpt
{
    std::vector<double> mu = std::vector<double>({1e-8, 1e-16}); // need explicit initialization list to compile in MSVC 2013
 
    double delta = 1.0;
    double eta_phi = 1.0e-4;
    double gamma_alpha = 0.05;
    double gamma_phi = 1.0e-5;
    double gamma_theta = 1.0e-5;
    double kappa_epsilon = 10.0;
    double kappa_mu = 0.2;
    double kappa_sigma = 1.0e+10;
    double kappa_soc = 0.99;
    double s_phi = 2.3;
    double s_theta = 1.1;
    double tau_min = 0.9999;
    double theta_mu = 2.0;
    unsigned max_iters_soc = 4;
    bool soc = true;
 
    double mux = 1.0e-5;
 
    bool scaling = true;
};
 
struct OptimumParamsKarpov
{
    double line_search_max_iterations = 3;
 
    double line_search_wolfe = 1.0e-4;
 
    // The fraction-to-the-boundary factor used in the feasible step
    double tau_feasible = 0.99;
 
    // The fraction-to-the-boundary factor used in the descent step
    double tau_descent = 0.9999;
 
    double feasibility_tolerance = 1.0e-13;
 
    double negative_dual_tolerance = -1.0e-2;
 
    double active_to_inactive = 1.0e-6;
 
    bool use_kkt_solver = false;
};
 
struct OptimumParamsRefiner
{
    bool use_lma_setup = true;
};
 
struct OptimumOutputOptions : OutputterOptions
{
    std::string xprefix = "x";
 
    std::string yprefix = "y";
 
    std::string zprefix = "z";
 
    std::vector<std::string> xnames;
 
    std::vector<std::string> ynames;
 
    std::vector<std::string> znames;
 
    auto operator=(bool active) -> OptimumOutputOptions&;
};
 
struct OptimumParamsRegularization : RegularizerOptions
{
    double delta = 0.0;
 
    double gamma = 0.0;
};
 
struct OptimumOptions
{
    double tolerance = 1.0e-6;
 
    double tolerancex = 0.0;
 
    double tolerancef = 0.0;
 
    double tolerance_linear_constraints = 1.0e-14;
 
    unsigned max_iterations = 200;
 
    OptimumOutputOptions output;
 
    OptimumParamsActNewton actnewton;
 
    OptimumParamsIpAction ipaction;
 
    OptimumParamsIpOpt ipopt;
 
    OptimumParamsIpNewton ipnewton;
 
    OptimumParamsIpActive ipactive;
 
    OptimumParamsKarpov karpov;
 
    OptimumParamsRefiner refiner;
 
    OptimumParamsRegularization regularization;
 
    KktOptions kkt;
};
 
} // namespace Reaktoro