MathLib::EigenLisLinearSolver Class Reference

Detailed Description

Linear solver using Lis library with Eigen matrix and vector objects

Definition at line 30 of file EigenLisLinearSolver.h.

#include <EigenLisLinearSolver.h>

Public Member Functions
	EigenLisLinearSolver (std::string const &solver_name, std::string const &lis_options)
void	setOption (std::string const &lis_options)
bool	solve (EigenMatrix &A, EigenVector &b, EigenVector &x)

Private Member Functions
bool	solve (LisMatrix &A, LisVector &b, LisVector &x)

Private Attributes
std::string	lis_options_

Constructor & Destructor Documentation

EigenLisLinearSolver()

MathLib::EigenLisLinearSolver::EigenLisLinearSolver	(	std::string const &	solver_name,
		std::string const &	lis_options )

Constructor

Parameters

solver_name	A name used as a prefix for command line options if there are such options available.
lis_options	string containing the options for LIS library; options will be applied in the solve method.

Definition at line 25 of file EigenLisLinearSolver.cpp.

    : lis_options_(lis_options)
{
}

Member Function Documentation

setOption()

void MathLib::EigenLisLinearSolver::setOption ( std::string const & lis_options )

inline

copy linear solvers options

Parameters

lis_options

string containing the options for LIS library; options will be applied in the solve method.

Definition at line 47 of file EigenLisLinearSolver.h.

    {
        lis_options_ = lis_options;
    }

References lis_options_.

solve() [1/2]

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

Definition at line 31 of file EigenLisLinearSolver.cpp.

{
    static_assert(EigenMatrix::RawMatrixType::IsRowMajor,
                  "Sparse matrix is required to be in row major storage.");
    auto& A = A_.getRawMatrix();
    auto& b = b_.getRawVector();
    auto& x = x_.getRawVector();
 
    if (!A.isCompressed())
    {
        A.makeCompressed();
    }
    int nnz = A.nonZeros();
    int* ptr = A.outerIndexPtr();
    int* col = A.innerIndexPtr();
    double* data = A.valuePtr();
    LisMatrix lisA(A_.getNumberOfRows(), nnz, ptr, col, data);
    LisVector lisb(b.rows(), b.data());
    LisVector lisx(x.rows(), x.data());
 
    bool const status = solve(lisA, lisb, lisx);
 
    for (std::size_t i = 0; i < lisx.size(); i++)
    {
        x[i] = lisx[i];
    }
 
    return status;
}

References MathLib::EigenMatrix::getNumberOfRows(), MathLib::EigenMatrix::getRawMatrix(), MathLib::EigenVector::getRawVector(), MathLib::LisVector::size(), and solve().

Referenced by solve(), and NumLib::detail::solvePicard().

solve() [2/2]

bool MathLib::EigenLisLinearSolver::solve ( LisMatrix & A, LisVector & b, LisVector & x )

private

Definition at line 62 of file EigenLisLinearSolver.cpp.

{
    finalizeMatrixAssembly(A);
 
    INFO("------------------------------------------------------------------");
    INFO("*** LIS solver computation");
 
    // Create solver
    LIS_SOLVER solver;
    int ierr = lis_solver_create(&solver);
    if (!checkLisError(ierr))
    {
        return false;
    }
    lis_solver_set_option(const_cast<char*>(lis_options_.c_str()), solver);
#ifdef _OPENMP
    INFO("-> number of threads: {:d}", (int)omp_get_max_threads());
#endif
    {
        int precon;
        ierr = lis_solver_get_precon(solver, &precon);
        if (!checkLisError(ierr))
        {
            return false;
        }
        INFO("-> precon: {:d}", precon);
    }
    {
        int slv;
        ierr = lis_solver_get_solver(solver, &slv);
        if (!checkLisError(ierr))
        {
            return false;
        }
        INFO("-> solver: {:d}", slv);
    }
 
    // solve
    INFO("-> solve");
    ierr =
        lis_solve(A.getRawMatrix(), b.getRawVector(), x.getRawVector(), solver);
    if (!checkLisError(ierr))
    {
        return false;
    }
 
    LIS_INT linear_solver_status;
    ierr = lis_solver_get_status(solver, &linear_solver_status);
    if (!checkLisError(ierr))
    {
        return false;
    }
 
    INFO("-> status: {:d}", linear_solver_status);
 
    {
        int iter = 0;
        ierr = lis_solver_get_iter(solver, &iter);
        if (!checkLisError(ierr))
        {
            return false;
        }
 
        INFO("-> iteration: {:d}", iter);
    }
    {
        double resid = 0.0;
        ierr = lis_solver_get_residualnorm(solver, &resid);
        if (!checkLisError(ierr))
        {
            return false;
        }
        INFO("-> residual: {:g}", resid);
    }
    {
        double time, itime, ptime, p_ctime, p_itime;
        ierr = lis_solver_get_timeex(solver, &time, &itime, &ptime, &p_ctime,
                                     &p_itime);
        if (!checkLisError(ierr))
        {
            return false;
        }
        INFO("-> time total           (s): {:g}", time);
        INFO("-> time iterations      (s): {:g}", itime);
        INFO("-> time preconditioning (s): {:g}", ptime);
        INFO("-> time precond. create (s): {:g}", p_ctime);
        INFO("-> time precond. iter   (s): {:g}", p_itime);
    }
 
    // Clear solver
    ierr = lis_solver_destroy(solver);
    if (!checkLisError(ierr))
    {
        return false;
    }
    INFO("------------------------------------------------------------------");
 
    return linear_solver_status == LIS_SUCCESS;
}

References MathLib::checkLisError(), MathLib::finalizeMatrixAssembly(), MathLib::LisMatrix::getRawMatrix(), MathLib::LisVector::getRawVector(), INFO(), and lis_options_.

Member Data Documentation

lis_options_

std::string MathLib::EigenLisLinearSolver::lis_options_

private

Definition at line 56 of file EigenLisLinearSolver.h.

Referenced by setOption(), and solve().

---

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

• MathLib/LinAlg/EigenLis/EigenLisLinearSolver.h
• MathLib/LinAlg/EigenLis/EigenLisLinearSolver.cpp