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); }