- fix tests

- bugfix dynamic state selection, planar pendulum works now

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@14513 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Compiler/BackEnd/BackendDAE.mo

@@ -498,7 +498,7 @@ public
 uniontype StateSet
   record STATESET
     Integer rang;
-    .DAE.ComponentRef state;
+    list< .DAE.ComponentRef> state;
     .DAE.ComponentRef crA "set.x=A*states";
     list< Var> varA;
     list< Var> statescandidates;

Compiler/BackEnd/BackendDAEUtil.mo

@@ -2218,13 +2218,14 @@ algorithm
       equation
         // "Mark an unmarked node/equation"
         true = intEq(iMark[eqn],0);
-        mark = arrayUpdate(iMark, eqn, 1);
+        _ = arrayUpdate(iMark, eqn, 1);
         vlst = List.select(m[eqn], Util.intPositive) "vars of equation";
+        vlst = List.removeOnTrue(arrayLength(ass1), intLt, vlst) "take care we access not behind ass1 length";
         queue = List.map1r(vlst,arrayGet,ass1) "equations of vars";
         queue = List.select(queue, Util.intPositive);
-        queue = List.fold1(queue,consNotMarked,mark,nextQueue);
+        queue = List.fold1(queue,consNotMarked,iMark,nextQueue);
       then
-        markStateEquationsWork(eqns,queue,m,ass1,mark);
+        markStateEquationsWork(eqns,queue,m,ass1,iMark);
     case (eqn::eqns,_,_,_,_)
       equation
         // Node allready marked.

Compiler/BackEnd/IndexReduction.mo

@@ -3839,7 +3839,7 @@ algorithm
         Debug.fcall(Flags.BLT_DUMP, BackendDump.debuglst,((dstates,BackendDAETransform.dumpStates,"\n","\n")));
 
         // generate Set Vars
-        (set,crset,setVars,crA,aVars,tp,crJ,varJ) = getSetVars(iSetIndex,rang,size);
+        (set,crset,setVars,crA,aVars,tp,crJ,varJ) = getSetVars(iSetIndex,rang,size,unassignedEqnsSize);
         // add set states 
         v = BackendVariable.addVars(setVars,v);
 
@@ -3852,8 +3852,9 @@ algorithm
         expcrA = DAE.CAST(tp,expcrA);
         op = Util.if_(intGt(rang,1),DAE.MUL_MATRIX_PRODUCT(DAE.T_REAL_DEFAULT),DAE.MUL_SCALAR_PRODUCT(DAE.T_REAL_DEFAULT));
         mulAstates = DAE.BINARY(expcrA,op,DAE.ARRAY(DAE.T_ARRAY(DAE.T_REAL_DEFAULT,{DAE.DIM_INTEGER(size)},DAE.emptyTypeSource),true,expcrstates));
+        ((mulAstates,(_,_))) = BackendDAEUtil.extendArrExp((mulAstates,(NONE(),false)));
         mulAdstates = DAE.BINARY(expcrA,op,DAE.ARRAY(DAE.T_ARRAY(DAE.T_REAL_DEFAULT,{DAE.DIM_INTEGER(size)},DAE.emptyTypeSource),true,expcrdstates));
-        //((mulAset,(_,_))) = BackendDAEUtil.extendArrExp((mulAset,(NONE(),false)));
+        ((mulAdstates,(_,_))) = BackendDAEUtil.extendArrExp((mulAdstates,(NONE(),false)));
         expset = Util.if_(intGt(rang,1),DAE.ARRAY(DAE.T_ARRAY(DAE.T_REAL_DEFAULT,{DAE.DIM_INTEGER(rang)},DAE.emptyTypeSource),true,expcrset),listGet(expcrset,1));
         expderset = Util.if_(intGt(rang,1),DAE.ARRAY(DAE.T_ARRAY(DAE.T_REAL_DEFAULT,{DAE.DIM_INTEGER(rang)},DAE.emptyTypeSource),true,expcrdset),listGet(expcrdset,1));
         // add set.states = set.A*{dummystates} equation
@@ -3880,7 +3881,7 @@ algorithm
         varlst = List.map1r(List.map(states,Util.tuple22),BackendVariable.getVarAt,vars);
         ovarlst = List.map1r(List.map(dstates,Util.tuple22),BackendVariable.getVarAt,vars);
 
