bool finalizeMatrixAssembly(LisMatrix &mat)
{
LIS_MATRIX &A = mat.getRawMatrix();
if (!mat.isAssembled()) {
int ierr = lis_matrix_set_type(A, static_cast<int>(mat.getMatrixType()));
checkLisError(ierr);
ierr = lis_matrix_assemble(A);
checkLisError(ierr);
mat._is_assembled = true;
}
return true;
}
void applyKnownSolution(LisMatrix &A, LisVector &b, const std::vector<std::size_t> &vec_knownX_id,
const std::vector<double> &vec_knownX_x, double penalty_scaling)
{
//Use penalty parameter
const double max_diag_coeff = A.getMaxDiagCoeff();
const double penalty = max_diag_coeff * penalty_scaling;
INFO("-> max. absolute value of diagonal entries = %e", max_diag_coeff);
INFO("-> penalty scaling = %e", penalty_scaling);
const std::size_t n_bc = vec_knownX_id.size();
for (std::size_t i_bc=0; i_bc<n_bc; i_bc++) {
const std::size_t rowId = vec_knownX_id[i_bc];
const double x = vec_knownX_x[i_bc];
//A(k, k) = penalty
A.setValue(rowId, rowId, penalty);
//b(k) = x*penalty
b.set(rowId, x*penalty);
}
}
bool LisLinearSolver::solve(LisMatrix &A, LisVector &b, LisVector &x)
{
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_option._option_string.c_str()), solver);
#ifdef _OPENMP
INFO("-> number of threads: %i", (int) omp_get_max_threads());
#endif
{
int precon;
ierr = lis_solver_get_precon(solver, &precon);
INFO("-> precon: %i", precon);
}
{
int slv;
ierr = lis_solver_get_solver(solver, &slv);
INFO("-> solver: %i", 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;
}
