[cRuntime] improve dump of the non-linear system solution

Belonging to [master]:
  - #2581
  - OpenModelica/OpenModelica-testsuite#1005

Author: Willi Braun

SimulationRuntime/c/simulation/solver/kinsolSolver.c

@@ -606,7 +606,7 @@ void nlsKinsolJacSumDense(DlsMat mat)
     }
 
     if (sum == 0.0){
-      warningStreamPrint(LOG_NLS, 0, "sum of col %d of jacobian is zero!", i);
+      warningStreamPrint(LOG_NLS_V, 0, "sum of col %d of jacobian is zero!", i);
     }else{
       infoStreamPrint(LOG_NLS_JAC, 0, "col %d jac sum = %g", i, sum);
     }
@@ -627,7 +627,7 @@ void nlsKinsolJacSumSparse(SlsMat mat)
     }
 
     if (sum == 0.0){
-      warningStreamPrint(LOG_NLS, 0, "sum of col %d of jacobian is zero!", i);
+      warningStreamPrint(LOG_NLS_V, 0, "sum of col %d of jacobian is zero!", i);
     }else{
       infoStreamPrint(LOG_NLS_JAC, 0, "col %d jac sum = %g", i, sum);
     }
@@ -644,13 +644,13 @@ void nlsKinsolErrorPrint(int errorCode, const char *module, const char *function
   int sysNumber = kinsolData->userData.sysNumber;
   long eqSystemNumber = data->simulationInfo->nonlinearSystemData[sysNumber].equationIndex;
 
-  if (ACTIVE_STREAM(LOG_NLS))
+  if (ACTIVE_STREAM(LOG_NLS_V))
   {
-    warningStreamPrint(LOG_NLS, 1, "kinsol failed for %d", modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).id);
-    warningStreamPrint(LOG_NLS, 0, "[module] %s | [function] %s | [error_code] %d", module, function, errorCode);
-    warningStreamPrint(LOG_NLS, 0, "%s", msg);
+    warningStreamPrint(LOG_NLS_V, 1, "kinsol failed for %d", modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).id);
+    warningStreamPrint(LOG_NLS_V, 0, "[module] %s | [function] %s | [error_code] %d", module, function, errorCode);
+    warningStreamPrint(LOG_NLS_V, 0, "%s", msg);
 
-    messageClose(LOG_NLS);
+    messageClose(LOG_NLS_V);
   }
 }
 
