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