-        syst = BackendDAE.EQSYSTEM(v,eqnsarr,om,omT,matching,BackendDAE.STATESET(rang,set,crA,aVars,varlst,ovarlst,eqnlst,oeqnlst,crJ,varJ)::stateSets);
+        syst = BackendDAE.EQSYSTEM(v,eqnsarr,om,omT,matching,BackendDAE.STATESET(rang,crset,crA,aVars,varlst,ovarlst,eqnlst,oeqnlst,crJ,varJ)::stateSets);
 
         // add dummy states
         dstates1 = listAppend(states,dstates);
@@ -6081,6 +6082,7 @@ protected function getSetVars
   input Integer index;
   input Integer setsize;
   input Integer nStates;
+  input Integer nCEqns;
   output DAE.ComponentRef crstates;
   output list<DAE.ComponentRef> crset;
   output list<BackendDAE.Var> oSetVars;
@@ -6112,7 +6114,7 @@ algorithm
   // add start value A[i,j] = if i==j then 1 else 0 via initial equations
   oAVars := List.map1(oAVars,BackendVariable.setVarStartValue,DAE.ICONST(0));
   oAVars := setSetAStart(oAVars,1,nStates,{});
-  tp := Util.if_(intGt(setsize,1),DAE.T_ARRAY(DAE.T_REAL_DEFAULT,{DAE.DIM_INTEGER(setsize)}, DAE.emptyTypeSource),DAE.T_REAL_DEFAULT);
+  tp := Util.if_(intGt(nCEqns,1),DAE.T_ARRAY(DAE.T_REAL_DEFAULT,{DAE.DIM_INTEGER(nCEqns)}, DAE.emptyTypeSource),DAE.T_REAL_DEFAULT);
   ocrJ := ComponentReference.joinCrefs(set,ComponentReference.makeCrefIdent("J",tp,{}));
   oJVars := generateArrayVar(ocrJ,BackendDAE.VARIABLE(),tp,NONE());
   oJVars := List.map1(oJVars,BackendVariable.setVarFixed,false);

Compiler/BackEnd/SimCode.mo

@@ -455,7 +455,7 @@ uniontype StateSet
     Integer index;
     Integer nCandidates;
     Integer nStates;
-    DAE.ComponentRef states;
+    list<DAE.ComponentRef> states;
     list<DAE.ComponentRef> statescandidates;
     DAE.ComponentRef crA;
     JacobianMatrix jacobianMatrix;

Compiler/BackEnd/SimCodeUtil.mo

@@ -3459,7 +3459,7 @@ algorithm
         // create symbolic jacobian for simulation
         emptyEqns = BackendEquation.listEquation({});
         emptyVars =  BackendVariable.emptyVars();
