LIS_INT lis_solve(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_SOLVER solver)
{
LIS_INT err;
LIS_PRECON precon;
LIS_DEBUG_FUNC_IN;
solver->A = A;
/* create preconditioner */
if( solver->options[LIS_OPTIONS_PRECON] < 0 || solver->options[LIS_OPTIONS_PRECON] > LIS_PRECONNAME_MAX )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_PRECON is %d (Set between 0 to %d)\n",solver->options[LIS_OPTIONS_PRECON], LIS_PRECONNAME_MAX);
return LIS_ERR_ILL_ARG;
}
err = lis_precon_create(solver, &precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
/* Core Kernel of lis_solve() */
lis_solve_kernel(A, b, x, solver, precon);
lis_precon_destroy(precon);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_solver_destroy(LIS_SOLVER solver)
{
LIS_DEBUG_FUNC_IN;
if( solver )
{
lis_solver_work_destroy(solver);
lis_vector_destroy(solver->d);
if( solver->At ) lis_matrix_destroy(solver->At);
if( solver->residual ) lis_free(solver->residual);
lis_free(solver);
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_solve_kernel(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT nsolver, precon_type, maxiter;
LIS_INT err;
LIS_SCALAR *residual;
LIS_VECTOR xx;
LIS_INT output;
LIS_INT scale;
LIS_INT conv_cond;
LIS_INT precision,is_use_at,storage,block;
LIS_INT i,n,np;
double p_c_times, p_i_times,itimes;
LIS_SCALAR nrm2,tol,tol_w;
LIS_VECTOR t;
LIS_VECTOR bb;
LIS_MATRIX AA,B;
LIS_MATRIX At;
char buf[64];
LIS_DEBUG_FUNC_IN;
nsolver = solver->options[LIS_OPTIONS_SOLVER];
precon_type = solver->options[LIS_OPTIONS_PRECON];
maxiter = solver->options[LIS_OPTIONS_MAXITER];
output = solver->options[LIS_OPTIONS_OUTPUT];
scale = solver->options[LIS_OPTIONS_SCALE];
precision = solver->options[LIS_OPTIONS_PRECISION];
is_use_at = solver->options[LIS_OPTIONS_USE_AT];
storage = solver->options[LIS_OPTIONS_STORAGE];
block = solver->options[LIS_OPTIONS_STORAGE_BLOCK];
conv_cond = solver->options[LIS_OPTIONS_CONV_COND];
tol = solver->params[LIS_PARAMS_RESID-LIS_OPTIONS_LEN];
tol_w = solver->params[LIS_PARAMS_RESID_WEIGHT-LIS_OPTIONS_LEN];
solver->precision = precision;
if( nsolver < 1 || nsolver > LIS_SOLVERS_LEN )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_SOLVER is %d (Set between 1 to %d)\n",nsolver, LIS_SOLVERS_LEN);
return LIS_ERR_ILL_ARG;
}
if( precon_type < 0 || precon_type > precon_register_type )
{
LIS_SETERR2(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_PRECON is %d (Set between 0 to %d)\n",precon_type, precon_register_type-1);
return LIS_ERR_ILL_ARG;
}
if( maxiter<0 )
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter LIS_OPTIONS_MAXITER(=%d) is less than 0\n",maxiter);
return LIS_ERR_ILL_ARG;
}
#ifdef USE_MPI
if( precon_type == LIS_PRECON_TYPE_SAAMG && solver->A->nprocs < 2)
{
LIS_SETERR1(LIS_ERR_ILL_ARG,"Parameter A->nprocs (=%d) is less than 2 (Set more than 1 when using parallel version of SAAMG)\n",solver->A->nprocs);
return LIS_ERR_ILL_ARG;
}
#endif
#ifdef USE_QUAD_PRECISION
if( precision==LIS_PRECISION_QUAD && lis_solver_execute_quad[nsolver]==NULL )
{
LIS_SETERR1(LIS_ERR_NOT_IMPLEMENTED,"Quad precision solver %s is not implemented\n",lis_solvername[nsolver]);
return LIS_ERR_NOT_IMPLEMENTED;
}
else if( precision==LIS_PRECISION_SWITCH && lis_solver_execute_switch[nsolver]==NULL )
{
LIS_SETERR1(LIS_ERR_NOT_IMPLEMENTED,"Switch solver %s is not implemented\n",lis_solvername[nsolver]);
return LIS_ERR_NOT_IMPLEMENTED;
}
if( solver->options[LIS_OPTIONS_SWITCH_MAXITER]==-1 )
{
solver->options[LIS_OPTIONS_SWITCH_MAXITER] = maxiter;
}
#endif
err = lis_solver_check_params[nsolver](solver);
if( err )
{
solver->retcode = err;
return err;
}
/* end parameter check */
solver->A = A;
solver->b = b;
/* create initial vector */
#ifndef USE_QUAD_PRECISION
err = lis_vector_duplicate(A,&xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
err = lis_vector_duplicate(A,&xx);
}
else
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,A,&xx);
}
#endif
if( err )
{
solver->retcode = err;
return err;
}
if( solver->options[LIS_OPTIONS_INITGUESS_ZEROS] )
{
if( output ) lis_printf(A->comm,"initial vector x = 0\n");
#ifndef USE_QUAD_PRECISION
lis_vector_set_all(0.0,xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
lis_vector_set_all(0.0,xx);
}
else
{
lis_vector_set_allex_nm(0.0,xx);
}
#endif
}
else
{
if( output ) lis_printf(A->comm,"initial vector x = user defined\n");
#ifndef USE_QUAD_PRECISION
lis_vector_copy(x,xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
lis_vector_copy(x,xx);
}
else
{
lis_vector_copyex_nm(x,xx);
}
#endif
}
/* create residual history vector */
if( solver->residual ) lis_free(solver->residual);
residual = (LIS_SCALAR *)lis_malloc((maxiter+2)*sizeof(LIS_SCALAR),"lis_solve::residual");
if( residual==NULL )
{
LIS_SETERR_MEM((maxiter+2)*sizeof(LIS_SCALAR));
lis_vector_destroy(xx);
solver->retcode = err;
return err;
}
residual[0] = 1.0;
n = A->n;
np = A->np;
t = NULL;
At = NULL;
p_c_times = lis_wtime();
if( precon_type==LIS_PRECON_TYPE_IS )
{
if( solver->d==NULL )
{
err = lis_vector_duplicate(A,&solver->d);
if( err )
{
return err;
}
}
if( !A->is_scaled )
{
lis_matrix_scaling(A,b,solver->d,LIS_SCALE_JACOBI);
}
else if( !b->is_scaled )
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
b->value[i] = b->value[i]*solver->d->value[i];
}
}
if( nsolver >= LIS_SOLVER_JACOBI && nsolver <= LIS_SOLVER_SOR )
{
solver->options[LIS_OPTIONS_ISLEVEL] = 0;
}
}
else if( nsolver >= LIS_SOLVER_JACOBI && nsolver <= LIS_SOLVER_SOR && precon_type!=LIS_PRECON_TYPE_NONE )
{
if( solver->d==NULL )
{
err = lis_vector_duplicate(A,&solver->d);
if( err )
{
return err;
}
}
if( !A->is_scaled )
{
lis_matrix_scaling(A,b,solver->d,LIS_SCALE_JACOBI);
}
}
else if( scale )
{
if( storage==LIS_MATRIX_BSR && scale==LIS_SCALE_JACOBI )
{
if( A->matrix_type!=LIS_MATRIX_BSR )
{
err = lis_matrix_duplicate(A,&B);
if( err ) return err;
lis_matrix_set_blocksize(B,block,block,NULL,NULL);
lis_matrix_set_type(B,storage);
err = lis_matrix_convert(A,B);
if( err ) return err;
lis_matrix_storage_destroy(A);
lis_matrix_DLU_destroy(A);
lis_matrix_diag_destroy(A->WD);
if( A->l2g_map ) lis_free( A->l2g_map );
if( A->commtable ) lis_commtable_destroy( A->commtable );
if( A->ranges ) lis_free( A->ranges );
err = lis_matrix_copy_struct(B,A);
if( err ) return err;
lis_free(B);
}
err = lis_matrix_split(A);
if( err ) return err;
err = lis_matrix_diag_duplicate(A->D,&solver->WD);
if( err ) return err;
lis_matrix_diag_copy(A->D,solver->WD);
lis_matrix_diag_inverse(solver->WD);
lis_matrix_bscaling_bsr(A,solver->WD);
lis_vector_duplicate(A,&t);
lis_matrix_diag_matvec(solver->WD,b,t);
lis_vector_copy(t,b);
lis_vector_destroy(t);
t = NULL;
}
else
{
if( solver->d==NULL )
{
err = lis_vector_duplicate(A,&solver->d);
if( err )
{
return err;
}
}
if( scale==LIS_SCALE_JACOBI && nsolver==LIS_SOLVER_CG )
{
scale = LIS_SCALE_SYMM_DIAG;
}
if( !A->is_scaled )
{
lis_matrix_scaling(A,b,solver->d,scale);
}
else if( !b->is_scaled )
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
b->value[i] = b->value[i]*solver->d->value[i];
}
}
}
}
/* precon_type = precon->precon_type;*/
if( precon_type==LIS_PRECON_TYPE_IS )
{
if( nsolver < LIS_SOLVER_JACOBI || nsolver > LIS_SOLVER_SOR )
{
AA = solver->A;
bb = solver->b;
}
else
{
AA = precon->A;
bb = precon->Pb;
}
}
else
{
AA = A;
bb = b;
}
p_c_times = lis_wtime() - p_c_times;
itimes = lis_wtime();
/* Matrix Convert */
solver->A = AA;
solver->b = bb;
err = lis_matrix_convert_self(solver);
if( err )
{
lis_vector_destroy(xx);
lis_solver_work_destroy(solver);
lis_free(residual);
solver->retcode = err;
return err;
}
block = solver->A->bnr;
if( A->my_rank==0 )
{
if( output ) printf("precision : %s\n", lis_precisionname[precision]);
if( output ) printf("solver : %s %d\n", lis_solvername[nsolver],nsolver);
switch( precon_type )
{
case LIS_PRECON_TYPE_ILU:
i = solver->options[LIS_OPTIONS_FILL];
if( A->matrix_type==LIS_MATRIX_BSR || A->matrix_type==LIS_MATRIX_VBR )
{
if( output ) sprintf(buf,"Block %s(%d)",lis_preconname[precon_type],i);
}
else
{
if( output ) sprintf(buf,"%s(%d)",lis_preconname[precon_type],i);
}
break;
default:
if( output ) sprintf(buf,"%s",lis_preconname[precon_type]);
break;
}
if( solver->options[LIS_OPTIONS_ADDS] && precon_type )
{
if( output ) printf("precon : %s + additive schwarz\n", buf);
}
else
{
if( output ) printf("precon : %s\n", buf);
}
}
switch(conv_cond)
{
case LIS_CONV_COND_NRM2_R:
case LIS_CONV_COND_NRM2_B:
if( A->my_rank==0 )
{
if( output ) ("CONV_COND : ||r||_2 <= %6.1e*||r_0||_2\n", tol);
}
break;
case LIS_CONV_COND_NRM1_B:
lis_vector_nrm1(b,&nrm2);
nrm2 = nrm2*tol_w + tol;
if( A->my_rank==0 )
{
if( output ) printf("conv_cond : ||r||_1 <= %6.1e*||b||_1 + %6.1e = %6.1e\n", tol_w,tol,nrm2);
}
break;
}
if( A->my_rank==0 )
{
if( AA->matrix_type==LIS_MATRIX_BSR || AA->matrix_type==LIS_MATRIX_BSC )
{
if( output ) printf("storage : %s(%d x %d)\n", lis_storagename[AA->matrix_type-1],block,block);
}
else
{
if( output ) printf("storage : %s\n", lis_storagename[AA->matrix_type-1]);
}
}
/* create work vector */
err = lis_solver_malloc_work[nsolver](solver);
if( err )
{
lis_vector_destroy(xx);
lis_precon_destroy(precon);
solver->retcode = err;
return err;
}
if( nsolver==LIS_SOLVER_BICG && is_use_at )
{
if( output ) lis_printf(A->comm,"Use At\n");
lis_matrix_duplicate(AA,&At);
lis_matrix_set_type(At,LIS_USE_AT_TYPE[AA->matrix_type]);
lis_matrix_convert(AA,At);
solver->At = At;
}
solver->x = xx;
solver->xx = x;
solver->precon = precon;
solver->residual = residual;
/* execute solver */
#ifndef USE_QUAD_PRECISION
err = lis_solver_execute[nsolver](solver);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
err = lis_solver_execute[nsolver](solver);
}
else if( precision==LIS_PRECISION_QUAD )
{
err = lis_solver_execute_quad[nsolver](solver);
}
else if( precision==LIS_PRECISION_SWITCH )
{
err = lis_solver_execute_switch[nsolver](solver);
}
#endif
solver->retcode = err;
if( scale==LIS_SCALE_SYMM_DIAG && precon_type!=LIS_PRECON_TYPE_IS)
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
x->value[i] = xx->value[i]*solver->d->value[i];
}
}
else
{
#ifndef USE_QUAD_PRECISION
lis_vector_copy(xx,x);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
lis_vector_copy(xx,x);
}
else
{
lis_vector_copyex_mn(xx,x);
}
#endif
}
itimes = lis_wtime() - itimes - solver->ptimes;
p_i_times = solver->ptimes;
solver->ptimes = p_c_times + p_i_times;
solver->p_c_times = p_c_times;
solver->p_i_times = p_i_times;
solver->times = solver->ptimes + itimes;
solver->itimes = itimes;
lis_solver_work_destroy(solver);
lis_vector_duplicate(A,&t);
xx->precision = LIS_PRECISION_DEFAULT;
lis_matvec(A,xx,t);
lis_vector_xpay(b,-1.0,t);
if( scale==LIS_SCALE_SYMM_DIAG && precon_type!=LIS_PRECON_TYPE_IS)
{
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(i=0;i<n;i++)
{
t->value[i] = t->value[i]/solver->d->value[i];
}
}
lis_vector_nrm2(t,&nrm2);
/*
solver->resid = nrm2;
*/
if( A->my_rank==0 )
{
if( err )
{
if( output ) printf("lis_solve : %s(code=%d)\n\n",lis_returncode[err],err);
}
else
{
if( output ) printf("lis_solve : normal end\n\n");
}
}
if( precision==LIS_PRECISION_DOUBLE )
{
solver->iter2 = solver->iter;
}
else if( precision==LIS_PRECISION_QUAD )
{
solver->iter2 = 0;
}
lis_vector_destroy(t);
/* lis_vector_destroy(d);*/
lis_vector_destroy(xx);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_esi_quad(LIS_ESOLVER esolver)
{
LIS_MATRIX A;
LIS_VECTOR x, Ax;
LIS_SCALAR xAx, xx, mu, lshift;
LIS_INT ss;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT i,j,k;
LIS_SCALAR evalue,dotvr;
LIS_INT iter,giter,output,niesolver;
LIS_INT nprocs,my_rank;
LIS_REAL nrm2,dot,resid,resid0;
LIS_QUAD_PTR qdot_vv, qdot_vr;
LIS_VECTOR *v,r,q;
LIS_SOLVER solver;
LIS_PRECON precon;
double times,itimes,ptimes,p_c_times,p_i_times;
LIS_INT err;
LIS_INT nsol, precon_type;
char solvername[128], preconname[128];
LIS_DEBUG_FUNC_IN;
A = esolver->A;
x = esolver->x;
ss = esolver->options[LIS_EOPTIONS_SUBSPACE];
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
lshift = esolver->lshift;
output = esolver->options[LIS_EOPTIONS_OUTPUT];
niesolver = esolver->options[LIS_EOPTIONS_INNER_ESOLVER];
r = esolver->work[0];
q = esolver->work[1];
v = &esolver->work[2];
Ax = esolver->work[3];
LIS_QUAD_SCALAR_MALLOC(qdot_vv,0,1);
LIS_QUAD_SCALAR_MALLOC(qdot_vr,1,1);
lis_vector_set_all(1.0,r);
lis_vector_nrm2(r, &nrm2);
lis_vector_scale(1/nrm2,r);
switch ( niesolver )
{
case LIS_ESOLVER_II:
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p ilu -precision quad",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
break;
case LIS_ESOLVER_AII:
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p ilu -precision quad",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
lis_vector_set_all(1.0,q);
lis_solve(A, q, x, solver);
lis_precon_create(solver, &precon);
solver->precon = precon;
break;
case LIS_ESOLVER_RQI:
lis_solver_create(&solver);
lis_solver_set_option("-p ilu -precision quad -maxiter 10",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_get_solvername(nsol, solvername);
lis_get_preconname(precon_type, preconname);
printf("solver : %s %d\n", solvername, nsol);
printf("precon : %s %d\n", preconname, precon_type);
if( A->my_rank==0 ) printf("local shift = %e\n", lshift);
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
break;
}
giter=0;
j=0;
while (j<ss)
{
lis_vector_duplicate(A,&esolver->evector[j]);
j = j+1;
lis_vector_copy(r, v[j]);
if (niesolver==LIS_ESOLVER_II || niesolver==LIS_ESOLVER_RQI)
{
/* create preconditioner */
solver->A = A;
err = lis_precon_create(solver, &precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
}
if (niesolver==LIS_ESOLVER_RQI)
{
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
lis_matvec(A, x, Ax);
lis_vector_dot(x, Ax, &xAx);
lis_vector_dot(x, x, &xx);
mu = xAx / xx;
}
iter = 0;
while (iter<emaxiter)
{
/* diagonalization */
iter = iter+1;
giter = giter+1;
for (k=1;k<j;k++)
{
lis_vector_dotex_mmm(v[j], v[k], &qdot_vv);
lis_quad_minus((LIS_QUAD *)qdot_vv.hi);
lis_vector_axpyex_mmm(qdot_vv,v[k],v[j]);
}
switch( niesolver )
{
case LIS_ESOLVER_PI:
lis_matvec(A,v[j],r);
break;
case LIS_ESOLVER_II:
lis_solve_kernel(A, v[j], r, solver, precon);
break;
case LIS_ESOLVER_AII:
lis_psolve(solver, v[j], r);
break;
case LIS_ESOLVER_RQI:
lis_vector_nrm2(v[j], &nrm2);
lis_vector_scale(1/nrm2, v[j]);
lis_matrix_shift_diagonal(A, -mu);
lis_solve_kernel(A, v[j], r, solver, precon);
lis_matrix_shift_diagonal(A, mu);
break;
}
if ( j==1 && ( niesolver==LIS_ESOLVER_II || niesolver==LIS_ESOLVER_AII || niesolver==LIS_ESOLVER_RQI ))
{
lis_solver_get_timeex(solver,×,&itimes,&ptimes,&p_c_times,&p_i_times);
esolver->ptimes += solver->ptimes;
esolver->itimes += solver->itimes;
esolver->p_c_times += solver->p_c_times;
esolver->p_i_times += solver->p_i_times;
}
lis_vector_nrm2(r, &nrm2);
lis_vector_dotex_mmm(v[j], r, &qdot_vr);
lis_quad_minus((LIS_QUAD *)qdot_vr.hi);
lis_vector_axpyzex_mmmm(qdot_vr,v[j],r,q);
lis_quad_minus((LIS_QUAD *)qdot_vr.hi);
dotvr = qdot_vr.hi[0];
mu = mu + 1/dotvr;
lis_vector_nrm2(q, &resid);
resid = fabs(resid / dotvr);
lis_vector_scale(1/nrm2,r);
lis_vector_copy(r, v[j]);
if ( j==1 )
{
if( output & LIS_PRINT_MEM ) esolver->residual[iter] = resid;
if( output & LIS_PRINT_OUT ) printf("iter: %5d residual = %e\n", iter, resid);
esolver->iter = iter;
esolver->resid = resid;
}
if (tol>resid) break;
}
if (niesolver==LIS_ESOLVER_II || niesolver==LIS_ESOLVER_RQI)
{
lis_precon_destroy(precon);
}
switch ( niesolver )
{
case LIS_ESOLVER_PI:
esolver->evalue[j-1] = dotvr;
break;
case LIS_ESOLVER_II:
esolver->evalue[j-1] = 1/dotvr;
break;
case LIS_ESOLVER_AII:
esolver->evalue[j-1] = 1/dotvr;
break;
case LIS_ESOLVER_RQI:
esolver->evalue[j-1] = mu;
break;
}
lis_vector_copy(v[j], esolver->evector[j-1]);
if (A->my_rank==0 && ss>1)
{
#ifdef _LONGLONG
printf("Subspace: mode number = %lld\n", j-1);
#else
printf("Subspace: mode number = %d\n", j-1);
#endif
printf("Subspace: eigenvalue = %e\n", esolver->evalue[j-1]);
#ifdef _LONGLONG
printf("Subspace: number of iterations = %lld\n",iter);
#else
printf("Subspace: number of iterations = %d\n",iter);
#endif
printf("Subspace: relative residual 2-norm = %e\n",resid);
}
}
lis_vector_copy(esolver->evector[esolver->options[LIS_EOPTIONS_MODE]], esolver->x);
switch ( niesolver )
{
case LIS_ESOLVER_II:
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_solver_destroy(solver);
break;
case LIS_ESOLVER_AII:
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_precon_destroy(precon);
lis_solver_destroy(solver);
break;
case LIS_ESOLVER_RQI:
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_solver_destroy(solver);
break;
}
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_precon_create_hybrid(LIS_SOLVER solver, LIS_PRECON precon)
{
LIS_INT nsolver, maxiter, precision;
LIS_INT err;
LIS_SCALAR *rhistory;
LIS_VECTOR xx;
LIS_SOLVER psolver;
LIS_MATRIX A;
LIS_PRECON pprecon;
LIS_DEBUG_FUNC_IN;
A = solver->A;
err = lis_solver_create(&psolver);
if( err )
{
return err;
}
psolver->params[LIS_PARAMS_RESID-LIS_OPTIONS_LEN] = solver->params[LIS_PARAMS_PRESID-LIS_OPTIONS_LEN];
psolver->params[LIS_PARAMS_W-LIS_OPTIONS_LEN] = solver->params[LIS_PARAMS_PW-LIS_OPTIONS_LEN];
psolver->options[LIS_OPTIONS_MAXITER] = solver->options[LIS_OPTIONS_PMAXITER];
psolver->options[LIS_OPTIONS_ELL] = solver->options[LIS_OPTIONS_PELL];
psolver->options[LIS_OPTIONS_RESTART] = solver->options[LIS_OPTIONS_PRESTART];
psolver->options[LIS_OPTIONS_OUTPUT] = 0;
psolver->options[LIS_OPTIONS_SOLVER] = solver->options[LIS_OPTIONS_PSOLVER];
psolver->options[LIS_OPTIONS_PRECON] = solver->options[LIS_OPTIONS_PPRECON];
psolver->options[LIS_OPTIONS_INITGUESS_ZEROS] = solver->options[LIS_OPTIONS_INITGUESS_ZEROS];
psolver->options[LIS_OPTIONS_PRECISION] = solver->options[LIS_OPTIONS_PRECISION];
psolver->A = solver->A;
psolver->At = solver->At;
psolver->precision = solver->precision;
nsolver = psolver->options[LIS_OPTIONS_SOLVER];
maxiter = psolver->options[LIS_OPTIONS_MAXITER];
precision = psolver->options[LIS_OPTIONS_PRECISION];
A = psolver->A;
/* create initial vector */
#ifndef USE_QUAD_PRECISION
err = lis_vector_duplicate(A,&xx);
#else
if( precision==LIS_PRECISION_DOUBLE )
{
err = lis_vector_duplicate(A,&xx);
}
else
{
err = lis_vector_duplicateex(LIS_PRECISION_QUAD,A,&xx);
}
#endif
if( err )
{
solver->retcode = err;
return err;
}
/* create residual history vector */
rhistory = (LIS_SCALAR *)lis_malloc((maxiter+2)*sizeof(LIS_SCALAR),"lis_precon_create_hybrid::rhistory");
if( rhistory==NULL )
{
LIS_SETERR_MEM((maxiter+2)*sizeof(LIS_SCALAR));
lis_vector_destroy(xx);
solver->retcode = err;
return err;
}
/* create preconditioner */
err = lis_precon_create(psolver, &pprecon);
if( err )
{
lis_vector_destroy(xx);
lis_solver_work_destroy(psolver);
lis_free(rhistory);
solver->retcode = err;
return err;
}
/* create work vector */
err = lis_solver_malloc_work[nsolver](psolver);
if( err )
{
lis_vector_destroy(xx);
lis_precon_destroy(pprecon);
solver->retcode = err;
return err;
}
psolver->x = xx;
psolver->precon = pprecon;
psolver->rhistory = rhistory;
precon->solver = psolver;
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
LIS_INT lis_egpi(LIS_ESOLVER esolver)
{
LIS_Comm comm;
LIS_MATRIX A,B;
LIS_VECTOR w,v,y,q;
LIS_SCALAR eta,theta;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT iter,iter2,output;
LIS_SCALAR oshift,ishift;
LIS_REAL nrm2,resid;
LIS_SOLVER solver;
double time,itime,ptime,p_c_time,p_i_time;
LIS_INT err;
LIS_PRECON precon;
LIS_INT nsol, precon_type;
char solvername[128], preconname[128];
LIS_DEBUG_FUNC_IN;
comm = LIS_COMM_WORLD;
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
output = esolver->options[LIS_EOPTIONS_OUTPUT];
#ifdef _COMPLEX
oshift = esolver->params[LIS_EPARAMS_SHIFT - LIS_EOPTIONS_LEN] + esolver->params[LIS_EPARAMS_SHIFT_IM - LIS_EOPTIONS_LEN] * _Complex_I;
#else
oshift = esolver->params[LIS_EPARAMS_SHIFT - LIS_EOPTIONS_LEN];
#endif
A = esolver->A;
B = esolver->B;
v = esolver->x;
if (esolver->options[LIS_EOPTIONS_INITGUESS_ONES] )
{
lis_vector_set_all(1.0,v);
}
w = esolver->work[0];
y = esolver->work[1];
q = esolver->work[2];
if ( esolver->ishift != 0.0 ) oshift = ishift;
if ( oshift != 0.0 ) lis_matrix_shift_matrix(A, B, oshift);
if( output )
{
#ifdef _COMPLEX
lis_printf(comm,"shift : (%e, %e)\n", (double)creal(oshift), (double)cimag(oshift));
#else
lis_printf(comm,"shift : %e\n", (double)oshift);
#endif
}
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p none",solver);
err = lis_solver_set_optionC(solver);
CHKERR(err);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_solver_get_solvername(nsol, solvername);
lis_solver_get_preconname(precon_type, preconname);
if( output )
{
lis_printf(comm,"linear solver : %s\n", solvername);
lis_printf(comm,"preconditioner : %s\n", preconname);
}
/* create preconditioner */
solver->A = B;
err = lis_precon_create(solver, &precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
iter=0;
while (iter<emaxiter)
{
iter = iter+1;
/* v = v / ||v||_2 */
lis_vector_nrm2(v, &nrm2);
lis_vector_scale(1.0/nrm2, v);
/* w = A * v */
lis_matvec(A, v, w);
/* v = v / <v,w>^1/2, w = w / <v,w>^1/2 */
lis_vector_dot(v, w, &eta);
eta = sqrt(eta);
lis_vector_scale(1.0/eta, v);
lis_vector_scale(1.0/eta, w);
/* y = B^-1 * w */
err = lis_solve_kernel(B, w, y, solver, precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
lis_solver_get_iter(solver, &iter2);
/* theta = <w,y> */
lis_vector_dot(w, y, &theta);
/* resid = ||y - theta * v||_2 / |theta| */
lis_vector_axpyz(-theta, v, y, q);
lis_vector_nrm2(q, &resid);
resid = resid / fabs(theta);
/* v = y */
lis_vector_copy(y, v);
/* convergence check */
lis_solver_get_timeex(solver,&time,&itime,&ptime,&p_c_time,&p_i_time);
esolver->ptime += solver->ptime;
esolver->itime += solver->itime;
esolver->p_c_time += solver->p_c_time;
esolver->p_i_time += solver->p_i_time;
if( output )
{
if( output & LIS_EPRINT_MEM ) esolver->rhistory[iter] = resid;
if( output & LIS_EPRINT_OUT ) lis_print_rhistory(comm,iter,resid);
}
if( tol >= resid )
{
esolver->retcode = LIS_SUCCESS;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = theta + oshift;
lis_vector_nrm2(v, &nrm2);
lis_vector_scale(1.0/nrm2, v);
if ( oshift != 0.0 ) lis_matrix_shift_matrix(A, B, -oshift);
lis_precon_destroy(precon);
lis_solver_destroy(solver);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
}
lis_precon_destroy(precon);
esolver->retcode = LIS_MAXITER;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = theta + oshift;
lis_vector_nrm2(v, &nrm2);
lis_vector_scale(1.0/nrm2, v);
if ( oshift != 0.0 ) lis_matrix_shift_matrix(A, B, -oshift);
lis_solver_destroy(solver);
LIS_DEBUG_FUNC_OUT;
return LIS_MAXITER;
}
LIS_INT lis_eii_quad(LIS_ESOLVER esolver)
{
LIS_MATRIX A;
LIS_VECTOR x;
LIS_SCALAR evalue, ievalue;
LIS_SCALAR lshift;
LIS_INT emaxiter;
LIS_REAL tol;
LIS_INT iter,iter2,output;
LIS_REAL nrm2,resid;
LIS_QUAD_PTR qdot_xz;
LIS_VECTOR z,q;
LIS_SOLVER solver;
double time,itime,ptime,p_c_time,p_i_time;
LIS_INT err;
LIS_PRECON precon;
LIS_INT nsol, precon_type;
char solvername[128], preconname[128];
LIS_DEBUG_FUNC_IN;
emaxiter = esolver->options[LIS_EOPTIONS_MAXITER];
tol = esolver->params[LIS_EPARAMS_RESID - LIS_EOPTIONS_LEN];
lshift = esolver->lshift;
output = esolver->options[LIS_EOPTIONS_OUTPUT];
A = esolver->A;
x = esolver->x;
if (esolver->options[LIS_EOPTIONS_INITGUESS_ONES] )
{
lis_vector_set_all(1.0,x);
}
evalue = 1.0;
z = esolver->work[0];
q = esolver->work[1];
LIS_QUAD_SCALAR_MALLOC(qdot_xz,0,1);
iter=0;
ievalue = 1/(evalue);
#ifdef _LONG__DOUBLE
if( output & (A->my_rank==0) ) printf("local shift : %Le\n", lshift);
#else
if( output & (A->my_rank==0) ) printf("local shift : %e\n", lshift);
#endif
if (lshift != 0) lis_matrix_shift_diagonal(A, lshift);
lis_solver_create(&solver);
lis_solver_set_option("-i bicg -p none -precision quad",solver);
lis_solver_set_optionC(solver);
lis_solver_get_solver(solver, &nsol);
lis_solver_get_precon(solver, &precon_type);
lis_solver_get_solvername(nsol, solvername);
lis_solver_get_preconname(precon_type, preconname);
if( output & (A->my_rank==0) ) printf("linear solver : %s\n", solvername);
if( output & (A->my_rank==0) ) printf("preconditioner : %s\n", preconname);
/* create preconditioner */
solver->A = A;
err = lis_precon_create(solver, &precon);
if( err )
{
lis_solver_work_destroy(solver);
solver->retcode = err;
return err;
}
while (iter<emaxiter)
{
iter = iter+1;
/* x = x / ||x||_2 */
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
/* z = (A - lshift I)^-1 * x */
lis_solve_kernel(A, x, z, solver, precon);
lis_solver_get_iter(solver,&iter2);
/* 1/evalue = <x,z> */
lis_vector_dotex_mmm(x, z, &qdot_xz);
lis_quad_minus((LIS_QUAD *)qdot_xz.hi);
lis_vector_axpyzex_mmmm(qdot_xz,x,z,q);
lis_quad_minus((LIS_QUAD *)qdot_xz.hi);
ievalue = qdot_xz.hi[0];
/* resid = ||z - 1/evalue * x||_2 / |1/evalue| */
lis_vector_nrm2(q, &resid);
resid = fabs(resid/ievalue);
/* x = z */
lis_vector_copy(z,x);
/* convergence check */
lis_solver_get_timeex(solver,&time,&itime,&ptime,&p_c_time,&p_i_time);
esolver->ptime += solver->ptime;
esolver->itime += solver->itime;
esolver->p_c_time += solver->p_c_time;
esolver->p_i_time += solver->p_i_time;
if( output )
{
if( output & LIS_EPRINT_MEM ) esolver->rhistory[iter] = resid;
if( output & LIS_EPRINT_OUT && A->my_rank==0 ) lis_print_rhistory(iter,resid);
}
if( tol >= resid )
{
esolver->retcode = LIS_SUCCESS;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = 1/ievalue;
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
if (lshift != 0) lis_matrix_shift_diagonal(A, -lshift);
lis_precon_destroy(precon);
lis_solver_destroy(solver);
LIS_DEBUG_FUNC_OUT;
return LIS_SUCCESS;
}
}
lis_precon_destroy(precon);
esolver->retcode = LIS_MAXITER;
esolver->iter[0] = iter;
esolver->resid[0] = resid;
esolver->evalue[0] = 1/ievalue;
lis_vector_nrm2(x, &nrm2);
lis_vector_scale(1/nrm2, x);
if (lshift != 0)
{
lis_matrix_shift_diagonal(A, -lshift);
}
lis_solver_destroy(solver);
LIS_DEBUG_FUNC_OUT;
return LIS_MAXITER;
}