@@ -839,32 +839,32 @@ int nlsKinsolErrorHandler(int errorCode, DATA *data, NONLINEAR_SYSTEM_DATA *nlsD
   case KIN_MEM_NULL:
   case KIN_ILL_INPUT:
   case KIN_NO_MALLOC:
-    errorStreamPrint(LOG_NLS, 0, "kinsol has a serious memory issue ERROR %d\n", errorCode);
+    errorStreamPrint(LOG_NLS_V, 0, "kinsol has a serious memory issue ERROR %d\n", errorCode);
     return errorCode;
     break;
   /* just retry with new initial guess */
   case KIN_MXNEWT_5X_EXCEEDED:
-    warningStreamPrint(LOG_NLS, 0, "Newton step exceed the maximum step size several times. Try again after increasing maximum step size.\n");
+    warningStreamPrint(LOG_NLS_V, 0, "Newton step exceed the maximum step size several times. Try again after increasing maximum step size.\n");
     kinsolData->maxstepfactor *= 1e5;
     nlsKinsolSetMaxNewtonStep(kinsolData, kinsolData->maxstepfactor);
     return 1;
     break;
   /* just retry without line search */
   case KIN_LINESEARCH_NONCONV:
-    warningStreamPrint(LOG_NLS, 0, "kinsols line search did not convergence. Try without.\n");
+    warningStreamPrint(LOG_NLS_V, 0, "kinsols line search did not convergence. Try without.\n");
     kinsolData->kinsolStrategy = KIN_NONE;
     kinsolData->retries--;
     return 1;
   /* maybe happened because of an out-dated factorization, so just retry  */
   case KIN_LSOLVE_FAIL:
-    warningStreamPrint(LOG_NLS, 0, "kinsols matrix need new factorization. Try again.\n");
+    warningStreamPrint(LOG_NLS_V, 0, "kinsols matrix need new factorization. Try again.\n");
     if (nlsData->isPatternAvailable){
       KINKLUReInit(kinsolData->kinsolMemory, kinsolData->size, kinsolData->nnz, 2);
     }
     return 1;
   case KIN_MAXITER_REACHED:
   case KIN_REPTD_SYSFUNC_ERR:
-    warningStreamPrint(LOG_NLS, 0, "kinsols runs into issues retry with different configuration.\n");
+    warningStreamPrint(LOG_NLS_V, 0, "kinsols runs into issues retry with different configuration.\n");
     retValue = 1;
     break;
   case KIN_LSETUP_FAIL:
@@ -883,7 +883,7 @@ int nlsKinsolErrorHandler(int errorCode, DATA *data, NONLINEAR_SYSTEM_DATA *nlsD
     break;
   case KIN_LINESEARCH_BCFAIL:
     KINGetNumBetaCondFails(kinsolData->kinsolMemory, &outL);
-    warningStreamPrint(LOG_NLS, 0, "kinsols runs into issues with beta-condition fails: %ld\n", outL);
+    warningStreamPrint(LOG_NLS_V, 0, "kinsols runs into issues with beta-condition fails: %ld\n", outL);
     retValue = 1;
     break;
   default:
@@ -896,14 +896,14 @@ int nlsKinsolErrorHandler(int errorCode, DATA *data, NONLINEAR_SYSTEM_DATA *nlsD
   KINGetFuncNorm(kinsolData->kinsolMemory, &fNorm);
   if (fNorm<FTOL_WITH_LESS_ACCURANCY)
   {
-    warningStreamPrint(LOG_NLS, 0, "Move forward with a less accurate solution.");
+    warningStreamPrint(LOG_NLS_V, 0, "Move forward with a less accurate solution.");
     KINSetFuncNormTol(kinsolData->kinsolMemory, FTOL_WITH_LESS_ACCURANCY);
     KINSetScaledStepTol(kinsolData->kinsolMemory, FTOL_WITH_LESS_ACCURANCY);
     retValue2 = 1;
   }
   else
   {
-    warningStreamPrint(LOG_NLS, 0, "Current status of fx = %f", fNorm);
+    warningStreamPrint(LOG_NLS_V, 0, "Current status of fx = %f", fNorm);
   }
 
   /* reconfigure kinsol for an other try */
@@ -976,8 +976,7 @@ int nlsKinsolSolve(DATA *data, threadData_t *threadData, int sysNumber)
   /* reset configuration settings */
   nlsKinsolConfigSetup(kinsolData);
 
-  infoStreamPrint(LOG_NLS, 0, "------------------------------------------------------");
-  infoStreamPrintWithEquationIndexes(LOG_NLS, 1, indexes, "Start solving non-linear system >>%ld<< using Kinsol solver at time %g", eqSystemNumber, data->localData[0]->timeValue);
+  infoStreamPrintWithEquationIndexes(LOG_NLS_V, 1, indexes, "Start Kinsol solver at time %g", data->localData[0]->timeValue);
 
   nlsKinsolResetInitial(data, kinsolData, nlsData, INITIAL_EXTRAPOLATION);
 
@@ -1031,10 +1030,10 @@ int nlsKinsolSolve(DATA *data, threadData_t *threadData, int sysNumber)
     N_VProd(kinsolData->fRes, kinsolData->fScale, kinsolData->fRes);
     fNormValue = N_VWL2Norm(kinsolData->fRes, kinsolData->fRes);
 
-    infoStreamPrint(LOG_NLS, 0, "scaled Euclidean norm of F(u) = %e", fNormValue);
+    infoStreamPrint(LOG_NLS_V, 0, "scaled Euclidean norm of F(u) = %e", fNormValue);
     if (FTOL_WITH_LESS_ACCURANCY<fNormValue)
     {
-      warningStreamPrint(LOG_NLS, 0, "False positive solution. FNorm is not small enough.");
+      warningStreamPrint(LOG_NLS_V, 0, "False positive solution. FNorm is not small enough.");
       success = 0;
     }
     else /* solved system for reuse linear solver information */
@@ -1043,19 +1042,9 @@ int nlsKinsolSolve(DATA *data, threadData_t *threadData, int sysNumber)
     }
     /* copy solution */
     memcpy(nlsData->nlsx, xStart, nlsData->size*(sizeof(double)));
-    /* dump solution */
-    if(ACTIVE_STREAM(LOG_NLS))
-    {
-      infoStreamPrintWithEquationIndexes(LOG_NLS, 1, indexes, "solution for NLS %ld at t=%g", eqSystemNumber, kinsolData->userData.data->localData[0]->timeValue);
-      for(i=0; i<nlsData->size; ++i)
-      {
-        infoStreamPrintWithEquationIndexes(LOG_NLS, 0, indexes, "[%d] %s = %g", i+1, modelInfoGetEquation(&kinsolData->userData.data->modelData->modelDataXml,eqSystemNumber).vars[i], nlsData->nlsx[i]);
-      }
-      messageClose(LOG_NLS);
-    }
   }
 
-  messageClose(LOG_NLS);
+  messageClose(LOG_NLS_V);
 
   return success;
 }