-        (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(v, kv, eqn, emptyEqns, emptyVars, inFuncs, inAllVars, uniqueEqIndex, tempvars); 
+        (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(v, kv, eqn, emptyEqns, emptyVars, inFuncs, inAllVars, "NLSJac", uniqueEqIndex, tempvars); 
       then
         ({SimCode.SES_NONLINEAR(uniqueEqIndex2, resEqs, crefs, 0, jacobianMatrix)},uniqueEqIndex+1,tempvars);
 
@@ -3474,7 +3474,7 @@ algorithm
         // create symbolic jacobian for simulation
         emptyEqns = BackendEquation.listEquation({});
         emptyVars =  BackendVariable.emptyVars();
-        (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(v, kv, eqn, emptyEqns, emptyVars, inFuncs, inAllVars, uniqueEqIndex, tempvars);
+        (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(v, kv, eqn, emptyEqns, emptyVars, inFuncs, inAllVars, "NLSJac", uniqueEqIndex, tempvars);
       then
         ({SimCode.SES_NONLINEAR(uniqueEqIndex2, resEqs, crefs, 0, jacobianMatrix)},uniqueEqIndex+1,tempvars);
 
@@ -3797,7 +3797,7 @@ algorithm
          otherVarsInts = List.unionList(otherVarsIntsLst);
          ovarsLst = List.map1r(otherVarsInts, BackendVariable.getVarAt, vars);
          ovars = BackendVariable.listVar1(ovarsLst);
-         (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(diffVars, kv, eqns, oeqns, ovars, functree, vars, uniqueEqIndex, tempvars);
+         (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(diffVars, kv, eqns, oeqns, ovars, functree, vars, "NLSJac", uniqueEqIndex, tempvars);
        then
          ({SimCode.SES_NONLINEAR(uniqueEqIndex2, simequations, tcrs, 0, jacobianMatrix)},uniqueEqIndex+1,tempvars);
    end matchcontinue;
@@ -3995,9 +3995,13 @@ protected function createStateSets
   output Integer ouniqueEqIndex;
   output list<SimCode.SimVar> otempvars;
   output Integer numStateSets;
+protected
+  Boolean flag;
 algorithm
+  flag := Flags.set(Flags.NLS_ANALYTIC_JACOBIAN, true);
   (outDAE,(oEquations,ouniqueEqIndex,otempvars,numStateSets)) := 
     BackendDAEUtil.mapEqSystemAndFold(inDAE,createStateSetsSystem,(iEquations,iuniqueEqIndex,itempvars,0));
+  _ := Flags.set(Flags.NLS_ANALYTIC_JACOBIAN, flag);
   // BackendDump.printBackendDAE(outDAE);
 end createStateSets;
 
@@ -4059,7 +4063,8 @@ algorithm
     local
       BackendDAE.StateSets sets;
       Integer rang,numStateSets,nCandidates;
-      DAE.ComponentRef crset,crA,crJ;
+      list<DAE.ComponentRef> crset;
+      DAE.ComponentRef crA,crJ;
       BackendDAE.Variables vars;
       list<BackendDAE.Var> aVars,statevars,dstatesvars,varJ;
       list<BackendDAE.Equation> ceqns,oeqns;
@@ -4068,6 +4073,8 @@ algorithm
       list<SimCode.StateSet> simequations;
       list<SimCode.SimVar> tempvars;
       Integer uniqueEqIndex;
+      BackendDAE.Variables diffVars,ovars;
+      BackendDAE.EquationArray eqnsarr,oeqnsarr;      
     case({},_,_,_,_,_,_,_) then (iVars,iEquations,iuniqueEqIndex,itempvars,iNumStateSets);
     case(BackendDAE.STATESET(rang=rang,state=crset,crA=crA,varA=aVars,statescandidates=statevars,ovars=dstatesvars,eqns=ceqns,oeqns=oeqns,crJ=crJ,varJ=varJ)::sets,_,_,_,_,_,_,_)
       equation
@@ -4077,11 +4084,22 @@ algorithm
         ceqns = replaceDerOpInEquationList(ceqns);
         oeqns = replaceDerOpInEquationList(oeqns);
         // convert ceqns to res[..] = lhs-rhs
-        ceqns = createResidualSetEquations(ceqns,crJ,1,intGt(rang,1),{});
+        ceqns = createResidualSetEquations(ceqns,crJ,1,intGt(listLength(ceqns),1),{});
         // get state names
         crstates = List.map(statevars,BackendVariable.varCref);
+        // get first a element for varinfo
+        crA = ComponentReference.subscriptCrefWithInt(crA,1);
+        crA = Debug.bcallret2(intGt(listLength(crset),1),ComponentReference.subscriptCrefWithInt,crA,1,crA);
         // number of states
         nCandidates = listLength(statevars);
+
+        // create symbolic jacobian for simulation
+        //oeqnsarr = BackendEquation.listEquation(oeqns);
+        //eqnsarr = BackendEquation.listEquation(ceqns);
+        //diffVars = BackendVariable.listVar1(statevars);
+        //ovars = BackendVariable.listVar1(dstatesvars);
+        //(SOME(jacobianMatrix),uniqueEqIndex,tempvars) = createSymbolicSimulationJacobian(diffVars, knVars, eqnsarr, oeqnsarr, ovars, functree, vars, "StateSetJac", iuniqueEqIndex,itempvars);
+
         // create symbolic jacobian for simulation
         (jacobianMatrix,uniqueEqIndex,tempvars) = createSymbolicSimulationJacobianSet(statevars, knVars, varJ, ceqns, dstatesvars, oeqns, vars, functree, iuniqueEqIndex,itempvars);
         // next set  
@@ -4356,14 +4374,15 @@ protected function createSymbolicSimulationJacobian
   input BackendDAE.EquationArray inotherEquations;
   input BackendDAE.Variables inotherVars;
   input DAE.FunctionTree inFuncs;
-  input BackendDAE.Variables inAllVars; 
+  input BackendDAE.Variables inAllVars;
+  input String Name;
   input Integer iuniqueEqIndex;
   input list<SimCode.SimVar> itempvars;
   output Option<SimCode.JacobianMatrix> res;
   output Integer ouniqueEqIndex;
   output list<SimCode.SimVar> otempvars;
 algorithm
-  (res, ouniqueEqIndex, otempvars) := matchcontinue(inVars, inKnVars, inResEquations, inotherEquations, inotherVars, inFuncs, inAllVars, iuniqueEqIndex, itempvars)
+  (res, ouniqueEqIndex, otempvars) := matchcontinue(inVars, inKnVars, inResEquations, inotherEquations, inotherVars, inFuncs, inAllVars, Name, iuniqueEqIndex, itempvars)
   local
     array<DAE.Constraint> constrs;
     array<DAE.ClassAttributes> clsAttrs;
@@ -4396,7 +4415,7 @@ algorithm
     list<SimCode.SimVar> seedVars, indexVars;
 
     String errorMessage;
-    case(_,_,_,_,_,_,_,_,_)
+    case(_,_,_,_,_,_,_,_,_,_)
       equation
         true = Flags.isSet(Flags.NLS_ANALYTIC_JACOBIAN);
         Debug.fcall(Flags.JAC_DUMP2, print, "---+++ create analytical jacobian +++---");
@@ -4469,7 +4488,7 @@ algorithm
                                           knvars,
                                           dependentVars,
                                           dependentVarsLst,
-                                          "NLSJac" +& intString(iuniqueEqIndex));
+                                          Name +& intString(iuniqueEqIndex));
 
         (BackendDAE.DAE(eqs={syst as BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(comps=comps))},
                                     shared=shared), name,
@@ -4527,7 +4546,7 @@ algorithm
         Debug.fcall(Flags.JAC_DUMP, print, "analytical Jacobians -> transformed to SimCode for Matrix " +& name +& " time: " +& realString(clock()) +& "\n");
 
         then (SOME(({(columnEquations,columnVars,s)},seedVars,name,(sparsepatternComRefs,(seedVars,indexVars)),sparseColoring,maxColor)), uniqueEqIndex, tempvars);
-    case(_,_,_,_,_,_,_,_,_)
+    case(_,_,_,_,_,_,_,_,_,_)
       equation
         false = Flags.isSet(Flags.NLS_ANALYTIC_JACOBIAN);
       then (NONE(), iuniqueEqIndex, itempvars);          

Compiler/Template/CodegenC.tpl

@@ -941,15 +941,17 @@ template functionInitialStateSets(list<StateSet> stateSets)
        let generatedJac = 'functionJacStateSetJac<%set.index%>_column'
        let initialJac = 'initialAnalyticJacobianStateSetJac<%set.index%>'
        let jacIndex = 'INDEX_JAC_StateSetJac<%set.index%>'
+       let statesvars = (states |> s hasindex i2 fromindex 0 => 'statesetData[<%i1%>].states[<%i2%>] = &<%cref(s)%>__varInfo;' ;separator="\n")
        let statescandidatesvars = (statescandidates |> cstate hasindex i2 fromindex 0 => 'statesetData[<%i1%>].statescandidates[<%i2%>] = &<%cref(cstate)%>__varInfo;' ;separator="\n")
        <<
        statesetData[<%i1%>].nCandidates = <%nCandidates%>;
        statesetData[<%i1%>].nStates = <%nStates%>;
        statesetData[<%i1%>].nDummyStates = <%nCandidates%>-<%nStates%>;
-       statesetData[<%i1%>].states = &<%cref(states)%>;
+       statesetData[<%i1%>].states = (VAR_INFO**) calloc(<%nStates%>,sizeof(VAR_INFO));
+       <%statesvars%>
        statesetData[<%i1%>].statescandidates = (VAR_INFO**) calloc(<%nCandidates%>,sizeof(VAR_INFO));
        <%statescandidatesvars%>
-       statesetData[<%i1%>].A = &<%cref(crA)%>;
+       statesetData[<%i1%>].A = &<%cref(crA)%>__varInfo;
        statesetData[<%i1%>].rowPivot = (modelica_integer*) calloc(<%nCandidates%>-<%nStates%>,sizeof(modelica_integer));
        statesetData[<%i1%>].colPivot = (modelica_integer*) calloc(<%nCandidates%>,sizeof(modelica_integer));
        statesetData[<%i1%>].J = (modelica_real*) calloc(<%nCandidates%>*<%nStates%>,sizeof(modelica_real));

Compiler/Template/SimCodeTV.mo

@@ -318,7 +318,7 @@ package SimCode
       Integer index;
       Integer nCandidates;
       Integer nStates;
-      DAE.ComponentRef states;
+      list<DAE.ComponentRef> states;
       list<DAE.ComponentRef> statescandidates;
       DAE.ComponentRef crA;
       JacobianMatrix jacobianMatrix;

SimulationRuntime/c/math-support/pivot.c

@@ -81,7 +81,7 @@ They hold the old (and new) pivoting information, such that
 void pivot( double *A, modelica_integer n_rows, modelica_integer n_cols, modelica_integer *rowInd, modelica_integer *colInd )
 {
   // parameter, determines how much larger an element should be before rows and columns are interchanged
-  const double fac = 2.0;
+  const double fac = 1.125; // approved by dymola ;)
 
   // temporary variables
   modelica_integer row;

SimulationRuntime/c/simulation/solver/solver_main.c

@@ -391,6 +391,7 @@ int solver_main(DATA* data, const char* init_initMethod,
     {
       /* if new set is calculated reinit the solver */
       solverInfo.didEventStep = 1;
+      overwriteOldSimulationData(data);
     }
 
     /******** Emit this time step ********/

SimulationRuntime/c/simulation/solver/stateset.c

@@ -93,10 +93,10 @@ void getAnalyticalJacobianSet(DATA* data, unsigned int index)
       if(data->simulationInfo.analyticJacobians[jacIndex].sparsePattern.colorCols[ii]-1 == i)
         data->simulationInfo.analyticJacobians[jacIndex].seedVars[ii] = 1;
 
-    if(DEBUG_STREAM(LOG_DSS)){
-      INFO(LOG_DSS,"Caluculate one col:\n");
+    if(DEBUG_STREAM(LOG_DSSJAC)){
+      INFO(LOG_DSSJAC,"Caluculate one col:\n");
       for(l=0;  l < data->simulationInfo.analyticJacobians[jacIndex].sizeCols;l++)
-        INFO2(LOG_DSS,"seed: data->simulationInfo.analyticJacobians[index].seedVars[%d]= %f",l,data->simulationInfo.analyticJacobians[jacIndex].seedVars[l]);
+        INFO2(LOG_DSSJAC,"seed: data->simulationInfo.analyticJacobians[index].seedVars[%d]= %f",l,data->simulationInfo.analyticJacobians[jacIndex].seedVars[l]);
     }
 
     ((data->simulationInfo.stateSetData[index].analyticalJacobianColumn))(data);
@@ -109,13 +109,13 @@ void getAnalyticalJacobianSet(DATA* data, unsigned int index)
           ii = 0;
         else
           ii = data->simulationInfo.analyticJacobians[jacIndex].sparsePattern.leadindex[j-1];
-        INFO2(LOG_DSS," take for %d -> %d\n",j,ii);
+        INFO2(LOG_DSSJAC," take for %d -> %d\n",j,ii);
         while(ii < data->simulationInfo.analyticJacobians[jacIndex].sparsePattern.leadindex[j])
         {
           l  = data->simulationInfo.analyticJacobians[jacIndex].sparsePattern.index[ii];
           k  = j*data->simulationInfo.analyticJacobians[jacIndex].sizeRows + l;
           jac[k] = data->simulationInfo.analyticJacobians[jacIndex].resultVars[l];
-          INFO7(LOG_DSS,"write %d. in jac[%d]-[%d,%d]=%f from col[%d]=%f",ii,k,l,j,jac[k],l,data->simulationInfo.analyticJacobians[jacIndex].resultVars[l]);
+          INFO7(LOG_DSSJAC,"write %d. in jac[%d]-[%d,%d]=%f from col[%d]=%f",ii,k,l,j,jac[k],l,data->simulationInfo.analyticJacobians[jacIndex].resultVars[l]);
           ii++;
         };
       }
@@ -136,29 +136,33 @@ void getAnalyticalJacobianSet(DATA* data, unsigned int index)
   }
 }
 
-void setAMatrix(modelica_integer* newEnable, modelica_integer nCandidates, modelica_integer nStates, modelica_integer* A, modelica_real* states, VAR_INFO** statecandidates, DATA *data)
+void setAMatrix(modelica_integer* newEnable, modelica_integer nCandidates, modelica_integer nStates, VAR_INFO* Ainfo, VAR_INFO** states, VAR_INFO** statecandidates, DATA *data)
 {
   modelica_integer col;
   modelica_integer row=0;
   /* clear old values */
+  unsigned int aid = Ainfo->id - data->modelData.integerVarsData[0].info.id;
+  modelica_integer *A = &(data->localData[0]->integerVars[aid]);
   memset(A,0,nCandidates*nStates*sizeof(modelica_integer));
 
   for (col=0;col<nCandidates;col++)
   {
     if (newEnable[col]==2)
     {
-      unsigned int id = statecandidates[col]->id-1000;
+      unsigned int firstrealid = data->modelData.realVarsData[0].info.id;
+      unsigned int id = statecandidates[col]->id-firstrealid;
+      unsigned int sid = states[row]->id-firstrealid;
       INFO1(LOG_DSS," select %s\n",statecandidates[col]->name);
       /* set A[row,col] */
       set_matrix_elt(A,col,row,nCandidates,1);
       /* reinit state */
-      states[row] = data->localData[0]->realVars[id];
+      data->localData[0]->realVars[sid] = data->localData[0]->realVars[id];
       row++;
     }
   } 
 }
 
-int comparePivot(modelica_integer *oldPivot, modelica_integer *newPivot, modelica_integer nCandidates, modelica_integer nDummyStates, modelica_integer nStates, modelica_integer* A, modelica_real* states, VAR_INFO** statecandidates, DATA *data)
+int comparePivot(modelica_integer *oldPivot, modelica_integer *newPivot, modelica_integer nCandidates, modelica_integer nDummyStates, modelica_integer nStates, VAR_INFO* A, VAR_INFO** states, VAR_INFO** statecandidates, DATA *data)
 {
   modelica_integer i;
   int ret = 0;
@@ -176,7 +180,7 @@ int comparePivot(modelica_integer *oldPivot, modelica_integer *newPivot, modelic
   {
     if (newEnable[i] != oldEnable[i])
     {
-      INFO(LOG_DSS,"Select new States:");
+      INFO1(LOG_DSS,"Select new States at time %f:",data->localData[0]->timeValue);
       ret = -1;
       break;
     }

SimulationRuntime/c/simulation_data.h

@@ -284,12 +284,12 @@ typedef struct STATE_SET_DATA
   modelica_integer nStates;
   modelica_integer nDummyStates;
 
-  modelica_integer* A;
+  VAR_INFO* A;
   modelica_integer* rowPivot;
   modelica_integer* colPivot;
   modelica_real* J;
 
-  modelica_real* states;
+  VAR_INFO** states;
   VAR_INFO** statescandidates;
 
   /* if analyticalJacobianColumn != NULL analyticalJacobian is available and

SimulationRuntime/c/util/omc_error.c

@@ -60,7 +60,8 @@ const char *LOG_STREAM_NAME[LOG_MAX] = {
   "LOG_STATS",
   "LOG_UTIL",
   "LOG_ZEROCROSSINGS",
-  "LOG_DSS"
+  "LOG_DSS",
+  "LOG_DSSJAC"
 };
 
 const char *LOG_STREAM_DESC[LOG_MAX] = {

SimulationRuntime/c/util/omc_error.h

@@ -89,6 +89,7 @@ enum LOG_STREAM
   LOG_UTIL,
   LOG_ZEROCROSSINGS,
   LOG_DSS,
+  LOG_DSSJAC,
 
   LOG_MAX
 };