static void PrintFinalStats(void *mem)
{
int retval;
long int nst, nni, nje, nre, nreLS, netf, ncfn, nge;
retval = IDAGetNumSteps(mem, &nst);
check_flag(&retval, "IDAGetNumSteps", 1);
retval = IDAGetNumResEvals(mem, &nre);
check_flag(&retval, "IDAGetNumResEvals", 1);
retval = IDASlsGetNumJacEvals(mem, &nje);
check_flag(&retval, "IDASlsGetNumJacEvals", 1);
retval = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&retval, "IDAGetNumNonlinSolvIters", 1);
retval = IDAGetNumErrTestFails(mem, &netf);
check_flag(&retval, "IDAGetNumErrTestFails", 1);
retval = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&retval, "IDAGetNumNonlinSolvConvFails", 1);
/* retval = IDASlsGetNumResEvals(mem, &nreLS); */
/* check_flag(&retval, "IDASlsGetNumResEvals", 1); */
nreLS = 0;
retval = IDAGetNumGEvals(mem, &nge);
check_flag(&retval, "IDAGetNumGEvals", 1);
printf("\nFinal Run Statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre+nreLS);
printf("Number of Jacobian evaluations = %ld\n", nje);
printf("Number of nonlinear iterations = %ld\n", nni);
printf("Number of error test failures = %ld\n", netf);
printf("Number of nonlinear conv. failures = %ld\n", ncfn);
printf("Number of root fn. evaluations = %ld\n", nge);
}
CAMLprim value sundials_ml_ida_get_num_res_evals(value ida_solver, value nrevals) {
CAMLparam2(ida_solver, nrevals);
long int _nrevals;
const int ret = IDAGetNumResEvals(IDA_MEM(ida_solver), &_nrevals);
Store_field(nrevals, 0, Val_int(_nrevals));
CAMLreturn(Val_int(ret));
}
static void PrintFinalStats(void *ida_mem)
{
long int nst, nre, nreLS, nni, nje, netf, ncfn;
int retval;
retval = IDAGetNumSteps(ida_mem, &nst);
check_retval(&retval, "IDAGetNumSteps", 1);
retval = IDAGetNumNonlinSolvIters(ida_mem, &nni);
check_retval(&retval, "IDAGetNumNonlinSolvIters", 1);
retval = IDAGetNumResEvals(ida_mem, &nre);
check_retval(&retval, "IDAGetNumResEvals", 1);
retval = IDAGetNumErrTestFails(ida_mem, &netf);
check_retval(&retval, "IDAGetNumErrTestFails", 1);
retval = IDAGetNumNonlinSolvConvFails(ida_mem, &ncfn);
check_retval(&retval, "IDAGetNumNonlinSolvConvFails", 1);
retval = IDAGetNumJacEvals(ida_mem, &nje);
check_retval(&retval, "IDAGetNumJacEvals", 1);
retval = IDAGetNumLinResEvals(ida_mem, &nreLS);
check_retval(&retval, "IDAGetNumLinResEvals", 1);
printf("-----------------------------------------------------------\n");
printf("Final run statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre+nreLS);
printf("Number of Jacobian evaluations = %ld\n", nje);
printf("Number of nonlinear iterations = %ld\n", nni);
printf("Number of error test failures = %ld\n", netf);
printf("Number of nonlinear conv. failures = %ld\n", ncfn);
}
static void PrintOutput(void *mem, realtype t, N_Vector uu)
{
int ier;
realtype umax, hused;
long int nst, nni, nje, nre;
int kused;
umax = N_VMaxNorm(uu);
ier = IDAGetLastOrder(mem, &kused);
check_flag(&ier, "IDAGetLastOrder", 1);
ier = IDAGetNumSteps(mem, &nst);
check_flag(&ier, "IDAGetNumSteps", 1);
ier = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&ier, "IDAGetNumNonlinSolvIters", 1);
ier = IDAGetNumResEvals(mem, &nre);
check_flag(&ier, "IDAGetNumResEvals", 1);
ier = IDAGetLastStep(mem, &hused);
check_flag(&ier, "IDAGetLastStep", 1);
ier = IDASlsGetNumJacEvals(mem, &nje);
check_flag(&ier, "IDASlsGetNumJacEvals", 1);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" %5.2Lf %13.5Le %d %3ld %3ld %3ld %4ld %9.2Le \n",
t, umax, kused, nst, nni, nje, nre, hused);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %9.2e \n",
t, umax, kused, nst, nni, nje, nre, hused);
#else
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %9.2e \n",
t, umax, kused, nst, nni, nje, nre, hused);
#endif
}
static void PrintFinalStats(void *mem)
{
long int nst, nre, sli, netf, nps, npevals, nrevalsLS;
int flag;
flag = IDAGetNumSteps(mem, &nst);
check_flag(&flag, "IDAGetNumSteps", 1);
flag = IDASpilsGetNumLinIters(mem, &sli);
check_flag(&flag, "IDAGetNumNonlinSolvIters", 1);
flag = IDAGetNumResEvals(mem, &nre);
check_flag(&flag, "IDAGetNumResEvals", 1);
flag = IDAGetNumErrTestFails(mem, &netf);
check_flag(&flag, "IDAGetNumErrTestFails", 1);
flag = IDASpilsGetNumPrecSolves(mem, &nps);
check_flag(&flag, "IDAGetNumNonlinSolvConvFails", 1);
flag = IDASpilsGetNumPrecEvals(mem, &npevals);
check_flag(&flag, "IDADlsGetNumJacEvals", 1);
flag = IDASpilsGetNumResEvals(mem, &nrevalsLS);
check_flag(&flag, "IDADlsGetNumResEvals", 1);
printf("-----------------------------------------------------------\n");
printf("Final run statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre);
printf("Number of Preconditioner evaluations = %ld\n", npevals);
printf("Number of linear iterations = %ld\n", sli);
printf("Number of error test failures = %ld\n", netf);
printf("Number of precond solve fun called = %ld\n", nps);
}
static void PrintFinalStats(void *mem)
{
long int nst, nre, nreLS, netf, ncfn, nni, ncfl, nli, npe, nps, nge;
int flag;
flag = IDAGetNumSteps(mem, &nst);
check_flag(&flag, "IDAGetNumSteps", 1, 0);
flag = IDAGetNumResEvals(mem, &nre);
check_flag(&flag, "IDAGetNumResEvals", 1, 0);
flag = IDAGetNumErrTestFails(mem, &netf);
check_flag(&flag, "IDAGetNumErrTestFails", 1, 0);
flag = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&flag, "IDAGetNumNonlinSolvConvFails", 1, 0);
flag = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&flag, "IDAGetNumNonlinSolvIters", 1, 0);
flag = IDASpilsGetNumConvFails(mem, &ncfl);
check_flag(&flag, "IDASpilsGetNumConvFails", 1, 0);
flag = IDASpilsGetNumLinIters(mem, &nli);
check_flag(&flag, "IDASpilsGetNumLinIters", 1, 0);
flag = IDASpilsGetNumPrecEvals(mem, &npe);
check_flag(&flag, "IDASpilsGetNumPrecEvals", 1, 0);
flag = IDASpilsGetNumPrecSolves(mem, &nps);
check_flag(&flag, "IDASpilsGetNumPrecSolves", 1, 0);
flag = IDASpilsGetNumResEvals(mem, &nreLS);
check_flag(&flag, "IDASpilsGetNumResEvals", 1, 0);
flag = IDABBDPrecGetNumGfnEvals(mem, &nge);
check_flag(&flag, "IDABBDPrecGetNumGfnEvals", 1, 0);
printf("-----------------------------------------------------------\n");
printf("\nFinal statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre+nreLS);
printf("Number of nonlinear iterations = %ld\n", nni);
printf("Number of error test failures = %ld\n", netf);
printf("Number of nonlinear conv. failures = %ld\n\n", ncfn);
printf("Number of linear iterations = %ld\n", nli);
printf("Number of linear conv. failures = %ld\n\n", ncfl);
printf("Number of preconditioner setups = %ld\n", npe);
printf("Number of preconditioner solves = %ld\n", nps);
printf("Number of local residual evals. = %ld\n", nge);
}
static void PrintOutput(int id, void *mem, realtype t, N_Vector uu)
{
realtype umax, hused;
int kused, ier;
long int nst, nni, nre, nli, npe, nps, nreLS, nge;
umax = N_VMaxNorm(uu);
if (id == 0) {
ier = IDAGetLastOrder(mem, &kused);
check_flag(&ier, "IDAGetLastOrder", 1, id);
ier = IDAGetNumSteps(mem, &nst);
check_flag(&ier, "IDAGetNumSteps", 1, id);
ier = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&ier, "IDAGetNumNonlinSolvIters", 1, id);
ier = IDAGetNumResEvals(mem, &nre);
check_flag(&ier, "IDAGetNumResEvals", 1, id);
ier = IDAGetLastStep(mem, &hused);
check_flag(&ier, "IDAGetLastStep", 1, id);
ier = IDASpilsGetNumLinIters(mem, &nli);
check_flag(&ier, "IDASpilsGetNumLinIters", 1, id);
ier = IDASpilsGetNumResEvals(mem, &nreLS);
check_flag(&ier, "IDASpilsGetNumResEvals", 1, id);
ier = IDABBDPrecGetNumGfnEvals(mem, &nge);
check_flag(&ier, "IDABBDPrecGetNumGfnEvals", 1, id);
ier = IDASpilsGetNumPrecEvals(mem, &npe);
check_flag(&ier, "IDASpilsGetPrecEvals", 1, id);
ier = IDASpilsGetNumPrecSolves(mem, &nps);
check_flag(&ier, "IDASpilsGetNumPrecSolves", 1, id);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" %5.2Lf %13.5Le %d %3ld %3ld %3ld %4ld %4ld %4ld %9.2Le %3ld %3ld\n",
t, umax, kused, nst, nni, nli, nre, nreLS, nge, hused, npe, nps);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %4ld %4ld %9.2e %3ld %3ld\n",
t, umax, kused, nst, nni, nli, nre, nreLS, nge, hused, npe, nps);
#else
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %4ld %4ld %9.2e %3ld %3ld\n",
t, umax, kused, nst, nni, nli, nre, nreLS, nge, hused, npe, nps);
#endif
}
}
void SundialsIda::printStats(clock_t dt)
{
long int nst, nje, nre, netf, ncfn, nge, npe, nps;
int retval;
retval = IDAGetNumSteps(sundialsMem, &nst);
check_flag(&retval, "IDAGetNumSteps", 1);
retval = IDAGetNumResEvals(sundialsMem, &nre);
check_flag(&retval, "IDAGetNumResEvals", 1);
retval = IDAGetNumErrTestFails(sundialsMem, &netf);
check_flag(&retval, "IDAGetNumErrTestFails", 1);
retval = IDAGetNumNonlinSolvConvFails(sundialsMem, &ncfn);
check_flag(&retval, "IDAGetNumNonlinSolvConvFails", 1);
if (findRoots) {
retval = IDAGetNumGEvals(sundialsMem, &nge);
check_flag(&retval, "IDAGetNumGEvals", 1);
}
retval = IDASpilsGetNumJtimesEvals(sundialsMem, &nje);
check_flag(&retval, "IDASpilsGetNumJtimesEvals", 1);
retval = IDASpilsGetNumPrecEvals(sundialsMem, &npe);
check_flag(&retval, "IDASpilsGetPrecEvals", 1);
retval = IDASpilsGetNumPrecSolves(sundialsMem, &nps);
check_flag(&retval, "IDASpilsGetNumPrecSolves", 1);
printf("\nIDA Solver Statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre);
printf("Number of error test failures = %ld\n", netf);
printf("Number of nonlinear conv. failures = %ld\n", ncfn);
if (findRoots) {
printf("Number of root fn. evaluations = %ld\n", nge);
}
printf("Number of J-v Evaluations = %ld\n", nje);
printf("Number of preconditioner evals. = %ld\n", npe);
printf("Number of preconditioner solves = %ld\n", nps);
retval = IDAGetNumSteps(sundialsMem, &nst);
if (dt == 0) {
logFile.write(format("IDA solver took %i steps.\n") % nst);
} else {
logFile.write(format("IDA solver took %i steps in %f seconds.\n") %
nst % (((double) dt)/CLOCKS_PER_SEC));
}
}
static void PrintFinalStats(void *mem)
{
int flag;
long int nst, nni, nje, nre, nreLS, netf, ncfn;
flag = IDAGetNumSteps(mem, &nst);
flag = IDAGetNumResEvals(mem, &nre);
flag = IDADlsGetNumJacEvals(mem, &nje);
flag = IDAGetNumNonlinSolvIters(mem, &nni);
flag = IDAGetNumErrTestFails(mem, &netf);
flag = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
flag = IDADlsGetNumResEvals(mem, &nreLS);
printf("\nFinal Run Statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre+nreLS);
printf("Number of Jacobian evaluations = %ld\n", nje);
printf("Number of nonlinear iterations = %ld\n", nni);
printf("Number of error test failures = %ld\n", netf);
printf("Number of nonlinear conv. failures = %ld\n", ncfn);
}
static void PrintOutput(void *mem, realtype t, N_Vector uu)
{
realtype hused, umax;
long int nst, nni, nje, nre, nreS, nli, npe, nps;
int kused, ier;
umax = N_VMaxNorm(uu);
ier = IDAGetLastOrder(mem, &kused);
check_flag(&ier, "IDAGetLastOrder", 1);
ier = IDAGetNumSteps(mem, &nst);
check_flag(&ier, "IDAGetNumSteps", 1);
ier = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&ier, "IDAGetNumNonlinSolvIters", 1);
ier = IDAGetNumResEvals(mem, &nre);
check_flag(&ier, "IDAGetNumResEvals", 1);
ier = IDAGetLastStep(mem, &hused);
check_flag(&ier, "IDAGetLastStep", 1);
ier = IDASpgmrGetNumJtimesEvals(mem, &nje);
check_flag(&ier, "IDASpgmrGetNumJtimesEvals", 1);
ier = IDASpgmrGetNumLinIters(mem, &nli);
check_flag(&ier, "IDASpgmrGetNumLinIters", 1);
ier = IDASpgmrGetNumResEvals(mem, &nreS);
check_flag(&ier, "IDASpgmrGetNumResEvals", 1);
ier = IDASpgmrGetNumPrecEvals(mem, &npe);
check_flag(&ier, "IDASpgmrGetPrecEvals", 1);
ier = IDASpgmrGetNumPrecSolves(mem, &nps);
check_flag(&ier, "IDASpgmrGetNumPrecSolves", 1);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" %5.2Lf %13.5Le %d %3ld %3ld %3ld %4ld %4ld %9.2Le %3ld %3ld\n",
t, umax, kused, nst, nni, nje, nre, nreS, hused, npe, nps);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf(" %5.2f %13.5le %d %3ld %3ld %3ld %4ld %4ld %9.2le %3ld %3ld\n",
t, umax, kused, nst, nni, nje, nre, nreS, hused, npe, nps);
#else
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %4ld %9.2e %3ld %3ld\n",
t, umax, kused, nst, nni, nje, nre, nreS, hused, npe, nps);
#endif
}
