MathLib::EigenLinearSolver Class Reference

Detailed Description

Definition at line 30 of file EigenLinearSolver.h.

#include <EigenLinearSolver.h>

Collaboration diagram for MathLib::EigenLinearSolver:

Public Member Functions
	EigenLinearSolver (const std::string &solver_name, BaseLib::ConfigTree const *const option)
	~EigenLinearSolver ()
void	setOption (const BaseLib::ConfigTree &option)
void	setOption (const EigenOption &option)
EigenOption &	getOption ()
bool	solve (EigenMatrix &A, EigenVector &b, EigenVector &x)

Protected Member Functions
void	setRestart ()

Protected Attributes
EigenOption	option_
std::unique_ptr< EigenLinearSolverBase >	solver_

Constructor & Destructor Documentation

EigenLinearSolver()

MathLib::EigenLinearSolver::EigenLinearSolver	(	const std::string &	solver_name,
		BaseLib::ConfigTree const *const	option
	)

Constructor

Parameters

solver_name	A name used as a prefix for command line options if there are such options available.
option	A pointer to a linear solver option. In case you omit this argument, default settings follow those of LisOption struct.

Definition at line 222 of file EigenLinearSolver.cpp.

{
    using Matrix = EigenMatrix::RawMatrixType;
 
    if (option)
    {
        setOption(*option);
    }
 
    // TODO for my taste it is much too unobvious that the default solver type
    //      currently is SparseLU.
    switch (option_.solver_type)
    {
        case EigenOption::SolverType::SparseLU:
        {
            using SolverType =
                Eigen::SparseLU<Matrix, Eigen::COLAMDOrdering<int>>;
            solver_ = std::make_unique<
                details::EigenDirectLinearSolver<SolverType>>();
            return;
        }
        case EigenOption::SolverType::BiCGSTAB:
        case EigenOption::SolverType::CG:
        case EigenOption::SolverType::GMRES:
            solver_ = details::createIterativeSolver(option_.solver_type,
                                                     option_.precon_type);
            return;
        case EigenOption::SolverType::PardisoLU:
        {
#ifdef USE_MKL
            using SolverType = Eigen::PardisoLU<EigenMatrix::RawMatrixType>;
            solver_.reset(new details::EigenDirectLinearSolver<SolverType>);
            return;
#else
            OGS_FATAL(
                "The code is not compiled with Intel MKL. Linear solver type "
                "PardisoLU is not available.");
#endif
        }
    }
 
    OGS_FATAL("Invalid Eigen linear solver type. Aborting.");
}

References MathLib::EigenOption::BiCGSTAB, MathLib::EigenOption::CG, MathLib::details::createIterativeSolver(), MathLib::EigenOption::GMRES, OGS_FATAL, option_, MathLib::EigenOption::PardisoLU, MathLib::EigenOption::precon_type, setOption(), solver_, MathLib::EigenOption::solver_type, and MathLib::EigenOption::SparseLU.

~EigenLinearSolver()

MathLib::EigenLinearSolver::~EigenLinearSolver ( )

default

Member Function Documentation

getOption()

EigenOption& MathLib::EigenLinearSolver::getOption ( )

inline

get linear solver options

Definition at line 59 of file EigenLinearSolver.h.

{ return option_; }

References option_.

setOption() [1/2]

void MathLib::EigenLinearSolver::setOption

(

const BaseLib::ConfigTree &

option

)

parse linear solvers configuration

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

Definition at line 269 of file EigenLinearSolver.cpp.

{
    ignoreOtherLinearSolvers(option, "eigen");
    auto const ptSolver = option.getConfigSubtreeOptional("eigen");
    if (!ptSolver)
    {
        return;
    }
 
    if (auto solver_type =
        ptSolver->getConfigParameterOptional<std::string>("solver_type"))
    {
        option_.solver_type = MathLib::EigenOption::getSolverType(*solver_type);
    }
    if (auto precon_type =
        ptSolver->getConfigParameterOptional<std::string>("precon_type"))
    {
        option_.precon_type = MathLib::EigenOption::getPreconType(*precon_type);
    }
    if (auto error_tolerance =
        ptSolver->getConfigParameterOptional<double>("error_tolerance"))
    {
        option_.error_tolerance = *error_tolerance;
    }
    if (auto max_iteration_step =
        ptSolver->getConfigParameterOptional<int>("max_iteration_step"))
    {
        option_.max_iterations = *max_iteration_step;
    }
    if (auto scaling =
        ptSolver->getConfigParameterOptional<bool>("scaling"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        option_.scaling = *scaling;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules. "
            "scaling is not available.");
#endif
    }
    if (auto restart =
        ptSolver->getConfigParameterOptional<int>("restart"))
    {
#ifdef USE_EIGEN_UNSUPPORTED
        option_.restart = *restart;
#else
        OGS_FATAL(
            "The code is not compiled with the Eigen unsupported modules. "
            "GMRES/GMRES option restart is not available.");
#endif
    }
}

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

Referenced by EigenLinearSolver().

setOption() [2/2]

void MathLib::EigenLinearSolver::setOption ( const EigenOption &  option )

inline

copy linear solvers options

Definition at line 54 of file EigenLinearSolver.h.

{ option_ = option; }

References option_.

setRestart()

void MathLib::EigenLinearSolver::setRestart ( )

protected

solve()

bool MathLib::EigenLinearSolver::solve	(	EigenMatrix &	A,
		EigenVector &	b,
		EigenVector &	x
	)

Definition at line 329 of file EigenLinearSolver.cpp.

{
    INFO("------------------------------------------------------------------");
    INFO("*** Eigen solver computation");
 
#ifdef USE_EIGEN_UNSUPPORTED
    std::unique_ptr<Eigen::IterScaling<EigenMatrix::RawMatrixType>> scal;
    if (option_.scaling)
    {
        INFO("-> scale");
        scal =
            std::make_unique<Eigen::IterScaling<EigenMatrix::RawMatrixType>>();
        scal->computeRef(A.getRawMatrix());
        b.getRawVector() = scal->LeftScaling().cwiseProduct(b.getRawVector());
    }
#endif
    auto const success = solver_->solve(A.getRawMatrix(), b.getRawVector(),
                                        x.getRawVector(), option_);
#ifdef USE_EIGEN_UNSUPPORTED
    if (scal)
    {
        x.getRawVector() = scal->RightScaling().cwiseProduct(x.getRawVector());
    }
#endif
 
    INFO("------------------------------------------------------------------");
 
    return success;
}

References MathLib::EigenMatrix::getRawMatrix(), MathLib::EigenVector::getRawVector(), INFO(), option_, and solver_.

Member Data Documentation

option_

EigenOption MathLib::EigenLinearSolver::option_

protected

Definition at line 64 of file EigenLinearSolver.h.

Referenced by EigenLinearSolver(), getOption(), setOption(), and solve().

solver_

std::unique_ptr<EigenLinearSolverBase> MathLib::EigenLinearSolver::solver_

protected

Definition at line 65 of file EigenLinearSolver.h.

Referenced by EigenLinearSolver(), and solve().

---

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

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