MathLib::LinearSolverOptionsParser< EigenLinearSolver > Struct Reference

Detailed Description

Definition at line 25 of file LinearSolverOptionsParser.h.

#include <LinearSolverOptionsParser.h>

Public Member Functions
std::tuple< std::string, EigenOption >	parseNameAndOptions (std::string const &prefix, BaseLib::ConfigTree const *const solver_config) const

Member Function Documentation

parseNameAndOptions()

std::tuple< std::string, EigenOption > MathLib::LinearSolverOptionsParser< EigenLinearSolver >::parseNameAndOptions	(	std::string const &	prefix,
		BaseLib::ConfigTree const *const	solver_config ) const

The method parses the linear solver options for Eigen.

Parameters

prefix	the prefix for the linear solver to distinguish different linear solvers for instance in the staggered schema
solver_config	the part of the property tree (usually created from the linear solver section in the project file)

Returns

the first item of the returned tuple is the solver prefix as string, the second item are all the options as an EigenOption object

Input File Parameter

prj__linear_solvers__linear_solver__eigen

Input File Parameter

prj__linear_solvers__linear_solver__eigen__solver_type

Input File Parameter

prj__linear_solvers__linear_solver__eigen__precon_type

Input File Parameter

prj__linear_solvers__linear_solver__eigen__error_tolerance

Input File Parameter

prj__linear_solvers__linear_solver__eigen__max_iteration_step

Input File Parameter

prj__linear_solvers__linear_solver__eigen__scaling

Input File Parameter

prj__linear_solvers__linear_solver__eigen__restart

Input File Parameter

prj__linear_solvers__linear_solver__eigen__l

Input File Parameter

prj__linear_solvers__linear_solver__eigen__s

Input File Parameter

prj__linear_solvers__linear_solver__eigen__smoothing

Input File Parameter

prj__linear_solvers__linear_solver__eigen__angle

Input File Parameter

prj__linear_solvers__linear_solver__eigen__residual_update

Definition at line 20 of file LinearSolverOptionsParser.cpp.

{
    if (!solver_config)
    {
        return {prefix, EigenOption{}};
    }
 
    ignoreOtherLinearSolvers(*solver_config, "eigen");
    auto const config = solver_config->getConfigSubtreeOptional("eigen");
    if (!config)
    {
        OGS_FATAL(
            "OGS was compiled with Eigen but the config section in the "
            "project file seems to be invalid");
    }
 
    EigenOption options;
 
    if (auto solver_type =
        config->getConfigParameterOptional<std::string>("solver_type"))
    {
        options.solver_type = MathLib::EigenOption::getSolverType(*solver_type);
    }
    if (auto precon_type =
        config->getConfigParameterOptional<std::string>("precon_type"))
    {
        options.precon_type = MathLib::EigenOption::getPreconType(*precon_type);
    }
    if (auto error_tolerance =
        config->getConfigParameterOptional<double>("error_tolerance"))
    {
        options.error_tolerance = *error_tolerance;
    }
    if (auto max_iteration_step =
        config->getConfigParameterOptional<int>("max_iteration_step"))
    {
        options.max_iterations = *max_iteration_step;
    }
    if (auto scaling =
        config->getConfigParameterOptional<bool>("scaling"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.scaling = *scaling;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules. "
            "scaling is not available.");
#endif
    }
    if (auto restart =
        config->getConfigParameterOptional<int>("restart"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.restart = *restart;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules. "
            "GMRES/GMRES option restart is not available.");
#endif
    }
    if (auto l =
        config->getConfigParameterOptional<int>("l"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.l = *l;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules.");
#endif
    }
    if (auto s =
        config->getConfigParameterOptional<int>("s"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.s = *s;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules.");
#endif
    }
    if (auto smoothing =
        config->getConfigParameterOptional<int>("smoothing"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.smoothing = *smoothing;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules.");
#endif
    }
    if (auto angle =
        config->getConfigParameterOptional<int>("angle"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.angle = *angle;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules.");
#endif
    }
    if (auto residualupdate =
        config->getConfigParameterOptional<int>("residual_update"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        options.residualupdate = *residualupdate;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules.");
#endif
    }
    return {prefix, options};
}

References MathLib::EigenOption::error_tolerance, BaseLib::ConfigTree::getConfigSubtreeOptional(), MathLib::EigenOption::getPreconType(), MathLib::EigenOption::getSolverType(), MathLib::ignoreOtherLinearSolvers(), MathLib::EigenOption::max_iterations, OGS_FATAL, MathLib::EigenOption::precon_type, MathLib::s, and MathLib::EigenOption::solver_type.

---

The documentation for this struct was generated from the following files:

• MathLib/LinAlg/Eigen/LinearSolverOptionsParser.h
• MathLib/LinAlg/Eigen/LinearSolverOptionsParser.cpp