static void PrintFinalStats(void *mem)
{
int retval;
long int nst, nni, nje, nre, netf, ncfn, nge;
retval = IDAGetNumSteps(mem, &nst);
check_retval(&retval, "IDAGetNumSteps", 1);
retval = IDAGetNumResEvals(mem, &nre);
check_retval(&retval, "IDAGetNumResEvals", 1);
retval = IDAGetNumJacEvals(mem, &nje);
check_retval(&retval, "IDAGetNumJacEvals", 1);
retval = IDAGetNumNonlinSolvIters(mem, &nni);
check_retval(&retval, "IDAGetNumNonlinSolvIters", 1);
retval = IDAGetNumErrTestFails(mem, &netf);
check_retval(&retval, "IDAGetNumErrTestFails", 1);
retval = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_retval(&retval, "IDAGetNumNonlinSolvConvFails", 1);
retval = IDAGetNumGEvals(mem, &nge);
check_retval(&retval, "IDAGetNumGEvals", 1);
printf("\nFinal Run Statistics: \n\n");
printf("Number of steps = %ld\n", nst);
printf("Number of residual evaluations = %ld\n", nre);
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_err_test_fails(value ida_solver, value netfails) {
CAMLparam2(ida_solver, netfails);
long int _netfails;
const int ret = IDAGetNumErrTestFails(IDA_MEM(ida_solver), &_netfails);
Store_field(netfails, 0, Val_int(_netfails));
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 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 netf, ncfn, ncfl;
IDAGetNumErrTestFails(mem, &netf);
IDAGetNumNonlinSolvConvFails(mem, &ncfn);
IDASpilsGetNumConvFails(mem, &ncfl);
printf("\nError test failures = %ld\n", netf);
printf("Nonlinear convergence failures = %ld\n", ncfn);
printf("Linear convergence failures = %ld\n", ncfl);
}
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);
}
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);
}
int main()
{
void *mem;
UserData data;
N_Vector uu, up, constraints, res;
int ier, iout;
realtype rtol, atol, t0, t1, tout, tret;
long int netf, ncfn, ncfl;
mem = NULL;
data = NULL;
uu = up = constraints = res = NULL;
/* Allocate N-vectors and the user data structure. */
uu = N_VNew_Serial(NEQ);
if(check_flag((void *)uu, "N_VNew_Serial", 0)) return(1);
up = N_VNew_Serial(NEQ);
if(check_flag((void *)up, "N_VNew_Serial", 0)) return(1);
res = N_VNew_Serial(NEQ);
if(check_flag((void *)res, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if(check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
data = (UserData) malloc(sizeof *data);
data->pp = NULL;
if(check_flag((void *)data, "malloc", 2)) return(1);
/* Assign parameters in the user data structure. */
data->mm = MGRID;
data->dx = ONE/(MGRID-ONE);
data->coeff = ONE/(data->dx * data->dx);
data->pp = N_VNew_Serial(NEQ);
if(check_flag((void *)data->pp, "N_VNew_Serial", 0)) return(1);
/* Initialize uu, up. */
SetInitialProfile(data, uu, up, res);
/* Set constraints to all 1's for nonnegative solution values. */
N_VConst(ONE, constraints);
/* Assign various parameters. */
t0 = ZERO;
t1 = RCONST(0.01);
rtol = ZERO;
atol = RCONST(1.0e-3);
/* Call IDACreate and IDAMalloc to initialize solution */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
ier = IDASetUserData(mem, data);
if(check_flag(&ier, "IDASetUserData", 1)) return(1);
ier = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1)) return(1);
N_VDestroy_Serial(constraints);
ier = IDAInit(mem, resHeat, t0, uu, up);
if(check_flag(&ier, "IDAInit", 1)) return(1);
ier = IDASStolerances(mem, rtol, atol);
if(check_flag(&ier, "IDASStolerances", 1)) return(1);
/* Call IDASpgmr to specify the linear solver. */
ier = IDASpgmr(mem, 0);
if(check_flag(&ier, "IDASpgmr", 1)) return(1);
ier = IDASpilsSetPreconditioner(mem, PsetupHeat, PsolveHeat);
if(check_flag(&ier, "IDASpilsSetPreconditioner", 1)) return(1);
/* Print output heading. */
PrintHeader(rtol, atol);
/*
* -------------------------------------------------------------------------
* CASE I
* -------------------------------------------------------------------------
*/
/* Print case number, output table heading, and initial line of table. */
printf("\n\nCase 1: gsytpe = MODIFIED_GS\n");
printf("\n Output Summary (umax = max-norm of solution) \n\n");
printf(" time umax k nst nni nje nre nreLS h npe nps\n" );
printf("----------------------------------------------------------------------\n");
/* Loop over output times, call IDASolve, and print results. */
for (tout = t1,iout = 1; iout <= NOUT ; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1)) return(1);
PrintOutput(mem, tret, uu);
}
/* Print remaining counters. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
ier = IDASpilsGetNumConvFails(mem, &ncfl);
check_flag(&ier, "IDASpilsGetNumConvFails", 1);
printf("\nError test failures = %ld\n", netf);
printf("Nonlinear convergence failures = %ld\n", ncfn);
printf("Linear convergence failures = %ld\n", ncfl);
/*
* -------------------------------------------------------------------------
* CASE II
* -------------------------------------------------------------------------
*/
/* Re-initialize uu, up. */
SetInitialProfile(data, uu, up, res);
/* Re-initialize IDA and IDASPGMR */
ier = IDAReInit(mem, t0, uu, up);
if(check_flag(&ier, "IDAReInit", 1)) return(1);
ier = IDASpilsSetGSType(mem, CLASSICAL_GS);
if(check_flag(&ier, "IDASpilsSetGSType",1)) return(1);
/* Print case number, output table heading, and initial line of table. */
printf("\n\nCase 2: gstype = CLASSICAL_GS\n");
printf("\n Output Summary (umax = max-norm of solution) \n\n");
printf(" time umax k nst nni nje nre nreLS h npe nps\n" );
printf("----------------------------------------------------------------------\n");
/* Loop over output times, call IDASolve, and print results. */
for (tout = t1,iout = 1; iout <= NOUT ; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1)) return(1);
PrintOutput(mem, tret, uu);
}
/* Print remaining counters. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
ier = IDASpilsGetNumConvFails(mem, &ncfl);
check_flag(&ier, "IDASpilsGetNumConvFails", 1);
printf("\nError test failures = %ld\n", netf);
printf("Nonlinear convergence failures = %ld\n", ncfn);
printf("Linear convergence failures = %ld\n", ncfl);
/* Free Memory */
IDAFree(&mem);
N_VDestroy_Serial(uu);
N_VDestroy_Serial(up);
N_VDestroy_Serial(res);
N_VDestroy_Serial(data->pp);
free(data);
return(0);
}
int main(void)
{
void *mem;
UserData data;
N_Vector uu, up, constraints, id, res;
int ier, iout;
long int mu, ml, netf, ncfn;
realtype rtol, atol, t0, t1, tout, tret;
mem = NULL;
data = NULL;
uu = up = constraints = id = res = NULL;
/* Create vectors uu, up, res, constraints, id. */
uu = N_VNew_Serial(NEQ);
if(check_flag((void *)uu, "N_VNew_Serial", 0)) return(1);
up = N_VNew_Serial(NEQ);
if(check_flag((void *)up, "N_VNew_Serial", 0)) return(1);
res = N_VNew_Serial(NEQ);
if(check_flag((void *)res, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if(check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ);
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
/* Create and load problem data block. */
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2)) return(1);
data->mm = MGRID;
data->dx = ONE/(MGRID - ONE);
data->coeff = ONE/( (data->dx) * (data->dx) );
/* Initialize uu, up, id. */
SetInitialProfile(data, uu, up, id, res);
/* Set constraints to all 1's for nonnegative solution values. */
N_VConst(ONE, constraints);
/* Set remaining input parameters. */
t0 = ZERO;
t1 = RCONST(0.01);
rtol = ZERO;
atol = RCONST(1.0e-3);
/* Call IDACreate and IDAMalloc to initialize solution */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
ier = IDASetUserData(mem, data);
if(check_flag(&ier, "IDASetUserData", 1)) return(1);
ier = IDASetId(mem, id);
if(check_flag(&ier, "IDASetId", 1)) return(1);
ier = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1)) return(1);
N_VDestroy_Serial(constraints);
ier = IDAInit(mem, heatres, t0, uu, up);
if(check_flag(&ier, "IDAInit", 1)) return(1);
ier = IDASStolerances(mem, rtol, atol);
if(check_flag(&ier, "IDASStolerances", 1)) return(1);
/* Call IDABand to specify the linear solver. */
mu = MGRID; ml = MGRID;
ier = IDABand(mem, NEQ, mu, ml);
if(check_flag(&ier, "IDABand", 1)) return(1);
/* Call IDACalcIC to correct the initial values. */
ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1);
if(check_flag(&ier, "IDACalcIC", 1)) return(1);
/* Print output heading. */
PrintHeader(rtol, atol);
PrintOutput(mem, t0, uu);
/* Loop over output times, call IDASolve, and print results. */
for (tout = t1, iout = 1; iout <= NOUT; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1)) return(1);
PrintOutput(mem, tret, uu);
}
/* Print remaining counters and free memory. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn);
IDAFree(&mem);
N_VDestroy_Serial(uu);
N_VDestroy_Serial(up);
N_VDestroy_Serial(id);
N_VDestroy_Serial(res);
free(data);
return(0);
}
int main(void)
{
void *mem;
UserData data;
N_Vector uu, up, constraints, id, res; /* uu is u, up is du/dt */
int ier, iout;
long int netf, ncfn;
realtype rtol, atol, t0, t1, tout, tret;
int nnz; /* number of non-zeroes */
mem = NULL;
data = NULL;
uu = up = constraints = id = res = NULL;
/* Create vectors uu, up, res, constraints, id. */
uu = N_VNew_Serial(NEQ);
if(check_flag((void *)uu, "N_VNew_Serial", 0)) return(1);
up = N_VNew_Serial(NEQ);
if(check_flag((void *)up, "N_VNew_Serial", 0)) return(1);
res = N_VNew_Serial(NEQ);
if(check_flag((void *)res, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if(check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ); /* differentiate between algebraic and differential */
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
/* Create and load problem data block. */
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2)) return(1);
data->mm = MGRID;
data->dx = ONE/(MGRID - ONE);
data->coeff = ONE/( (data->dx) * (data->dx) );
/* Initialize uu, up, id. */
SetInitialProfile(data, uu, up, id, res);
/* Set constraints to all 1's for nonnegative solution values. */
N_VConst(ONE, constraints);
/* Set remaining input parameters. */
t0 = ZERO;
t1 = RCONST(0.01);
rtol = ZERO;
atol = RCONST(1.0e-8);
/* Call IDACreate and IDAMalloc to initialize solution */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
ier = IDASetUserData(mem, data);
if(check_flag(&ier, "IDASetUserData", 1)) return(1);
/* Sets up which components are algebraic or differential */
ier = IDASetId(mem, id);
if(check_flag(&ier, "IDASetId", 1)) return(1);
ier = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1)) return(1);
N_VDestroy_Serial(constraints);
ier = IDAInit(mem, heatres, t0, uu, up);
if(check_flag(&ier, "IDAInit", 1)) return(1);
ier = IDASStolerances(mem, rtol, atol);
if(check_flag(&ier, "IDASStolerances", 1)) return(1);
/* Call IDAKLU and set up the linear solver */
nnz = NEQ*NEQ;
ier = IDAKLU(mem, NEQ, nnz, CSC_MAT);
if(check_flag(&ier, "IDAKLU", 1)) return(1);
/* check size of Jacobian matrix */
if(MGRID >= 4){
ier = IDASlsSetSparseJacFn(mem, jacHeat);
}
/* special case MGRID=3 */
else if(MGRID==3){
ier = IDASlsSetSparseJacFn(mem, jacHeat3);
}
/* MGRID<=2 is pure boundary points, nothing to solve */
else{
printf("MGRID size is too small to run.\n");
return(1);
}
if(check_flag(&ier, "IDASlsSetSparseJacFn", 1)) return(1);
/* Call IDACalcIC to correct the initial values. */
ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1);
if(check_flag(&ier, "IDACalcIC", 1)) return(1);
/* Print output heading. */
PrintHeader(rtol, atol);
PrintOutput(mem, t0, uu);
/* Loop over output times, call IDASolve, and print results. */
for (tout = t1, iout = 1; iout <= NOUT; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1)) return(1);
PrintOutput(mem, tret, uu);
}
/* Print remaining counters and free memory. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn);
IDAFree(&mem);
N_VDestroy_Serial(uu);
N_VDestroy_Serial(up);
N_VDestroy_Serial(id);
N_VDestroy_Serial(res);
free(data);
return(0);
}
