Need to debug so cvsRoberts_dns example gives the correct answer.
authorilb@NIH.GOV <ilb@NIH.GOV@ba61647d-9d00-f842-95cd-605cb4296b96>
Tue, 6 Mar 2018 22:49:43 +0000 (22:49 +0000)
committerilb@NIH.GOV <ilb@NIH.GOV@ba61647d-9d00-f842-95cd-605cb4296b96>
Tue, 6 Mar 2018 22:49:43 +0000 (22:49 +0000)
git-svn-id: https://citdcbmipav.cit.nih.gov/repos-pub/mipav/trunk@15401 ba61647d-9d00-f842-95cd-605cb4296b96

mipav/src/gov/nih/mipav/model/algorithms/CVODES.java

index 0061a79..9585e85 100644 (file)
@@ -652,6 +652,7 @@ public abstract class CVODES {
                int iout;\r
                double t[] = new double[1];\r
                int rootsfound[] = new int[2];\r
+               int i;\r
                \r
                // Call CVodeCreate to create the solver memory and specify the\r
                // Backward Differentiation Formula and the use of a Newton\r
@@ -660,6 +661,16 @@ public abstract class CVODES {
                if (cvode_mem == null) {\r
                    return;     \r
                }\r
+               // Allow unlimited steps in reaching tout\r
+               flag = CVodeSetMaxNumSteps(cvode_mem, -1);\r
+               if (flag != CV_SUCCESS) {\r
+                       return;\r
+               }\r
+               // Allow many error test failures\r
+               flag = CVodeSetMaxErrTestFails(cvode_mem, Integer.MAX_VALUE);\r
+               if (flag != CV_SUCCESS) {\r
+                       return;\r
+               }\r
                \r
                // Call CVodeInit to initialize the integrator memory and specify the\r
                // user's right hand side function in y' = f(t,y), the initial time T0, and\r
@@ -719,7 +730,7 @@ public abstract class CVODES {
                \r
                while (true) {\r
                        flag = CVode(cvode_mem, tout, y, t, CV_NORMAL);\r
-                       System.out.println("At t = " + t + " y[0] = " + y.data[0] + " y[1] = " + y.data[1] + " y[2] = " + y.data[2]);\r
+                       System.out.println("At t = " + t[0] + " y[0] = " + y.data[0] + " y[1] = " + y.data[1] + " y[2] = " + y.data[2]);\r
                        \r
                        if (flag == CV_ROOT_RETURN) {\r
                            flagr = CVodeGetRootInfo(cvode_mem, rootsfound)     ;\r
@@ -746,13 +757,88 @@ public abstract class CVODES {
                \r
                // Print some final statistics\r
                PrintFinalStats(cvode_mem);\r
+               \r
+               // Check the solution error\r
+               flag = check_ans(y, reltol, abstol);\r
+               \r
+               // Free y and abstol vectors\r
+               N_VDestroy(y);\r
+               N_VDestroy(abstol);\r
+               \r
+               // Free the integrator memory\r
+               CVodeFree(cvode_mem);\r
+               \r
+               // Free the linear solver memory\r
+               SUNLinSolFree_Dense(LS);\r
+               \r
+               // Free the matrix memory\r
+               for (i = 0; i < NEQ; i++) {\r
+                       A[i] = null;\r
+               }\r
+               A = null;\r
+               return;\r
        }\r
        \r
+       \r
+\r
        private void PrintFinalStats(CVodeMemRec cv_mem) {\r
            System.out.println("Number of integrations steps = " + cv_mem.cv_nst);\r
            System.out.println("Number of calls to f = " + cv_mem.cv_nfe);\r
            System.out.println("Number of calls to the linear solver setup routine = " + cv_mem.cv_nsetups);\r
+           System.out.println("Number of error test failures = " + cv_mem.cv_netf[0]);\r
+           System.out.println("Number of nonlinear solver iterations = " + cv_mem.cv_nni);\r
+           System.out.println("Number of nonlinear solver convergence failures = " + cv_mem.cv_ncfn[0]);\r
+           System.out.println("Number of Jacobian evaluations = " + cv_mem.cv_lmem.nje);\r
+           System.out.println("Number of calls to the ODE function needed for the DQ Jacobian approximation = " + cv_mem.cv_lmem.nfeDQ);\r
+           System.out.println("Number of calls to g (for rootfinding) = " + cv_mem.cv_nge);\r
+       }\r
+       \r
+       /* compare the solution at the final time 4e10s to a reference solution computed\r
+          using a relative tolerance of 1e-8 and absoltue tolerance of 1e-14 */\r
+       private int check_ans(NVector y, double rtol, NVector atol)\r
+       {\r
+         int      passfail=0;        /* answer pass (0) or fail (1) flag */  \r
+         NVector ref;               /* reference solution vector        */\r
+         NVector ewt;               /* error weight vector              */\r
+         double err;               /* wrms error                       */\r
+         double ONE = 1.0;  \r
+\r
+         /* create reference solution and error weight vectors */\r
+         ref = N_VClone(y);\r
+         ewt = N_VClone(y);\r
+\r
+         /* set the reference solution data */\r
+         ref.data[0] = 5.2083495894337328e-08;\r
+         ref.data[1] = 2.0833399429795671e-13;\r
+         ref.data[2] = 9.9999994791629776e-01;\r
+\r
+         /* compute the error weight vector, loosen atol */\r
+         N_VAbs_Serial(ref, ewt);\r
+         N_VLinearSum_Serial(rtol, ewt, 10.0, atol, ewt);\r
+         if (N_VMin_Serial(ewt) <= ZERO) {\r
+           System.err.println("check_ans failed - ewt <= 0\n\n");\r
+           return(-1);\r
+         }\r
+         N_VInv_Serial(ewt, ewt);   \r
+\r
+         /* compute the solution error */\r
+         N_VLinearSum_Serial(ONE, y, -ONE, ref, ref);\r
+         err = N_VWrmsNorm_Serial(ref, ewt);\r
+\r
+         /* is the solution within the tolerances? */\r
+         passfail = (err < ONE) ? 0 : 1; \r
+\r
+         if (passfail == 1) {\r
+           System.err.println("WARNING: check_ans error= " + err);\r
+         }\r
+\r
+         /* Free vectors */\r
+         N_VDestroy(ref);\r
+         N_VDestroy(ewt);\r
+\r
+         return(passfail);\r
        }\r
+\r
        \r
        private void N_VNew_Serial(NVector y, int length) {\r
            if ((y != null) && (length > 0)) {\r
@@ -1419,33 +1505,17 @@ public abstract class CVODES {
      void cvProcessError(CVodeMemRec cv_mem, \r
                          int error_code,  String module, String fname, \r
                          String msgfmt, double... numbers)\r
-     {\r
-        MipavUtil.displayError("In module " + module + " in function " + fname + " msgfmt");\r
-       //va_list ap;\r
-       //char msg[256];\r
-\r
-       /* Initialize the argument pointer variable \r
-          (msgfmt is the last required argument to cvProcessError) */\r
-\r
-       //va_start(ap, msgfmt);\r
-\r
-       /* Compose the message */\r
-\r
-       //vsprintf(msg, msgfmt, ap);\r
-\r
-       //if (cv_mem == NULL) {    /* We write to stderr */\r
-     //#ifndef NO_FPRINTF_OUTPUT\r
-         //fprintf(stderr, "\n[%s ERROR]  %s\n  ", module, fname);\r
-         //fprintf(stderr, "%s\n\n", msg);\r
-     //#endif\r
-\r
-       //} else {                 /* We can call ehfun */\r
-         //cv_mem->cv_ehfun(error_code, module, fname, msg, cv_mem->cv_eh_data);\r
-       //}\r
-\r
-       /* Finalize argument processing */\r
-       //va_end(ap);\r
-\r
+     {   \r
+        int index = msgfmt.indexOf("%lg");\r
+        if (index > 0) {\r
+                msgfmt = msgfmt.substring(0, index)+numbers[0]+msgfmt.substring(index+3);\r
+                index = msgfmt.indexOf("%lg");\r
+                if (index > 0) {\r
+                        msgfmt = msgfmt.substring(0, index)+numbers[1]+msgfmt.substring(index+3);       \r
+                }\r
+        }\r
+        System.err.println("In module " + module + " in function " + fname + msgfmt);\r
+       \r
        return;\r
      }\r
      \r
@@ -1743,7 +1813,7 @@ public abstract class CVODES {
          return(CV_ILL_INPUT);\r
        }\r
 \r
-       if (N_VMin(abstol) < ZERO) {\r
+       if (N_VMin_Serial(abstol) < ZERO) {\r
          cvProcessError(cv_mem, CV_ILL_INPUT, "CVODES",\r
                         "CVodeSVtolerances", MSGCV_BAD_ABSTOL);\r
          return(CV_ILL_INPUT);\r
@@ -1771,7 +1841,7 @@ public abstract class CVODES {
        return(CV_SUCCESS);\r
      }\r
 \r
-     private double N_VMin(NVector x) {\r
+     private double N_VMin_Serial(NVector x) {\r
         int i;\r
         if ((x == null) || (x.data == null) || (x.data.length == 0)) {\r
                 return Double.NaN;\r
@@ -2948,7 +3018,7 @@ public abstract class CVODES {
     N_VAbs_Serial(ycur, cv_mem.cv_tempv);\r
     N_VScale_Serial(cv_mem.cv_reltol, cv_mem.cv_tempv, cv_mem.cv_tempv);\r
     N_VAddConst_Serial(cv_mem.cv_tempv, cv_mem.cv_Sabstol, cv_mem.cv_tempv);\r
-    if (N_VMin(cv_mem.cv_tempv) <= ZERO) return(-1);\r
+    if (N_VMin_Serial(cv_mem.cv_tempv) <= ZERO) return(-1);\r
     N_VInv_Serial(cv_mem.cv_tempv, weight);\r
 \r
     return(0);\r
@@ -2968,7 +3038,7 @@ public abstract class CVODES {
     N_VAbs_Serial(ycur, cv_mem.cv_tempv);\r
     N_VLinearSum_Serial(cv_mem.cv_reltol, cv_mem.cv_tempv, ONE,\r
                  cv_mem.cv_Vabstol, cv_mem.cv_tempv);\r
-    if (N_VMin(cv_mem.cv_tempv) <= ZERO) return(-1);\r
+    if (N_VMin_Serial(cv_mem.cv_tempv) <= ZERO) return(-1);\r
     N_VInv_Serial(cv_mem.cv_tempv, weight);\r
     return(0);\r
   }\r
@@ -3441,7 +3511,7 @@ public abstract class CVODES {
     N_VAbs_Serial(qcur, cv_mem.cv_tempvQ);\r
     N_VScale_Serial(cv_mem.cv_reltolQ, cv_mem.cv_tempvQ, cv_mem.cv_tempvQ);\r
     N_VAddConst_Serial(cv_mem.cv_tempvQ, cv_mem.cv_SabstolQ, cv_mem.cv_tempvQ);\r
-    if (N_VMin(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
+    if (N_VMin_Serial(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
     N_VInv_Serial(cv_mem.cv_tempvQ, weightQ);\r
 \r
     return(0);\r
@@ -3457,7 +3527,7 @@ public abstract class CVODES {
     N_VAbs_Serial(qcur, cv_mem.cv_tempvQ);\r
     N_VLinearSum_Serial(cv_mem.cv_reltolQ, cv_mem.cv_tempvQ, ONE,\r
                  cv_mem.cv_VabstolQ, cv_mem.cv_tempvQ);\r
-    if (N_VMin(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
+    if (N_VMin_Serial(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
     N_VInv_Serial(cv_mem.cv_tempvQ, weightQ);\r
 \r
     return(0);\r
@@ -3531,7 +3601,7 @@ public abstract class CVODES {
       N_VAbs_Serial(yScur[is], cv_mem.cv_tempv);\r
       N_VScale_Serial(cv_mem.cv_reltolS, cv_mem.cv_tempv, cv_mem.cv_tempv);\r
       N_VAddConst_Serial(cv_mem.cv_tempv, cv_mem.cv_SabstolS[is], cv_mem.cv_tempv);\r
-      if (N_VMin(cv_mem.cv_tempv) <= ZERO) return(-1);\r
+      if (N_VMin_Serial(cv_mem.cv_tempv) <= ZERO) return(-1);\r
       N_VInv_Serial(cv_mem.cv_tempv, weightS[is]);\r
     }\r
     return(0);\r
@@ -3550,7 +3620,7 @@ public abstract class CVODES {
       N_VAbs_Serial(yScur[is], cv_mem.cv_tempv);\r
       N_VLinearSum_Serial(cv_mem.cv_reltolS, cv_mem.cv_tempv, ONE,\r
                    cv_mem.cv_VabstolS[is], cv_mem.cv_tempv);\r
-      if (N_VMin(cv_mem.cv_tempv) <= ZERO) return(-1);\r
+      if (N_VMin_Serial(cv_mem.cv_tempv) <= ZERO) return(-1);\r
       N_VInv_Serial(cv_mem.cv_tempv, weightS[is]);\r
     }\r
 \r
@@ -3620,7 +3690,7 @@ public abstract class CVODES {
       N_VAbs_Serial(yQScur[is], cv_mem.cv_tempvQ);\r
       N_VScale_Serial(cv_mem.cv_reltolQS, cv_mem.cv_tempvQ, cv_mem.cv_tempvQ);\r
       N_VAddConst_Serial(cv_mem.cv_tempvQ, cv_mem.cv_SabstolQS[is], cv_mem.cv_tempvQ);\r
-      if (N_VMin(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
+      if (N_VMin_Serial(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
       N_VInv_Serial(cv_mem.cv_tempvQ, weightQS[is]);\r
     }\r
 \r
@@ -3635,7 +3705,7 @@ public abstract class CVODES {
       N_VAbs_Serial(yQScur[is], cv_mem.cv_tempvQ);\r
       N_VLinearSum_Serial(cv_mem.cv_reltolQS, cv_mem.cv_tempvQ, ONE,\r
                    cv_mem.cv_VabstolQS[is], cv_mem.cv_tempvQ);\r
-      if (N_VMin(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
+      if (N_VMin_Serial(cv_mem.cv_tempvQ) <= ZERO) return(-1);\r
       N_VInv_Serial(cv_mem.cv_tempvQ, weightQS[is]);\r
     }\r
 \r
@@ -8643,6 +8713,334 @@ else                return(snrm);
           return(CV_SUCCESS);\r
         }\r
 \r
+        /*\r
+         * CVodeFree\r
+         *\r
+         * This routine frees the problem memory allocated by CVodeInit.\r
+         * Such memory includes all the vectors allocated by cvAllocVectors,\r
+         * and the memory lmem for the linear solver (deallocated by a call\r
+         * to lfree), as well as (if Ns!=0) all memory allocated for \r
+         * sensitivity computations by CVodeSensInit.\r
+         */\r
+\r
+        private void CVodeFree(CVodeMemRec cv_mem)\r
+        {\r
+\r
+          if (cv_mem == null) return;\r
+          \r
+          cvFreeVectors(cv_mem);\r
+\r
+          CVodeQuadFree(cv_mem);\r
+\r
+          CVodeSensFree(cv_mem);\r
+\r
+          CVodeQuadSensFree(cv_mem);\r
+\r
+          //CVodeAdjFree(cv_mem);\r
+\r
+          cvDlsFree(cv_mem);\r
+\r
+          if (cv_mem.cv_nrtfn > 0) {\r
+            cv_mem.cv_glo = null; \r
+            cv_mem.cv_ghi = null;\r
+            cv_mem.cv_grout = null;\r
+            cv_mem.cv_iroots = null;\r
+            cv_mem.cv_rootdir = null;\r
+            cv_mem.cv_gactive = null;\r
+          }\r
+          \r
+          cv_mem = null;\r
+        }\r
+\r
+        \r
+        /*  \r
+         * cvFreeVectors\r
+         *\r
+         * This routine frees the CVODES vectors allocated in cvAllocVectors.\r
+         */\r
+\r
+        private void cvFreeVectors(CVodeMemRec cv_mem)\r
+        {\r
+          int j, maxord;\r
+          \r
+          maxord = cv_mem.cv_qmax_alloc;\r
+\r
+          N_VDestroy(cv_mem.cv_ewt);\r
+          N_VDestroy(cv_mem.cv_acor);\r
+          N_VDestroy(cv_mem.cv_tempv);\r
+          N_VDestroy(cv_mem.cv_ftemp);\r
+          for (j=0; j <= maxord; j++) N_VDestroy(cv_mem.cv_zn[j]);\r
+\r
+          cv_mem.cv_lrw -= (maxord + 5)*cv_mem.cv_lrw1;\r
+          cv_mem.cv_liw -= (maxord + 5)*cv_mem.cv_liw1;\r
+\r
+          if (cv_mem.cv_VabstolMallocDone) {\r
+            N_VDestroy(cv_mem.cv_Vabstol);\r
+            cv_mem.cv_lrw -= cv_mem.cv_lrw1;\r
+            cv_mem.cv_liw -= cv_mem.cv_liw1;\r
+          }\r
+        }\r
+\r
+        \r
+        /*\r
+         * CVodeQuadFree\r
+         *\r
+         * CVodeQuadFree frees the problem memory in cvode_mem allocated\r
+         * for quadrature integration. Its only argument is the pointer\r
+         * cvode_mem returned by CVodeCreate. \r
+         */\r
+\r
+        private void CVodeQuadFree(CVodeMemRec cv_mem)\r
+        {\r
+          \r
+          if (cv_mem == null) return;\r
+\r
+          if(cv_mem.cv_QuadMallocDone) {\r
+            cvQuadFreeVectors(cv_mem);\r
+            cv_mem.cv_QuadMallocDone = false;\r
+            cv_mem.cv_quadr = false;\r
+          }\r
+        }\r
+        \r
+        /*\r
+         * cvQuadFreeVectors\r
+         *\r
+         * This routine frees the CVODES vectors allocated in cvQuadAllocVectors.\r
+         */\r
+\r
+        private void cvQuadFreeVectors(CVodeMemRec cv_mem)\r
+        {\r
+          int j, maxord;\r
+          \r
+          maxord = cv_mem.cv_qmax_allocQ;\r
+\r
+          N_VDestroy(cv_mem.cv_ewtQ);\r
+          N_VDestroy(cv_mem.cv_acorQ);\r
+          N_VDestroy(cv_mem.cv_yQ);\r
+          N_VDestroy(cv_mem.cv_tempvQ);\r
+          \r
+          for (j=0; j<=maxord; j++) N_VDestroy(cv_mem.cv_znQ[j]);\r
+\r
+          cv_mem.cv_lrw -= (maxord + 5)*cv_mem.cv_lrw1Q;\r
+          cv_mem.cv_liw -= (maxord + 5)*cv_mem.cv_liw1Q;\r
+\r
+          if (cv_mem.cv_VabstolQMallocDone) {\r
+            N_VDestroy(cv_mem.cv_VabstolQ);\r
+\r
+           cv_mem.cv_lrw -= cv_mem.cv_lrw1Q;\r
+            cv_mem.cv_liw -= cv_mem.cv_liw1Q;\r
+          }\r
+\r
+          cv_mem.cv_VabstolQMallocDone = false;\r
+        }\r
+\r
+\r
+        /*\r
+         *\r
+        CVodeSensFree\r
+         *\r
+         * CVodeSensFree frees the problem memory in cvode_mem allocated\r
+         * for sensitivity analysis. Its only argument is the pointer\r
+         * cvode_mem returned by CVodeCreate. \r
+         */\r
+\r
+        private void CVodeSensFree(CVodeMemRec cv_mem)\r
+        {\r
+          int i;\r
+          if (cv_mem == null) return;\r
+\r
+          if(cv_mem.cv_SensMallocDone) {\r
+            if (cv_mem.cv_stgr1alloc) {\r
+              for (i = 0; i < cv_mem.cv_ncfS1.length; i++) {\r
+                  cv_mem.cv_ncfS1[i] = null;\r
+              }\r
+              cv_mem.cv_ncfS1 = null;\r
+              for (i = 0; i < cv_mem.cv_ncfS1.length; i++) {\r
+                  cv_mem.cv_ncfS1[i] = null;\r
+              }\r
+              cv_mem.cv_ncfnS1 = null;\r
+              cv_mem.cv_nniS1 = null;\r
+              cv_mem.cv_stgr1alloc = false;\r
+            }\r
+            cvSensFreeVectors(cv_mem);\r
+            cv_mem.cv_SensMallocDone = false;\r
+            cv_mem.cv_sensi = false;\r
+          }\r
+        }\r
+        \r
+        /*\r
+         * cvSensFreeVectors\r
+         *\r
+         * This routine frees the CVODES vectors allocated in cvSensAllocVectors.\r
+         */\r
+\r
+        private void cvSensFreeVectors(CVodeMemRec cv_mem) \r
+        {\r
+          int j, maxord;\r
+          \r
+          maxord = cv_mem.cv_qmax_allocS;\r
+\r
+          N_VDestroyVectorArray(cv_mem.cv_yS, cv_mem.cv_Ns);\r
+          N_VDestroyVectorArray(cv_mem.cv_ewtS, cv_mem.cv_Ns);\r
+          N_VDestroyVectorArray(cv_mem.cv_acorS, cv_mem.cv_Ns);\r
+          N_VDestroyVectorArray(cv_mem.cv_tempvS, cv_mem.cv_Ns);\r
+          N_VDestroyVectorArray(cv_mem.cv_ftempS, cv_mem.cv_Ns);\r
+          \r
+          for (j=0; j<=maxord; j++)\r
+            N_VDestroyVectorArray(cv_mem.cv_znS[j], cv_mem.cv_Ns);  \r
+\r
+          cv_mem.cv_pbar = null;\r
+          cv_mem.cv_plist = null;\r
+\r
+          cv_mem.cv_lrw -= (maxord + 6)*cv_mem.cv_Ns*cv_mem.cv_lrw1 + cv_mem.cv_Ns;\r
+          cv_mem.cv_liw -= (maxord + 6)*cv_mem.cv_Ns*cv_mem.cv_liw1 + cv_mem.cv_Ns;\r
+\r
+\r
+         if (cv_mem.cv_VabstolSMallocDone) {\r
+            N_VDestroyVectorArray(cv_mem.cv_VabstolS, cv_mem.cv_Ns);\r
+            cv_mem.cv_lrw -= cv_mem.cv_Ns*cv_mem.cv_lrw1;\r
+            cv_mem.cv_liw -= cv_mem.cv_Ns*cv_mem.cv_liw1;\r
+          }\r
+          if (cv_mem.cv_SabstolSMallocDone) {\r
+            cv_mem.cv_SabstolS = null;\r
+            cv_mem.cv_lrw -= cv_mem.cv_Ns;\r
+          }\r
+          cv_mem.cv_VabstolSMallocDone = false;\r
+          cv_mem.cv_SabstolSMallocDone = false;\r
+        }\r
+        \r
+        /* ----------------------------------------------------------------------------\r
+         * Function to free an array created with N_VCloneVectorArray_Serial\r
+         */\r
+\r
+        private void N_VDestroyVectorArray(NVector vs[], int count)\r
+        {\r
+          int j;\r
+\r
+          for (j = 0; j < count; j++) N_VDestroy(vs[j]);\r
+\r
+          vs = null;\r
+\r
+          return;\r
+        }\r
+\r
+\r
+\r
+        /*\r
+         * CVodeQuadSensFree\r
+         *\r
+         * CVodeQuadSensFree frees the problem memory in cvode_mem allocated\r
+         * for quadrature sensitivity analysis. Its only argument is the pointer\r
+         * cvode_mem returned by CVodeCreate. \r
+         */\r
+\r
+        private void CVodeQuadSensFree(CVodeMemRec cv_mem)\r
+        {\r
+          \r
+          if (cv_mem == null) return;\r
+\r
+          if(cv_mem.cv_QuadSensMallocDone) {\r
+            cvQuadSensFreeVectors(cv_mem);\r
+            cv_mem.cv_QuadSensMallocDone = false;\r
+            cv_mem.cv_quadr_sensi = false;\r
+          }\r
+        }\r
+\r
+          /*\r
+           * cvQuadSensFreeVectors\r
+           *\r
+\r
+          * This routine frees the CVODES vectors allocated in cvQuadSensAllocVectors.\r
+           */\r
+\r
+          private void cvQuadSensFreeVectors(CVodeMemRec cv_mem)\r
+          {\r
+            int j, maxord;\r
+            \r
+            maxord = cv_mem.cv_qmax_allocQS;\r
+\r
+            N_VDestroy(cv_mem.cv_ftempQ);\r
+\r
+            N_VDestroyVectorArray(cv_mem.cv_yQS, cv_mem.cv_Ns);\r
+            N_VDestroyVectorArray(cv_mem.cv_ewtQS, cv_mem.cv_Ns);\r
+            N_VDestroyVectorArray(cv_mem.cv_acorQS, cv_mem.cv_Ns);\r
+            N_VDestroyVectorArray(cv_mem.cv_tempvQS, cv_mem.cv_Ns);\r
+            \r
+            for (j=0; j<=maxord; j++)\r
+              N_VDestroyVectorArray(cv_mem.cv_znQS[j], cv_mem.cv_Ns);  \r
+\r
+            cv_mem.cv_lrw -= (maxord + 5)*cv_mem.cv_Ns*cv_mem.cv_lrw1Q;\r
+            cv_mem.cv_liw -= (maxord + 5)*cv_mem.cv_Ns*cv_mem.cv_liw1Q;\r
+\r
+            if (cv_mem.cv_VabstolQSMallocDone) {\r
+              N_VDestroyVectorArray(cv_mem.cv_VabstolQS, cv_mem.cv_Ns);\r
+              cv_mem.cv_lrw -= cv_mem.cv_Ns*cv_mem.cv_lrw1Q;\r
+              cv_mem.cv_liw -= cv_mem.cv_Ns*cv_mem.cv_liw1Q;\r
+            }\r
+            if (cv_mem.cv_SabstolQSMallocDone) {\r
+              cv_mem.cv_SabstolQS = null;\r
+              cv_mem.cv_lrw -= cv_mem.cv_Ns;\r
+            }\r
+            cv_mem.cv_VabstolQSMallocDone = false;\r
+            cv_mem.cv_SabstolQSMallocDone = false;\r
+\r
+          }\r
+          \r
+          private int SUNLinSolFree_Dense(SUNLinearSolver S)\r
+          {\r
+            /* return if S is already free */\r
+            if (S == null)\r
+              return(SUNLS_SUCCESS);\r
+\r
+            /* delete items from contents, then delete generic structure */\r
+            S.pivots = null;\r
+            S = null;\r
+            return(SUNLS_SUCCESS);\r
+          }\r
+          \r
+          /* \r
+           * CVodeSetMaxNumSteps\r
+           *\r
+           * Specifies the maximum number of integration steps\r
+           */\r
+\r
+          private int CVodeSetMaxNumSteps(CVodeMemRec cv_mem, long mxsteps)\r
+          {\r
+\r
+            if (cv_mem==null) {\r
+              cvProcessError(null, CV_MEM_NULL, "CVODES", "CVodeSetMaxNumSteps", MSGCV_NO_MEM);\r
+              return(CV_MEM_NULL);\r
+            }\r
+\r
+            /* Passing mxsteps=0 sets the default. Passing mxsteps<0 disables the test. */\r
+            if (mxsteps == 0)\r
+              cv_mem.cv_mxstep = MXSTEP_DEFAULT;\r
+            else\r
+              cv_mem.cv_mxstep = mxsteps;\r
+\r
+            return(CV_SUCCESS);\r
+          }\r
+\r
+          /* \r
+           * CVodeSetMaxErrTestFails\r
+           *\r
+           * Specifies the maximum number of error test failures during one\r
+           * step try.\r
+           */\r
+\r
+          private int CVodeSetMaxErrTestFails(CVodeMemRec cv_mem, int maxnef)\r
+          {\r
+\r
+            if (cv_mem==null) {\r
+              cvProcessError(null, CV_MEM_NULL, "CVODES", "CVodeSetMaxErrTestFails", MSGCV_NO_MEM);\r
+              return (CV_MEM_NULL);\r
+            }\r
+\r
+            cv_mem.cv_maxnef = maxnef;\r
+\r
+            return(CV_SUCCESS);\r
+          }\r
+\r
 \r
 \r
 }
\ No newline at end of file