static void PrintFinalStats(void *cvode_mem)
{
long int lenrw, leniw ;
long int lenrwSPGMR, leniwSPGMR;
long int nst, nfe, nsetups, nni, ncfn, netf;
long int nli, npe, nps, ncfl, nfeSPGMR;
int flag;
flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw);
flag = CVodeGetNumSteps(cvode_mem, &nst);
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
flag = CVSpilsGetWorkSpace(cvode_mem, &lenrwSPGMR, &leniwSPGMR);
flag = CVSpilsGetNumLinIters(cvode_mem, &nli);
flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe);
flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps);
flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl);
flag = CVSpilsGetNumRhsEvals(cvode_mem, &nfeSPGMR);
printf("\nFinal Statistics.. \n\n");
printf("lenrw = %6ld leniw = %6ld\n", lenrw, leniw);
printf("llrw = %6ld lliw = %6ld\n", lenrwSPGMR, leniwSPGMR);
printf("nst = %6ld\n" , nst);
printf("nfe = %6ld nfel = %6ld\n" , nfe, nfeSPGMR);
printf("nni = %6ld nli = %6ld\n" , nni, nli);
printf("nsetups = %6ld netf = %6ld\n" , nsetups, netf);
printf("npe = %6ld nps = %6ld\n" , npe, nps);
printf("ncfn = %6ld ncfl = %6ld\n\n", ncfn, ncfl);
}
static void PrintFinalStats(void *cvode_mem)
{
long int lenrw, leniw ;
long int lenrwLS, leniwLS;
long int lenrwBP, leniwBP;
long int nst, nfe, nsetups, nni, ncfn, netf;
long int nli, npe, nps, ncfl, nfeLS;
long int nfeBP;
int flag;
flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw);
check_flag(&flag, "CVodeGetWorkSpace", 1);
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1);
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1);
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1);
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1);
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1);
flag = CVSpilsGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS);
check_flag(&flag, "CVSpilsGetWorkSpace", 1);
flag = CVSpilsGetNumLinIters(cvode_mem, &nli);
check_flag(&flag, "CVSpilsGetNumLinIters", 1);
flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe);
check_flag(&flag, "CVSpilsGetNumPrecEvals", 1);
flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps);
check_flag(&flag, "CVSpilsGetNumPrecSolves", 1);
flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl);
check_flag(&flag, "CVSpilsGetNumConvFails", 1);
flag = CVSpilsGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVSpilsGetNumRhsEvals", 1);
flag = CVBandPrecGetWorkSpace(cvode_mem, &lenrwBP, &leniwBP);
check_flag(&flag, "CVBandPrecGetWorkSpace", 1);
flag = CVBandPrecGetNumRhsEvals(cvode_mem, &nfeBP);
check_flag(&flag, "CVBandPrecGetNumRhsEvals", 1);
printf("\nFinal Statistics.. \n\n");
printf("lenrw = %5ld leniw = %5ld\n", lenrw, leniw);
printf("lenrwls = %5ld leniwls = %5ld\n", lenrwLS, leniwLS);
printf("lenrwbp = %5ld leniwbp = %5ld\n", lenrwBP, leniwBP);
printf("nst = %5ld\n" , nst);
printf("nfe = %5ld nfetot = %5ld\n" , nfe, nfe+nfeLS+nfeBP);
printf("nfeLS = %5ld nfeBP = %5ld\n" , nfeLS, nfeBP);
printf("nni = %5ld nli = %5ld\n" , nni, nli);
printf("nsetups = %5ld netf = %5ld\n" , nsetups, netf);
printf("npe = %5ld nps = %5ld\n" , npe, nps);
printf("ncfn = %5ld ncfl = %5ld\n\n", ncfn, ncfl);
}
static void PrintFinalStats(void *cvode_mem)
{
long int lenrw, leniw ;
long int lenrwLS, leniwLS;
long int lenrwBBDP, leniwBBDP, ngevalsBBDP;
long int nst, nfe, nsetups, nni, ncfn, netf;
long int nli, npe, nps, ncfl, nfeLS;
int flag;
flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw);
check_flag(&flag, "CVodeGetWorkSpace", 1, 0);
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1, 0);
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1, 0);
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1, 0);
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1, 0);
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1, 0);
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1, 0);
flag = CVSpilsGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS);
check_flag(&flag, "CVSpilsGetWorkSpace", 1, 0);
flag = CVSpilsGetNumLinIters(cvode_mem, &nli);
check_flag(&flag, "CVSpilsGetNumLinIters", 1, 0);
flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe);
check_flag(&flag, "CVSpilsGetNumPrecEvals", 1, 0);
flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps);
check_flag(&flag, "CVSpilsGetNumPrecSolves", 1, 0);
flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl);
check_flag(&flag, "CVSpilsGetNumConvFails", 1, 0);
flag = CVSpilsGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVSpilsGetNumRhsEvals", 1, 0);
printf("\nFinal Statistics: \n\n");
printf("lenrw = %5ld leniw = %5ld\n", lenrw, leniw);
printf("lenrwls = %5ld leniwls = %5ld\n", lenrwLS, leniwLS);
printf("nst = %5ld\n" , nst);
printf("nfe = %5ld nfels = %5ld\n" , nfe, nfeLS);
printf("nni = %5ld nli = %5ld\n" , nni, nli);
printf("nsetups = %5ld netf = %5ld\n" , nsetups, netf);
printf("npe = %5ld nps = %5ld\n" , npe, nps);
printf("ncfn = %5ld ncfl = %5ld\n\n", ncfn, ncfl);
flag = CVBBDPrecGetWorkSpace(cvode_mem, &lenrwBBDP, &leniwBBDP);
check_flag(&flag, "CVBBDPrecGetWorkSpace", 1, 0);
flag = CVBBDPrecGetNumGfnEvals(cvode_mem, &ngevalsBBDP);
check_flag(&flag, "CVBBDPrecGetNumGfnEvals", 1, 0);
printf("In CVBBDPRE: real/integer local work space sizes = %ld, %ld\n",
lenrwBBDP, leniwBBDP);
printf(" no. flocal evals. = %ld\n",ngevalsBBDP);
}
PetscErrorCode TSStep_Sundials_Nonlinear(TS ts,int *steps,double *time)
{
TS_Sundials *cvode = (TS_Sundials*)ts->data;
Vec sol = ts->vec_sol;
PetscErrorCode ierr;
PetscInt i,max_steps = ts->max_steps,flag;
long int its;
realtype t,tout;
PetscScalar *y_data;
void *mem;
PetscFunctionBegin;
mem = cvode->mem;
tout = ts->max_time;
ierr = VecGetArray(ts->vec_sol,&y_data);CHKERRQ(ierr);
N_VSetArrayPointer((realtype *)y_data,cvode->y);
ierr = VecRestoreArray(ts->vec_sol,PETSC_NULL);CHKERRQ(ierr);
for (i = 0; i < max_steps; i++) {
if (ts->ptime >= ts->max_time) break;
ierr = TSPreStep(ts);CHKERRQ(ierr);
if (cvode->monitorstep){
flag = CVode(mem,tout,cvode->y,&t,CV_ONE_STEP);
} else {
flag = CVode(mem,tout,cvode->y,&t,CV_NORMAL);
}
if (flag)SETERRQ1(PETSC_ERR_LIB,"CVode() fails, flag %d",flag);
if (t > ts->max_time && cvode->exact_final_time) {
/* interpolate to final requested time */
ierr = CVodeGetDky(mem,tout,0,cvode->y);CHKERRQ(ierr);
t = tout;
}
ts->time_step = t - ts->ptime;
ts->ptime = t;
/* copy the solution from cvode->y to cvode->update and sol */
ierr = VecPlaceArray(cvode->w1,y_data); CHKERRQ(ierr);
ierr = VecCopy(cvode->w1,cvode->update);CHKERRQ(ierr);
ierr = VecResetArray(cvode->w1); CHKERRQ(ierr);
ierr = VecCopy(cvode->update,sol);CHKERRQ(ierr);
ierr = CVodeGetNumNonlinSolvIters(mem,&its);CHKERRQ(ierr);
ts->nonlinear_its = its;
ierr = CVSpilsGetNumLinIters(mem, &its);
ts->linear_its = its;
ts->steps++;
ierr = TSPostStep(ts);CHKERRQ(ierr);
ierr = TSMonitor(ts,ts->steps,t,sol);CHKERRQ(ierr);
}
*steps += ts->steps;
*time = t;
PetscFunctionReturn(0);
}
PetscErrorCode TSView_Sundials(TS ts,PetscViewer viewer)
{
TS_Sundials *cvode = (TS_Sundials*)ts->data;
PetscErrorCode ierr;
char *type;
char atype[] = "Adams";
char btype[] = "BDF: backward differentiation formula";
PetscBool iascii,isstring;
long int nsteps,its,nfevals,nlinsetups,nfails,itmp;
PetscInt qlast,qcur;
PetscReal hinused,hlast,hcur,tcur,tolsfac;
PC pc;
PetscFunctionBegin;
if (cvode->cvode_type == SUNDIALS_ADAMS) type = atype;
else type = btype;
ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr);
if (iascii) {
ierr = PetscViewerASCIIPrintf(viewer,"Sundials integrater does not use SNES!\n");CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials integrater type %s\n",type);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials abs tol %g rel tol %g\n",cvode->abstol,cvode->reltol);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials linear solver tolerance factor %g\n",cvode->linear_tol);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials max dimension of Krylov subspace %D\n",cvode->maxl);CHKERRQ(ierr);
if (cvode->gtype == SUNDIALS_MODIFIED_GS) {
ierr = PetscViewerASCIIPrintf(viewer,"Sundials using modified Gram-Schmidt for orthogonalization in GMRES\n");CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIPrintf(viewer,"Sundials using unmodified (classical) Gram-Schmidt for orthogonalization in GMRES\n");CHKERRQ(ierr);
}
if (cvode->mindt > 0) {ierr = PetscViewerASCIIPrintf(viewer,"Sundials minimum time step %g\n",cvode->mindt);CHKERRQ(ierr);}
if (cvode->maxdt > 0) {ierr = PetscViewerASCIIPrintf(viewer,"Sundials maximum time step %g\n",cvode->maxdt);CHKERRQ(ierr);}
/* Outputs from CVODE, CVSPILS */
ierr = CVodeGetTolScaleFactor(cvode->mem,&tolsfac);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials suggested factor for tolerance scaling %g\n",tolsfac);CHKERRQ(ierr);
ierr = CVodeGetIntegratorStats(cvode->mem,&nsteps,&nfevals,
&nlinsetups,&nfails,&qlast,&qcur,
&hinused,&hlast,&hcur,&tcur);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials cumulative number of internal steps %D\n",nsteps);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of calls to rhs function %D\n",nfevals);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of calls to linear solver setup function %D\n",nlinsetups);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of error test failures %D\n",nfails);CHKERRQ(ierr);
ierr = CVodeGetNonlinSolvStats(cvode->mem,&its,&nfails);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of nonlinear solver iterations %D\n",its);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of nonlinear convergence failure %D\n",nfails);CHKERRQ(ierr);
ierr = CVSpilsGetNumLinIters(cvode->mem, &its);CHKERRQ(ierr); /* its = no. of calls to TSPrecond_Sundials() */
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of linear iterations %D\n",its);CHKERRQ(ierr);
ierr = CVSpilsGetNumConvFails(cvode->mem,&itmp);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of linear convergence failures %D\n",itmp);CHKERRQ(ierr);
ierr = TSSundialsGetPC(ts,&pc);CHKERRQ(ierr);
ierr = PCView(pc,viewer);CHKERRQ(ierr);
ierr = CVSpilsGetNumPrecEvals(cvode->mem,&itmp);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of preconditioner evaluations %D\n",itmp);CHKERRQ(ierr);
ierr = CVSpilsGetNumPrecSolves(cvode->mem,&itmp);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of preconditioner solves %D\n",itmp);CHKERRQ(ierr);
ierr = CVSpilsGetNumJtimesEvals(cvode->mem,&itmp);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of Jacobian-vector product evaluations %D\n",itmp);CHKERRQ(ierr);
ierr = CVSpilsGetNumRhsEvals(cvode->mem,&itmp);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Sundials no. of rhs calls for finite diff. Jacobian-vector evals %D\n",itmp);CHKERRQ(ierr);
} else if (isstring) {
ierr = PetscViewerStringSPrintf(viewer,"Sundials type %s",type);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode TSStep_Sundials(TS ts)
{
TS_Sundials *cvode = (TS_Sundials*)ts->data;
PetscErrorCode ierr;
PetscInt flag;
long int its,nsteps;
realtype t,tout;
PetscScalar *y_data;
void *mem;
PetscFunctionBegin;
mem = cvode->mem;
tout = ts->max_time;
ierr = VecGetArray(ts->vec_sol,&y_data);CHKERRQ(ierr);
N_VSetArrayPointer((realtype*)y_data,cvode->y);
ierr = VecRestoreArray(ts->vec_sol,NULL);CHKERRQ(ierr);
ierr = TSPreStep(ts);CHKERRQ(ierr);
/* We would like to call TSPreStep() when starting each step (including rejections) and TSPreStage() before each
* stage solve, but CVode does not appear to support this. */
if (cvode->monitorstep) flag = CVode(mem,tout,cvode->y,&t,CV_ONE_STEP);
else flag = CVode(mem,tout,cvode->y,&t,CV_NORMAL);
if (flag) { /* display error message */
switch (flag) {
case CV_ILL_INPUT:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_ILL_INPUT");
break;
case CV_TOO_CLOSE:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_TOO_CLOSE");
break;
case CV_TOO_MUCH_WORK: {
PetscReal tcur;
ierr = CVodeGetNumSteps(mem,&nsteps);CHKERRQ(ierr);
ierr = CVodeGetCurrentTime(mem,&tcur);CHKERRQ(ierr);
SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_TOO_MUCH_WORK. At t=%G, nsteps %D exceeds mxstep %D. Increase '-ts_max_steps <>' or modify TSSetDuration()",tcur,nsteps,ts->max_steps);
} break;
case CV_TOO_MUCH_ACC:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_TOO_MUCH_ACC");
break;
case CV_ERR_FAILURE:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_ERR_FAILURE");
break;
case CV_CONV_FAILURE:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_CONV_FAILURE");
break;
case CV_LINIT_FAIL:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_LINIT_FAIL");
break;
case CV_LSETUP_FAIL:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_LSETUP_FAIL");
break;
case CV_LSOLVE_FAIL:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_LSOLVE_FAIL");
break;
case CV_RHSFUNC_FAIL:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_RHSFUNC_FAIL");
break;
case CV_FIRST_RHSFUNC_ERR:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_FIRST_RHSFUNC_ERR");
break;
case CV_REPTD_RHSFUNC_ERR:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_REPTD_RHSFUNC_ERR");
break;
case CV_UNREC_RHSFUNC_ERR:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_UNREC_RHSFUNC_ERR");
break;
case CV_RTFUNC_FAIL:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, CV_RTFUNC_FAIL");
break;
default:
SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVode() fails, flag %d",flag);
}
}
/* copy the solution from cvode->y to cvode->update and sol */
ierr = VecPlaceArray(cvode->w1,y_data);CHKERRQ(ierr);
ierr = VecCopy(cvode->w1,cvode->update);CHKERRQ(ierr);
ierr = VecResetArray(cvode->w1);CHKERRQ(ierr);
ierr = VecCopy(cvode->update,ts->vec_sol);CHKERRQ(ierr);
ierr = CVodeGetNumNonlinSolvIters(mem,&its);CHKERRQ(ierr);
ierr = CVSpilsGetNumLinIters(mem, &its);
ts->snes_its = its; ts->ksp_its = its;
ts->time_step = t - ts->ptime;
ts->ptime = t;
ts->steps++;
ierr = CVodeGetNumSteps(mem,&nsteps);CHKERRQ(ierr);
if (!cvode->monitorstep) ts->steps = nsteps;
PetscFunctionReturn(0);
}
static void PrintFinalStats(void *cvode_mem)
{
long int lenrw, leniw ;
long int lenrwLS, leniwLS;
long int nst, nfe, nsetups, nni, ncfn, netf;
long int nli, npe, nps, ncfl, nfeLS;
int flag;
realtype avdim;
flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw);
check_flag(&flag, "CVodeGetWorkSpace", 1);
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1);
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1);
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1);
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1);
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1);
flag = CVSpilsGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS);
check_flag(&flag, "CVSpilsGetWorkSpace", 1);
flag = CVSpilsGetNumLinIters(cvode_mem, &nli);
check_flag(&flag, "CVSpilsGetNumLinIters", 1);
flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe);
check_flag(&flag, "CVSpilsGetNumPrecEvals", 1);
flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps);
check_flag(&flag, "CVSpilsGetNumPrecSolves", 1);
flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl);
check_flag(&flag, "CVSpilsGetNumConvFails", 1);
flag = CVSpilsGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVSpilsGetNumRhsEvals", 1);
printf("\n\n Final statistics for this run:\n\n");
printf(" CVode real workspace length = %4ld \n", lenrw);
printf(" CVode integer workspace length = %4ld \n", leniw);
printf(" CVSPGMR real workspace length = %4ld \n", lenrwLS);
printf(" CVSPGMR integer workspace length = %4ld \n", leniwLS);
printf(" Number of steps = %4ld \n", nst);
printf(" Number of f-s = %4ld \n", nfe);
printf(" Number of f-s (SPGMR) = %4ld \n", nfeLS);
printf(" Number of f-s (TOTAL) = %4ld \n", nfe + nfeLS);
printf(" Number of setups = %4ld \n", nsetups);
printf(" Number of nonlinear iterations = %4ld \n", nni);
printf(" Number of linear iterations = %4ld \n", nli);
printf(" Number of preconditioner evaluations = %4ld \n", npe);
printf(" Number of preconditioner solves = %4ld \n", nps);
printf(" Number of error test failures = %4ld \n", netf);
printf(" Number of nonlinear conv. failures = %4ld \n", ncfn);
printf(" Number of linear convergence failures = %4ld \n", ncfl);
avdim = (nni > 0) ? ((realtype)nli)/((realtype)nni) : ZERO;
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" Average Krylov subspace dimension = %.3Lf \n", avdim);
#else
printf(" Average Krylov subspace dimension = %.3f \n", avdim);
#endif
printf("\n\n--------------------------------------------------------------");
printf("--------------\n");
printf( "--------------------------------------------------------------");
printf("--------------\n");
}
/*
* Get and print some final statistics
*/
void PrintFinalStats(struct Integrator* integrator)
{
void* cvode_mem = integrator->cvode_mem;
long int lenrw = -1, leniw = -1, nst = -1, nfe = -1, nsetups = -1, nni = -1, ncfn = -1, netf = -1;
long int lenrwLS = -1, leniwLS = -1, nje = -1, nfeLS = -1,npe = -1,nps = -1,ncfl = -1,nli = -1;
int flag;
flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw);
check_flag(&flag, "CVodeGetWorkSpace", 1);
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1);
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1);
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1);
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1);
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1);
printf("\n Final integrator statistics for this run:\n");
printf(" (MM: %s; IM: %s; LS: %s; max-step: %0.4le)\n",
multistepMethodToString(
simulationGetMultistepMethod(integrator->simulation)),
iterationMethodToString(
simulationGetIterationMethod(integrator->simulation)),
linearSolverToString(simulationGetLinearSolver(integrator->simulation)),
simulationGetBvarMaxStep(integrator->simulation));
printf(" CVode real workspace length = %4ld \n", lenrw);
printf(" CVode integer workspace length = %4ld \n", leniw);
printf(" Number of steps = %4ld \n", nst);
printf(" Number of f-s = %4ld \n", nfe);
printf(" Number of setups = %4ld \n", nsetups);
printf(" Number of nonlinear iterations = %4ld \n", nni);
printf(" Number of nonlinear convergence failures = %4ld \n", ncfn);
printf(" Number of error test failures = %4ld \n\n",netf);
if (simulationGetIterationMethod(integrator->simulation) == NEWTON)
{
enum LinearSolver solver =
simulationGetLinearSolver(integrator->simulation);
switch(solver)
{
case DENSE:
{
//flag = CVDenseGetNumJacEvals(cvode_mem, &nje);
//check_flag(&flag, "CVDenseGetNumJacEvals", 1);
//flag = CVDenseGetNumRhsEvals(cvode_mem, &nfeLS);
//check_flag(&flag, "CVDenseGetNumRhsEvals", 1);
//flag = CVDenseGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS);
//check_flag(&flag, "CVDenseGetWorkSpace", 1);
} break;
case BAND:
{
//flag = CVBandGetNumJacEvals(cvode_mem, &nje);
//check_flag(&flag, "CVBandGetNumJacEvals", 1);
//flag = CVBandGetNumRhsEvals(cvode_mem, &nfeLS);
//check_flag(&flag, "CVBandGetNumRhsEvals", 1);
//flag = CVBandGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS);
//check_flag(&flag, "CVBandGetWorkSpace", 1);
} break;
case DIAG:
{
nje = nsetups;
flag = CVDiagGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVDiagGetNumRhsEvals", 1);
flag = CVDiagGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS);
check_flag(&flag, "CVDiagGetWorkSpace", 1);
} break;
case SPGMR:
case SPBCG:
case SPTFQMR:
{
nje = nsetups;
flag = CVSpilsGetWorkSpace(cvode_mem,&lenrwLS,&leniwLS);
check_flag(&flag, "CVSpilsGetWorkSpace", 1);
flag = CVSpilsGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVSpilsGetNumRhsEvals", 1);
flag = CVSpilsGetNumLinIters(cvode_mem, &nli);
check_flag(&flag, "CVSpilsGetNumLinIters", 1);
flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe);
check_flag(&flag, "CVSpilsGetNumPrecEvals", 1);
flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps);
check_flag(&flag, "CVSpilsGetNumPrecSolves", 1);
flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl);
check_flag(&flag, "CVSpilsGetNumConvFails", 1);
} break;
default:
{
nje = -1;
nfeLS = -1;
lenrwLS = -1;
leniwLS = -1;
}
break;
}
printf(" Linear solver real workspace length = %4ld \n", lenrwLS);
printf(" Linear solver integer workspace length = %4ld \n", leniwLS);
printf(" Number of Jacobian evaluations = %4ld \n", nje);
printf(" Number of f evals. in linear solver = %4ld \n", nfeLS);
if ((solver == SPGMR) || (solver == SPBCG) ||
(solver == SPTFQMR))
{
printf(" Number of linear iterations = %4ld \n",nli);
printf(" Number of preconditioner evaluations = %4ld \n",npe);
printf(" Number of preconditioner solves = %4ld \n",nps);
printf(" Number of convergence failures = %4ld \n",ncfl);
}
printf("\n");
}
}
static void PrintFinalStats(void *cvode_mem, booleantype sensi)
{
long int nst;
long int nfe, nsetups, nni, ncfn, netf;
long int nfSe, nfeS, nsetupsS, nniS, ncfnS, netfS;
long int nli, ncfl, npe, nps;
int flag;
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1);
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1);
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1);
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1);
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1);
if (sensi) {
flag = CVodeGetNumSensRhsEvals(cvode_mem, &nfSe);
check_flag(&flag, "CVodeGetNumSensRhsEvals", 1);
flag = CVodeGetNumRhsEvalsSens(cvode_mem, &nfeS);
check_flag(&flag, "CVodeGetNumRhsEvalsSens", 1);
flag = CVodeGetNumSensLinSolvSetups(cvode_mem, &nsetupsS);
check_flag(&flag, "CVodeGetNumSensLinSolvSetups", 1);
flag = CVodeGetNumSensErrTestFails(cvode_mem, &netfS);
check_flag(&flag, "CVodeGetNumSensErrTestFails", 1);
flag = CVodeGetNumSensNonlinSolvIters(cvode_mem, &nniS);
check_flag(&flag, "CVodeGetNumSensNonlinSolvIters", 1);
flag = CVodeGetNumSensNonlinSolvConvFails(cvode_mem, &ncfnS);
check_flag(&flag, "CVodeGetNumSensNonlinSolvConvFails", 1);
}
flag = CVSpilsGetNumLinIters(cvode_mem, &nli);
check_flag(&flag, "CVSpilsGetNumLinIters", 1);
flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl);
check_flag(&flag, "CVSpilsGetNumConvFails", 1);
flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe);
check_flag(&flag, "CVSpilsGetNumPrecEvals", 1);
flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps);
check_flag(&flag, "CVSpilsGetNumPrecSolves", 1);
printf("\nFinal Statistics\n\n");
printf("nst = %5ld\n\n", nst);
printf("nfe = %5ld\n", nfe);
printf("netf = %5ld nsetups = %5ld\n", netf, nsetups);
printf("nni = %5ld ncfn = %5ld\n", nni, ncfn);
if(sensi) {
printf("\n");
printf("nfSe = %5ld nfeS = %5ld\n", nfSe, nfeS);
printf("netfs = %5ld nsetupsS = %5ld\n", netfS, nsetupsS);
printf("nniS = %5ld ncfnS = %5ld\n", nniS, ncfnS);
}
printf("\n");
printf("nli = %5ld ncfl = %5ld\n", nli, ncfl);
printf("npe = %5ld nps = %5ld\n", npe, nps);
}