SimulationRuntime/c/simulation/solver/nonlinearSolverHomotopy.c

@@ -1122,9 +1122,9 @@ int solveSystemWithTotalPivotSearch(int n, double* x, double* A, int* indRow, in
     getIndicesOfPivotElement(&n, &nPivot, &i, A, indRow, indCol, &pRow, &pCol, &absMax);
     if (absMax<DBL_EPSILON) {
       *rank = i;
-      warningStreamPrint(LOG_NLS, 0, "Matrix singular!");
-      debugInt(LOG_NLS,"rank = ", *rank);
-      debugInt(LOG_NLS,"position = ", *pos);
+      warningStreamPrint(LOG_NLS_V, 0, "Matrix singular!");
+      debugInt(LOG_NLS_V,"rank = ", *rank);
+      debugInt(LOG_NLS_V,"position = ", *pos);
       break;
     }
     /* swap row indices */
@@ -1155,7 +1155,7 @@ int solveSystemWithTotalPivotSearch(int n, double* x, double* A, int* indRow, in
   debugMatrixPermutedDouble(LOG_NLS_JAC,"Linear System Matrix [Jac res] after decomposition",A, n, m, indRow, indCol);
   debugDouble(LOG_NLS_JAC,"Determinant = ", detJac);
   if (isnan(detJac)){
-    warningStreamPrint(LOG_NLS, 0, "Jacobian determinant is NaN.");
+    warningStreamPrint(LOG_NLS_V, 0, "Jacobian determinant is NaN.");
     return -1;
   }
   else if (fabs(detJac) < 1e-9 && casualTearingSet)
@@ -1169,7 +1169,7 @@ int solveSystemWithTotalPivotSearch(int n, double* x, double* A, int* indRow, in
     if (i>=*rank) {
       /* this criteria should be evaluated and may be improved in future */
       if (fabs(A[indRow[i] + indCol[n]*n])>1e-6) {
-        warningStreamPrint(LOG_NLS, 0, "under-determined linear system not solvable!");
+        warningStreamPrint(LOG_NLS_V, 0, "under-determined linear system not solvable!");
         return -1;
       } else {
         x[indCol[i]] = 0.0;
@@ -1319,7 +1319,7 @@ static int newtonAlgorithm(DATA_HOMOTOPY* solverData, double* x)
   debugString(LOG_NLS_V, "******************************************************");
   debugInt(LOG_NLS_V, "NEWTON SOLVER STARTED! equation number: ",solverData->eqSystemNumber);
   debugInt(LOG_NLS_V, "maximum number of function evaluation: ", solverData->maxNumberOfIterations);
-  printUnknowns(LOG_NLS, solverData);
+  printUnknowns(LOG_NLS_V, solverData);
 
   /* set default solver message */
   solverData->info = 0;
@@ -1393,7 +1393,7 @@ static int newtonAlgorithm(DATA_HOMOTOPY* solverData, double* x)
 
       if (lambda1 < lambdaMin)
       {
-        debugDouble(LOG_NLS,"UPS! MUST HANDLE A PROBLEM (Newton method), time : ", solverData->timeValue);
+        debugDouble(LOG_NLS_V,"UPS! MUST HANDLE A PROBLEM (Newton method), time : ", solverData->timeValue);
         solverData->info = -1;
         break;
       }
@@ -1439,7 +1439,7 @@ static int newtonAlgorithm(DATA_HOMOTOPY* solverData, double* x)
 #endif
         if (assert)
         {
-          debugDouble(LOG_NLS,"UPS! MUST HANDLE A PROBLEM (Newton method), time : ", solverData->timeValue);
+          debugDouble(LOG_NLS_V,"UPS! MUST HANDLE A PROBLEM (Newton method), time : ", solverData->timeValue);
           solverData->info = -1;
           break;
         }
@@ -1487,7 +1487,7 @@ static int newtonAlgorithm(DATA_HOMOTOPY* solverData, double* x)
 #endif
           if (assert)
           {
-            debugDouble(LOG_NLS,"UPS! MUST HANDLE A PROBLEM (Newton method), time : ", solverData->timeValue);
+            debugDouble(LOG_NLS_V,"UPS! MUST HANDLE A PROBLEM (Newton method), time : ", solverData->timeValue);
             solverData->info = -1;
             break;
           }
@@ -1693,7 +1693,7 @@ static int homotopyAlgorithm(DATA_HOMOTOPY* solverData, double *x)
 
   vecConst(solverData->n, 0.0, solverData->dy2);
   solverData->dy2[solverData->n]= solverData->startDirection;
-  printHomotopyUnknowns(LOG_NLS, solverData);
+  printHomotopyUnknowns(LOG_NLS_V, solverData);
   assert = 1;
 #ifndef OMC_EMCC
     MMC_TRY_INTERNAL(simulationJumpBuffer)
@@ -2299,7 +2299,7 @@ int solveHomotopy(DATA *data, threadData_t *threadData, int sysNumber)
 
       // If this is the casual tearing set (only exists for dynamic tearing), break after first try
       if (solverData->info == -1 && solverData->casualTearingSet){
-        infoStreamPrint(LOG_NLS, 0, "### No Solution for the casual tearing set at the first try! ###");
+        infoStreamPrint(LOG_NLS_V, 0, "### No Solution for the casual tearing set at the first try! ###");
         break;
       }
 
@@ -2353,7 +2353,7 @@ int solveHomotopy(DATA *data, threadData_t *threadData, int sysNumber)
 
           pos = solverData->n;
           solveSystemWithTotalPivotSearch(solverData->n, solverData->dy0, solverData->fJac,   solverData->indRow, solverData->indCol, &pos, &rank, solverData->casualTearingSet);
-          debugDouble(LOG_NLS,"solve mixed system at time : ", solverData->timeValue);
+          debugDouble(LOG_NLS_V,"solve mixed system at time : ", solverData->timeValue);
           continue;
         }
       }
@@ -2362,7 +2362,7 @@ int solveHomotopy(DATA *data, threadData_t *threadData, int sysNumber)
         debugString(LOG_NLS_V,"SYSTEM SOLVED");
         debugInt(LOG_NLS_V,   "homotopy method:          ",runHomotopy);
         debugInt(LOG_NLS_V,   "number of function calls: ",solverData->numberOfFunctionEvaluations-numberOfFunctionEvaluationsOld);
-        printUnknowns(LOG_NLS, solverData);
+        printUnknowns(LOG_NLS_V, solverData);
         debugString(LOG_NLS_V, "------------------------------------------------------");
         /* take the solution */
         vecCopy(solverData->n, solverData->x, systemData->nlsx);