Unify reading enumeration flags

This commit simplifies the handling of the command-line arguments. It
fixed some typos from copy-paste, etc. Hopefully generated FMUs will be
able to set flags in the future as well (then the routines handling the
flags need to be moved to a separate module since they are all part of
simulation_runtime.cpp right now).

Belonging to [master]:
  - #1908

Author: sjoelund

SimulationRuntime/c/simulation/simulation_runtime.cpp

@@ -218,124 +218,26 @@ void setGlobalVerboseLevel(int argc, char**argv)
   delete flags;
 }
 
-static int getNonlinearSolverMethod()
+static void readFlag(int *flag, int max, const char *value, const char *flagName, const char **names, const char **desc)
 {
   int i;
-  const char *cflags = omc_flagValue[FLAG_NLS];
-  const string *method = cflags ? new string(cflags) : NULL;
-
-  if(!method)
-    return NLS_MIXED; /* default method */
-
-  for(i=1; i<NLS_MAX; ++i)
-    if(*method == NLS_NAME[i])
-      return i;
-
-  warningStreamPrint(LOG_STDOUT, 1, "unrecognized option -nls=%s, current options are:", method->c_str());
-  for(i=1; i<NLS_MAX; ++i)
-    warningStreamPrint(LOG_STDOUT, 0, "%-18s [%s]", NLS_NAME[i], NLS_DESC[i]);
-  messageClose(LOG_STDOUT);
-  throwStreamPrint(NULL,"see last warning");
-
-  return NLS_NONE;
-}
-
-static int getlinearSolverMethod()
-{
-  int i;
-  const char *cflags = omc_flagValue[FLAG_LS];
-  const string *method = cflags ? new string(cflags) : NULL;
-
-  if(!method)
-    return LS_DEFAULT; /* default method */
-
-  for(i=1; i<LS_MAX; ++i)
-    if(*method == LS_NAME[i])
-      return i;
-
-  warningStreamPrint(LOG_STDOUT, 1, "unrecognized option -ls=%s, current options are:", method->c_str());
-  for(i=1; i<LS_MAX; ++i)
-    warningStreamPrint(LOG_STDOUT, 0, "%-18s [%s]", LS_NAME[i], LS_DESC[i]);
-  messageClose(LOG_STDOUT);
-  throwStreamPrint(NULL,"see last warning");
-
-  return LS_NONE;
-}
-
-static int getlinearSparseSolverMethod()
-{
-  int i;
-  const char *cflags = omc_flagValue[FLAG_LSS];
-  const string *method = cflags ? new string(cflags) : NULL;
-
-  if (!method) {
-    return LSS_DEFAULT; /* default method */
+  if (!value) {
+    return; /* keep the default value */
   }
 
-  for(i=1; i<LSS_MAX; ++i)
-    if(*method == LSS_NAME[i])
-      return i;
-
-  warningStreamPrint(LOG_STDOUT, 1, "unrecognized option -lss=%s, current options are:", method->c_str());
-  for(i=1; i<LSS_MAX; ++i)
-    warningStreamPrint(LOG_STDOUT, 0, "%-18s [%s]", LSS_NAME[i], LSS_DESC[i]);
-  messageClose(LOG_STDOUT);
-  throwStreamPrint(NULL,"see last warning");
-
-  return LSS_NONE;
-}
-
-static int getNewtonStrategy()
-{
-  int i;
-  const char *cflags = omc_flagValue[FLAG_NEWTON_STRATEGY];
-  const string *method = cflags ? new string(cflags) : NULL;
-
-  if(!method)
-    return NEWTON_DAMPED2; /* default method */
-
-  for(i=1; i<NEWTON_MAX; ++i)
-    if(*method == NEWTONSTRATEGY_NAME[i])
-      return i;
-
-  warningStreamPrint(LOG_STDOUT, 1, "unrecognized option -nls=%s, current options are:", method->c_str());
-  for(i=1; i<NEWTON_MAX; ++i)
-    warningStreamPrint(LOG_STDOUT, 0, "%-18s [%s]", NEWTONSTRATEGY_NAME[i], NEWTONSTRATEGY_DESC[i]);
-  messageClose(LOG_STDOUT);
-  throwStreamPrint(NULL,"see last warning");
-
-  return NEWTON_NONE;
-}
-
-static int getNlsLSSolver(int nlsSolver)
-{
-  int i;
-  const char *cflags = omc_flagValue[FLAG_NLS_LS];
-  const string *method = cflags ? new string(cflags) : NULL;
-
-  if(!method)
-  {
-    if (nlsSolver == NLS_KINSOL)
-    {
-      return NLS_LS_KLU; /* default kinsol linear solver method */
-    }
-    else
-    {
-      return NLS_LS_LAPACK; /* default method */
+  for (i=1; i<max; ++i) {
+    if (0 == strcmp(value, names[i])) {
+      *flag = i;
+      return;
     }
   }
 
-  for(i=1; i<NLS_LS_MAX; ++i)
-    if(*method == NLS_LS_METHOD[i])
-      return i;
-
-  warningStreamPrint(LOG_STDOUT, 1, "unrecognized option -nls=%s, current options are:", method->c_str());
-  for(i=1; i<NLS_LS_MAX; ++i)
-    warningStreamPrint(LOG_STDOUT, 0, "%-18s [%s]", NLS_LS_METHOD[i], NLS_LS_METHOD_DESC[i]);
+  warningStreamPrint(LOG_STDOUT, 1, "unrecognized option %s=%s, current options are:", flagName, value);
+  for (i=1; i<LS_MAX; ++i) {
+    warningStreamPrint(LOG_STDOUT, 0, "%-18s [%s]", names[i], desc[i]);
+  }
   messageClose(LOG_STDOUT);
   throwStreamPrint(NULL,"see last warning");
-
-  return NLS_LS_UNKNOWN;
 }
 
 static double getFlagReal(enum _FLAG flag, double res)
@@ -839,12 +741,12 @@ int initRuntimeAndSimulation(int argc, char**argv, DATA *data, threadData_t *thr
     EXIT(1);
   }
 
-  data->simulationInfo->nlsMethod = getNonlinearSolverMethod();
-  data->simulationInfo->lsMethod = getlinearSolverMethod();
-  data->simulationInfo->lssMethod = getlinearSparseSolverMethod();
-  data->simulationInfo->newtonStrategy = getNewtonStrategy();
+  readFlag(&data->simulationInfo->nlsMethod, NLS_MAX, omc_flagValue[FLAG_NLS], "-nls", NLS_NAME, NLS_DESC);
+  readFlag(&data->simulationInfo-> lsMethod,  LS_MAX, omc_flagValue[FLAG_LS ],  "-ls",  LS_NAME,  LS_DESC);
+  readFlag(&data->simulationInfo->lssMethod, LSS_MAX, omc_flagValue[FLAG_LSS], "-lss", LSS_NAME, LSS_DESC);
+  readFlag(&data->simulationInfo->newtonStrategy, NEWTON_MAX, omc_flagValue[FLAG_NEWTON_STRATEGY], "-newton", NEWTONSTRATEGY_NAME, NEWTONSTRATEGY_DESC);
   data->simulationInfo->nlsCsvInfomation = omc_flag[FLAG_NLS_INFO];
-  data->simulationInfo->nlsLinearSolver = getNlsLSSolver(data->simulationInfo->nlsMethod);
+  readFlag(&data->simulationInfo->nlsLinearSolver, NLS_LS_MAX, omc_flagValue[FLAG_NLS_LS], "-nlsLS", NLS_LS_METHOD, NLS_LS_METHOD_DESC);
 
   if(omc_flag[FLAG_HOMOTOPY_ADAPT_BEND]) {
     homAdaptBend = atof(omc_flagValue[FLAG_HOMOTOPY_ADAPT_BEND]);

SimulationRuntime/c/simulation/solver/fmi_events.h

@@ -31,8 +31,8 @@
 /*! \file events.h
  */
 
-#ifndef _EVENTS_H_
-#define _EVENTS_H_
+#ifndef _OMC_FMI_EVENTS_H_
+#define _OMC_FMI_EVENTS_H_
 
 #include "simulation_data.h"
 

SimulationRuntime/c/simulation/solver/kinsolSolver.c

@@ -211,7 +211,7 @@ int nlsKinsolAllocate(int size, NONLINEAR_SYSTEM_DATA *nlsData, int linearSolver
   }
 
   /* Specify linear solver and/or corresponding jacobian function*/
-  if (kinsolData->linearSolverMethod == 3)
+  if (kinsolData->linearSolverMethod == NLS_LS_KLU)
   {
     if(nlsData->isPatternAvailable)
     {
@@ -229,23 +229,21 @@ int nlsKinsolAllocate(int size, NONLINEAR_SYSTEM_DATA *nlsData, int linearSolver
       if (checkReturnFlag(flag)){
         errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL Sparse Solver!");
       }
-    }
-    else
-    {
+    } else {
       flag = KINDense(kinsolData->kinsolMemory, size);
       if (checkReturnFlag(flag)){
         errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
       }
     }
   }
-  else if (kinsolData->linearSolverMethod == 1)
+  else if (kinsolData->linearSolverMethod == NLS_LS_TOTALPIVOT)
   {
     flag = KINDense(kinsolData->kinsolMemory, size);
     if (checkReturnFlag(flag)){
       errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
     }
   }
-  else if (kinsolData->linearSolverMethod == 2)
+  else if (kinsolData->linearSolverMethod == NLS_LS_LAPACK)
   {
     flag = KINDense(kinsolData->kinsolMemory, size);
     if (checkReturnFlag(flag)){
@@ -261,12 +259,13 @@ int nlsKinsolAllocate(int size, NONLINEAR_SYSTEM_DATA *nlsData, int linearSolver
   nlsKinsolConfigSetup(kinsolData);
 
   /* debug print level of kinsol */
-  if (ACTIVE_STREAM(LOG_NLS_V))
+  if (ACTIVE_STREAM(LOG_NLS_V)) {
     printLevel = 3;
-  else if (ACTIVE_STREAM(LOG_NLS))
+  } else if (ACTIVE_STREAM(LOG_NLS)) {
     printLevel = 1;
-  else
+  } else {
     printLevel = 0;
+  }
   KINSetPrintLevel(kinsolData->kinsolMemory, printLevel);
 
   return 0;
@@ -751,7 +750,7 @@ void nlsKinsolFScaling(DATA* data, NLS_KINSOL_DATA *kinsolData, NONLINEAR_SYSTEM
       nlsKinsolResiduals(x, kinsolData->fTmp, &kinsolData->userData);
 
       /* calculate the right jacobian */
-      if(nlsData->isPatternAvailable && kinsolData->linearSolverMethod == 3)
+      if(nlsData->isPatternAvailable && kinsolData->linearSolverMethod == NLS_LS_KLU)
       {
         spJac = NewSparseMat(kinsolData->size,kinsolData->size,kinsolData->nnz);
         if (nlsData->analyticalJacobianColumn != NULL){
@@ -871,7 +870,7 @@ int nlsKinsolErrorHandler(int errorCode, DATA *data, NONLINEAR_SYSTEM_DATA *nlsD
     break;
   case KIN_LSETUP_FAIL:
     /* in case of something goes wrong with the symbolic jacobian try the numerical */
-    if ( kinsolData->linearSolverMethod == 3 && nlsData->isPatternAvailable && nlsData->analyticalJacobianColumn != NULL){
+    if ( kinsolData->linearSolverMethod == NLS_LS_KLU && nlsData->isPatternAvailable && nlsData->analyticalJacobianColumn != NULL){
       flag = KINSlsSetSparseJacFn(kinsolData->kinsolMemory, nlsSparseJac);
     }
     if (checkReturnFlag(flag)){

SimulationRuntime/c/simulation/solver/model_help.c

@@ -47,6 +47,7 @@
 #include "mixedSystem.h"
 #include "delay.h"
 #include "epsilon.h"
+#include "simulation/solver/fmi_events.h"
 #include "simulation/solver/stateset.h"
 #include "meta/meta_modelica.h"
 
@@ -939,11 +940,11 @@ void initializeDataStruc(DATA *data, threadData_t *threadData)
 #else
   data->simulationInfo->nlsMethod = NLS_HOMOTOPY;
 #endif
-  data->simulationInfo->nlsLinearSolver = NLS_LS_LAPACK;
+  data->simulationInfo->nlsLinearSolver = NLS_LS_DEFAULT;
   data->simulationInfo->lsMethod = LS_DEFAULT;
   data->simulationInfo->lssMethod = LSS_DEFAULT;
   data->simulationInfo->mixedMethod = MIXED_SEARCH;
-  data->simulationInfo->newtonStrategy = NEWTON_PURE;
+  data->simulationInfo->newtonStrategy = NEWTON_DAMPED2;
   data->simulationInfo->nlsCsvInfomation = 0;
   data->simulationInfo->currentContext = CONTEXT_ALGEBRAIC;
   data->simulationInfo->jacobianEvals = data->modelData->nStates;

SimulationRuntime/c/simulation/solver/nonlinearSolverHomotopy.c

@@ -1146,7 +1146,7 @@ int linearSolverWrapper(int n, double* x, double* A, int* indRow, int* indCol, i
   debugVectorDouble(LOG_NLS_JAC,"vector b:", x, n);
 
   switch(method){
-    case (1): /* NLS_LS_TOTALPIVOT */
+    case NLS_LS_TOTALPIVOT:
 
       solverinfo = solveSystemWithTotalPivotSearch(n, x, A, indRow, indCol, pos, rank, casualTearingSet);
       /* in case of failing */
@@ -1165,7 +1165,7 @@ int linearSolverWrapper(int n, double* x, double* A, int* indRow, int* indCol, i
         returnValue = 0;
       }
       break;
-    case 2: /* NLS_LS_LAPACK */
+    case NLS_LS_LAPACK:
       /* Solve system with lapack */
       dgesv_((int*) &n,
           (int*) &nrhs,
@@ -1200,7 +1200,7 @@ int linearSolverWrapper(int n, double* x, double* A, int* indRow, int* indCol, i
       }
       break;
     default:
-      warningStreamPrint(LOG_STDOUT, 0, "Non-Linear solver try to run with a unknown linear solver.");
+      throwStreamPrint(0, "Non-Linear solver try to run with a unknown linear solver (%d).", method);
   }
 
   /* Debugging error of linear system */

SimulationRuntime/c/simulation/solver/nonlinearSystem.c

@@ -34,6 +34,7 @@
 #include <math.h>
 #include <string.h>
 
+#include "util/simulation_options.h"
 #include "util/omc_error.h"
 #include "nonlinearSystem.h"
 #include "nonlinearValuesList.h"
@@ -348,6 +349,17 @@ int initializeNonlinearSystems(DATA *data, threadData_t *threadData)
 
   infoStreamPrint(LOG_NLS, 1, "initialize non-linear system solvers");
   infoStreamPrint(LOG_NLS, 0, "%ld non-linear systems", data->modelData->nNonLinearSystems);
+  if (data->simulationInfo->nlsLinearSolver == NLS_LS_DEFAULT) {
+#if !defined(OMC_MINIMAL_RUNTIME)
+    if (data->simulationInfo->nlsMethod == NLS_KINSOL) {
+      data->simulationInfo->nlsLinearSolver = NLS_LS_KLU;
+    } else {
+      data->simulationInfo->nlsLinearSolver = NLS_LS_LAPACK;
+    }
+#else
+    data->simulationInfo->nlsLinearSolver = NLS_LS_LAPACK;
+#endif
+  }
 
   for(i=0; i<data->modelData->nNonLinearSystems; ++i)
   {
@@ -837,16 +849,17 @@ int solve_nonlinear_system(DATA *data, threadData_t *threadData, int sysNumber)
     /* SOLVE!
      If the new global homotopy approach is activated and the component contains the homotopy operator
      use the HOMOTOPY SOLVER, otherwise use the selected solver */
-    if(data->callback->useHomotopy == 2 && nonlinsys->homotopySupport)
+    if(data->callback->useHomotopy == 2 && nonlinsys->homotopySupport) {
       nonlinsys->solved = solveHomotopy(data, threadData, sysNumber);
-    else
+    } else {
       nonlinsys->solved = solveNLS(data, threadData, sysNumber);
+    }
   }
 
   if (lambda_steps > 1 && !nonlinsys->solved) {
-    if (!omc_flag[FLAG_HOMOTOPY_ON_FIRST_TRY])
+    if (!omc_flag[FLAG_HOMOTOPY_ON_FIRST_TRY]) {
       warningStreamPrint(LOG_ASSERT, 0, "Failed to solve initial system %d without homotopy method. The homotopy method is used now.", sysNumber);
-
+    }
 #if !defined(OMC_NO_FILESYSTEM)
     if(ACTIVE_STREAM(LOG_INIT))
     {
@@ -864,9 +877,9 @@ int solve_nonlinear_system(DATA *data, threadData_t *threadData, int sysNumber)
     {
       data->simulationInfo->lambda = ((double)step)/(lambda_steps-1);
 
-      if(data->simulationInfo->lambda > 1.0) {
-          data->simulationInfo->lambda = 1.0;
-        }
+      if (data->simulationInfo->lambda > 1.0) {
+        data->simulationInfo->lambda = 1.0;
+      }
 
       infoStreamPrint(LOG_INIT, 0, "[system %d] homotopy parameter lambda = %g", sysNumber, data->simulationInfo->lambda);
       nonlinsys->solved = solveNLS(data, threadData, sysNumber);

SimulationRuntime/c/util/simulation_options.c

@@ -803,6 +803,7 @@ const char *IDA_LS_METHOD_DESC[IDA_LS_MAX] = {
 const char *NLS_LS_METHOD[NLS_LS_MAX] = {
   "unknown",
 
+  "default",
   "totalpivot",
   "lapack",
   "klu"
@@ -811,6 +812,7 @@ const char *NLS_LS_METHOD[NLS_LS_MAX] = {
 const char *NLS_LS_METHOD_DESC[NLS_LS_MAX] = {
   "unknown",
 
+  "chooses the nls linear solver based on which nls is being used.",
   "internal total pivot implementation. Solve in some case even under-determined systems.",
   "use external lapack implementation.",
   "use klu direct sparse solver."

SimulationRuntime/c/util/simulation_options.h

@@ -305,6 +305,8 @@ enum NLS_LS
 {
   NLS_LS_UNKNOWN = 0,
 
+  NLS_LS_DEFAULT,
+
   NLS_LS_TOTALPIVOT,
   NLS_LS_LAPACK,
   NLS_LS_KLU,