remove KINGetReturnFlagName as it contains mem leak

Author: Yi Zhang

stan/math/prim/err/check_flag_sundials.hpp

@@ -4,7 +4,7 @@
 #include <kinsol/kinsol.h>
 #include <cvodes/cvodes.h>
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err/throw_domain_error.hpp>
+#include <stan/math/prim/err/domain_error.hpp>
 
 namespace stan {
 namespace math {
@@ -34,26 +34,50 @@ inline void cvodes_check(int flag, const char* func_name) {
 }
 
 /**
- * Throws an exception message when the function KINSol()
- * (call to the solver) fails. When the exception is caused
+ * Throws an exception message when the functions in KINSOL
+ * fails. When the exception is caused
+ * by a tuning parameter the user controls, gives a specific
+ * error. "KINGetReturnFlagName()" from sundials has a mem leak bug so
+ * until it's fixed we cannot use it to extract flag error string.
+ *
+ * @param flag Error flag
+ * @param func_name calling function name
+ * @throw <code>std::runtime_error</code> if the flag is negative.
+ */
+  inline void kinsol_check(int flag, const char* func_name) {
+    std::ostringstream ss;
+    if (flag < 0) {
+      ss << "algebra_solver failed with error flag " << flag << ".";
+      throw std::runtime_error(ss.str());
+    }
+  }
+
+/**
+ * Throws an exception message when the KINSol() call fails.
+ * When the exception is caused
  * by a tuning parameter the user controls, gives a specific
  * error.
  *
  * @param flag Error flag
+ * @param func_name calling function name
+ * @param max_num_steps max number of nonlinear iters
  * @throw <code>std::runtime_error</code> if the flag is negative.
+ * @throw <code>std::domain_error</code> if the flag indicates max
+ * number of steps is exceeded..
  */
-inline void kinsol_check(int flag, const char* func_name) {
-  std::ostringstream ss;
-  if (flag < 0) {
-    ss << func_name << " failed with error flag " << flag << ": "
-       << KINGetReturnFlagName(flag) << ".";
+  inline void kinsol_check(int flag, const char* func_name, long int max_num_steps) {  // NOLINT(runtime/int)
+    std::ostringstream ss;
     if (flag == -6) {
-      throw std::domain_error(ss.str());
-    } else {
+      domain_error("algebra_solver", "maximum number of iterations",
+                   max_num_steps, "(", ") was exceeded in the solve.");
+    } else if (flag == -11) {
+      ss << "The linear solver’s setup function failed in an unrecoverable manner.";
+      throw std::runtime_error(ss.str());
+    } else if (flag < 0) {
+      ss << "algebra_solver failed with error flag " << flag << ".";
       throw std::runtime_error(ss.str());
     }
   }
-}
 
 }  // namespace math
 }  // namespace stan

stan/math/rev/functor/algebra_solver_fp.hpp

@@ -244,8 +244,9 @@ struct FixedPointSolver<KinsolFixedPointEnv<F>, fp_jac_type> {
     CHECK_KINSOL_CALL(KINInit(mem, &env.kinsol_f_system, env.nv_x_));
     CHECK_KINSOL_CALL(KINSetFuncNormTol(mem, f_tol));
     CHECK_KINSOL_CALL(KINSetUserData(mem, static_cast<void*>(&env)));
-    CHECK_KINSOL_CALL(
-        KINSol(mem, env.nv_x_, KIN_FP, env.nv_u_scal_, env.nv_f_scal_));
+    kinsol_check(KINSol(mem, env.nv_x_, KIN_FP, env.nv_u_scal_, env.nv_f_scal_),
+                 "KINSol", max_num_steps);
+
 
     for (int i = 0; i < N; ++i) {
       x(i) = NV_Ith_S(env.nv_x_, i);

stan/math/rev/functor/kinsol_solve.hpp

@@ -109,8 +109,9 @@ Eigen::VectorXd kinsol_solve(const F1& f, const Eigen::VectorXd& x,
     for (int i = 0; i < N; i++)
       NV_Ith_S(nv_x, i) = x(i);
 
-    CHECK_KINSOL_CALL(KINSol(kinsol_data.kinsol_memory_, nv_x,
-                             global_line_search, scaling, scaling));
+    kinsol_check(KINSol(kinsol_data.kinsol_memory_, nv_x,
+                        global_line_search, scaling, scaling),
+                 "KINSol", max_num_steps);
 
     for (int i = 0; i < N; i++)
       x_solution(i) = NV_Ith_S(nv_x, i);

test/unit/math/rev/functor/algebra_solver_fp_test.cpp

@@ -521,7 +521,7 @@ TEST_F(FP_2d_func_test, exception_handling) {
 
   {
     std::stringstream err_msg;
-    err_msg << "KIN_MAXITER_REACHED";
+    err_msg << "maximum number of iterations";
     std::string msg = err_msg.str();
     EXPECT_THROW_MSG(algebra_solver_fp(f, x, y, x_r, x_i, u_scale, f_scale, 0,
                                        f_tol, max_num_steps),  // NOLINT

test/unit/math/rev/functor/algebra_solver_newton_test.cpp

@@ -99,7 +99,7 @@ TEST_F(degenerate_eq_test, newton_guess_saddle_point_dbl) {
   // a saddle point.
   using stan::math::algebra_solver_newton;
   std::stringstream err_msg;
-  err_msg << "KIN_LSETUP_FAIL";
+  err_msg << "The linear solver’s setup function failed in an unrecoverable manner";
   std::string msg = err_msg.str();
 
   EXPECT_THROW_MSG(algebra_solver_newton(degenerate_eq_functor(), x_guess_3,

test/unit/math/rev/functor/util_algebra_solver.hpp

@@ -426,7 +426,7 @@ void inline unsolvable_flag_test(Eigen::Matrix<T, Eigen::Dynamic, 1>& y,
   std::vector<double> dat;
   std::vector<int> dat_int;
   std::stringstream err_msg;
-  err_msg << "KIN_LSETUP_FAIL";
+  err_msg << "The linear solver’s setup function failed in an unrecoverable manner.";
   std::string msg = err_msg.str();
   EXPECT_THROW_MSG(general_algebra_solver(is_newton, unsolvable_eq_functor(), x,
                                           y, dat, dat_int),