static void PrintFinalStats(void *cvode_mem) { long int nst, nfe, nsetups, nje, nfeLS, nni, ncfn, netf, nge; 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); flag = CVDlsGetNumJacEvals(cvode_mem, &nje); check_flag(&flag, "CVDlsGetNumJacEvals", 1); flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS); check_flag(&flag, "CVDlsGetNumRhsEvals", 1); flag = CVodeGetNumGEvals(cvode_mem, &nge); check_flag(&flag, "CVodeGetNumGEvals", 1); printf("\nFinal Statistics:\n"); printf("nst = %-6ld nfe = %-6ld nsetups = %-6ld nfeLS = %-6ld nje = %ld\n", nst, nfe, nsetups, nfeLS, nje); printf("nni = %-6ld ncfn = %-6ld netf = %-6ld nge = %ld\n \n", nni, ncfn, netf, nge); }
/*======================================================================= Print the final statistics returned from the most recent call to CVODE -----------------------------------------------------------------------*/ static void PrintFinalStatistics(void *cvode_mem) { long int nst, nfe, nsetups, nje, nfeLS, nni, ncfn, netf; 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); flag = CVDlsGetNumJacEvals(cvode_mem, &nje); check_flag(&flag, "CVDlsGetNumJacEvals", 1); flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS); check_flag(&flag, "CVDlsGetNumRhsEvals", 1); #pragma omp critical (statistics) #ifdef OPENMP printf("\nFinal Statistics (thread %d):\n", omp_get_thread_num()); #endif printf("nst = %-6ld nfe = %-6ld nsetups = %-6ld nfeLS = %-6ld\n", nst, nfe, nsetups, nfeLS); printf("nje = %-6ld nni = %-6ld ncfn = %-6ld netf = %-6ld\n", nje, nni, ncfn, netf); }
void ode_solver_print_stats(const ode_solver* solver, FILE* outF){ long int nst; long int nfe, nsetups, nni, ncfn, netf; long int nfSe, nfeS, nsetupsS, nniS, ncfnS, netfS; long int nje, nfeLS; int flag; void* cvode_mem = solver->cvode_mem; 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); if (solver->yS != 0) { flag = CVodeGetSensNumRhsEvals(cvode_mem, &nfSe); flag = CVodeGetNumRhsEvalsSens(cvode_mem, &nfeS); flag = CVodeGetSensNumLinSolvSetups(cvode_mem, &nsetupsS); flag = CVodeGetSensNumErrTestFails(cvode_mem, &netfS); flag = CVodeGetSensNumNonlinSolvIters(cvode_mem, &nniS); flag = CVodeGetSensNumNonlinSolvConvFails(cvode_mem, &ncfnS); } flag = CVDlsGetNumJacEvals(cvode_mem, &nje); flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS); fprintf(outF,"\n# Solver Statistics\n\n"); fprintf(outF,"# Steps = %5ld\n\n", nst); fprintf(outF,"# RhsEvals = %5ld\n", nfe); fprintf(outF,"# ErrTestFails = %5ld LinSolvSetups = %5ld\n", netf, nsetups); fprintf(outF,"# NonlinSolvIters = %5ld NonlinSolvConvFails = %5ld\n", nni, ncfn); if(solver->yS != 0) { fprintf(outF,"\n# Sensitivities Statistics\n"); fprintf(outF,"# SensRhsEvals = %5ld RhsEvals = %5ld\n", nfSe, nfeS); fprintf(outF,"# ErrTestFails = %5ld LinSolvSetups = %5ld\n", netfS, nsetupsS); fprintf(outF,"# NonlinSolvIters = %5ld NonlinSolvConvFails = %5ld\n", nniS, ncfnS); } fprintf(outF,"\n# Jacobian Statistics\n"); fprintf(outF,"# JacEvals = %5ld RhsEvals = %5ld\n", nje, nfeLS); }
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 nje, nfeLS; int retval; retval = CVodeGetNumSteps(cvode_mem, &nst); check_retval(&retval, "CVodeGetNumSteps", 1); retval = CVodeGetNumRhsEvals(cvode_mem, &nfe); check_retval(&retval, "CVodeGetNumRhsEvals", 1); retval = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups); check_retval(&retval, "CVodeGetNumLinSolvSetups", 1); retval = CVodeGetNumErrTestFails(cvode_mem, &netf); check_retval(&retval, "CVodeGetNumErrTestFails", 1); retval = CVodeGetNumNonlinSolvIters(cvode_mem, &nni); check_retval(&retval, "CVodeGetNumNonlinSolvIters", 1); retval = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn); check_retval(&retval, "CVodeGetNumNonlinSolvConvFails", 1); if (sensi) { retval = CVodeGetSensNumRhsEvals(cvode_mem, &nfSe); check_retval(&retval, "CVodeGetSensNumRhsEvals", 1); retval = CVodeGetNumRhsEvalsSens(cvode_mem, &nfeS); check_retval(&retval, "CVodeGetNumRhsEvalsSens", 1); retval = CVodeGetSensNumLinSolvSetups(cvode_mem, &nsetupsS); check_retval(&retval, "CVodeGetSensNumLinSolvSetups", 1); retval = CVodeGetSensNumErrTestFails(cvode_mem, &netfS); check_retval(&retval, "CVodeGetSensNumErrTestFails", 1); retval = CVodeGetSensNumNonlinSolvIters(cvode_mem, &nniS); check_retval(&retval, "CVodeGetSensNumNonlinSolvIters", 1); retval = CVodeGetSensNumNonlinSolvConvFails(cvode_mem, &ncfnS); check_retval(&retval, "CVodeGetSensNumNonlinSolvConvFails", 1); } retval = CVDlsGetNumJacEvals(cvode_mem, &nje); check_retval(&retval, "CVDlsGetNumJacEvals", 1); retval = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS); check_retval(&retval, "CVDlsGetNumRhsEvals", 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("nje = %5ld nfeLS = %5ld\n", nje, nfeLS); }
void OpenSMOKE_CVODE_Sundials<T>::Status() const { int flag; long int nst, nfe, nsetups, netf, nni, ncfn, nje, nfeLS, nge; int qcurrent, qlast; double hcurrent, hlast; flag = CVodeGetNumSteps(cvode_mem_, &nst); check_flag(&flag, std::string("CVodeGetNumSteps"), 1); flag = CVDlsGetNumJacEvals(cvode_mem_, &nje); check_flag(&flag, std::string("CVDlsGetNumJacEvals"), 1); flag = CVodeGetNumRhsEvals(cvode_mem_, &nfe); check_flag(&flag, std::string("CVodeGetNumRhsEvals"), 1); flag = CVodeGetNumLinSolvSetups(cvode_mem_, &nsetups); check_flag(&flag, std::string("CVodeGetNumLinSolvSetups"), 1); flag = CVodeGetNumErrTestFails(cvode_mem_, &netf); check_flag(&flag, std::string("CVodeGetNumErrTestFails"), 1); flag = CVodeGetNumNonlinSolvIters(cvode_mem_, &nni); check_flag(&flag, std::string("CVodeGetNumNonlinSolvIters"), 1); flag = CVodeGetNumNonlinSolvConvFails(cvode_mem_, &ncfn); check_flag(&flag, std::string("CVodeGetNumNonlinSolvConvFails"), 1); flag = CVodeGetNumGEvals(cvode_mem_, &nge); check_flag(&flag, std::string("CVodeGetNumGEvals"), 1); flag = CVDlsGetNumRhsEvals(cvode_mem_, &nfeLS); check_flag(&flag, std::string("CVDlsGetNumRhsEvals"), 1); flag = CVodeGetLastOrder(cvode_mem_, &qlast); check_flag(&flag, std::string("CVodeGetLastOrder"), 1); flag = CVodeGetCurrentOrder(cvode_mem_, &qcurrent); check_flag(&flag, std::string("CVodeGetCurrentOrder"), 1); flag = CVodeGetLastStep(cvode_mem_, &hlast); check_flag(&flag, std::string("CVodeGetLastStep"), 1); flag = CVodeGetCurrentStep(cvode_mem_, &hcurrent); check_flag(&flag, std::string("CVodeGetCurrentStep"), 1); std::cout << "CVODE Sundials Status" << std::endl; std::cout << " * Absolute tolerance: " << this->absTolerance_[0] << std::endl; // Absolute tolerance std::cout << " * Relative tolerance: " << this->relTolerance_[0] << std::endl; // Relative tolerance std::cout << " * Number of steps: " << nst << std::endl; // Number of steps taken for the problem so far std::cout << " * Number of function evaluations: " << nfe << std::endl; // Number of f evaluations for the problem so far. std::cout << " * Number of Jacobians: " << nje << std::endl; // Number of Jacobian evaluations (and of matrix LU decompositions) for the problem so far. std::cout << " * Last step: " << hlast << std::endl; std::cout << " * Next step: " << hcurrent << std::endl; std::cout << " * Last order: " << qlast << std::endl; std::cout << " * Next order: " << qcurrent << std::endl; }