- remove path from "Get Var " error message

- incidenceRowExp1 matchcontinue -> match 
- add uode index reduction method, this is the underlying ODE without any constrained stapilization or projection techniques
- add print message to unneccesary case in traversingincidenceRowExpSolvableFinder

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

Author: Jens Frenkel

Compiler/BackEnd/BackendDAEUtil.mo

@@ -3693,9 +3693,18 @@ algorithm
         pa = incidenceRowExp1(varslst,p,pa,false);
       then
         ((e,false,(vars,pa,ofunctionTree)));
+    /* higher derivative, is only present during index reduction */
+    case (((e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr),DAE.ICONST(_)}),(vars,pa,ofunctionTree))))
+      equation
+        (varslst,p) = BackendVariable.getVar(cr, vars);
+        pa = incidenceRowExp1(varslst,p,pa,false);
+      then
+        ((e,false,(vars,pa,ofunctionTree)));
 
+    /* this case should not be here, because it points out that somewhere the dummy var replacement was not done */
     case (((e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),(vars,pa,ofunctionTree))))
       equation
+         print("Use the devel case\n");
         cr = ComponentReference.crefPrefixDer(cr);
         (varslst,p) = BackendVariable.getVar(cr, vars);
         pa = incidenceRowExp1(varslst,p,pa,false);
@@ -3784,56 +3793,54 @@ end traversingincidenceRowExpFinder;
 protected function incidenceRowExp1
   input list<Var> inVarLst;
   input list<Integer> inIntegerLst;
-  input list<Integer> inIntegerLst1;
+  input list<Integer> inVarIndxLst;
   input Boolean notinder;
-  output list<Integer> outIntegerLst;
+  output list<Integer> outVarIndxLst;
 algorithm
-  outIntegerLst := matchcontinue (inVarLst,inIntegerLst,inIntegerLst1,notinder)
+  outVarIndxLst := match (inVarLst,inIntegerLst,inVarIndxLst,notinder)
     local
        list<Var> rest;
-       list<Integer> irest,res,vars;
+       list<Integer> irest,vars;
        Integer i,i1;
        Boolean b;
     case ({},{},vars,_) then vars;
     /*If variable x is a state, der(x) is a variable in incidence matrix,
          x is inserted as negative value, since it is needed by debugging and
          index reduction using dummy derivatives */ 
-    case (BackendDAE.VAR(varKind = BackendDAE.STATE(_)) :: rest,i::irest,vars,b)
-      equation
-        i1 = Util.if_(b,-i,i);
-        failure(_ = List.getMemberOnTrue(i1, vars, intEq));
-        res = incidenceRowExp1(rest,irest,i1::vars,b);
-      then res;
-    case (BackendDAE.VAR(varKind = BackendDAE.STATE_DER()) :: rest,i::irest,vars,b)
-      equation
-        failure(_ = List.getMemberOnTrue(i, vars, intEq));
-        res = incidenceRowExp1(rest,irest,i::vars,b);
-      then res;
-    case (BackendDAE.VAR(varKind = BackendDAE.VARIABLE()) :: rest,i::irest,vars,b)
-      equation
-        failure(_ = List.getMemberOnTrue(i, vars, intEq));
-        res = incidenceRowExp1(rest,irest,i::vars,b);
-      then res;
-    case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE()) :: rest,i::irest,vars,b)
-      equation
-        failure(_ = List.getMemberOnTrue(i, vars, intEq));
-        res = incidenceRowExp1(rest,irest,i::vars,b);
-      then res;
-    case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_DER()) :: rest,i::irest,vars,b)
-      equation
-        failure(_ = List.getMemberOnTrue(i, vars, intEq));
-        res = incidenceRowExp1(rest,irest,i::vars,b);
-      then res;
-    case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_STATE()) :: rest,i::irest,vars,b)
-      equation
-        failure(_ = List.getMemberOnTrue(i, vars, intEq));
-        res = incidenceRowExp1(rest,irest,i::vars,b);
-      then res;
-    case (_ :: rest,_::irest,vars,b)
-      equation
-        res = incidenceRowExp1(rest,irest,vars,b);
-      then res;
-  end matchcontinue;
+    case (BackendDAE.VAR(varKind = BackendDAE.STATE(_)) :: rest,i::irest,_,_)
+      equation
+        i1 = Util.if_(notinder,-i,i);
+        b = List.isMemberOnTrue(i1, inVarIndxLst, intEq);
+        vars = List.consOnTrue(not b, i1, inVarIndxLst);
+      then incidenceRowExp1(rest,irest,vars,notinder);
+    case (BackendDAE.VAR(varKind = BackendDAE.STATE_DER()) :: rest,i::irest,_,_)
+      equation
+        b = List.isMemberOnTrue(i, inVarIndxLst, intEq);
+        vars = List.consOnTrue(not b, i, inVarIndxLst);
+      then incidenceRowExp1(rest,irest,vars,notinder);
+    case (BackendDAE.VAR(varKind = BackendDAE.VARIABLE()) :: rest,i::irest,_,_)
+      equation
+        b = List.isMemberOnTrue(i, inVarIndxLst, intEq);
+        vars = List.consOnTrue(not b, i, inVarIndxLst);
+      then incidenceRowExp1(rest,irest,vars,notinder);
+    case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE()) :: rest,i::irest,_,_)
+      equation
+        b = List.isMemberOnTrue(i, inVarIndxLst, intEq);
+        vars = List.consOnTrue(not b, i, inVarIndxLst);
+      then incidenceRowExp1(rest,irest,vars,notinder);
+    case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_DER()) :: rest,i::irest,_,_)
+      equation
+        b = List.isMemberOnTrue(i, inVarIndxLst, intEq);
+        vars = List.consOnTrue(not b, i, inVarIndxLst);
+      then incidenceRowExp1(rest,irest,vars,notinder);
+    case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_STATE()) :: rest,i::irest,_,_)
+      equation
+        b = List.isMemberOnTrue(i, inVarIndxLst, intEq);
+        vars = List.consOnTrue(not b, i, inVarIndxLst);
+      then incidenceRowExp1(rest,irest,vars,notinder);
+    case (_ :: rest,_::irest,_,_)
+      then incidenceRowExp1(rest,irest,inVarIndxLst,notinder);
+  end match;
 end incidenceRowExp1;
 
 public function traversingincidenceRowExpFinderwithInput "
@@ -8374,6 +8381,7 @@ protected
   String strIndexReductionMethod;
 algorithm
  allIndexReductionMethods := {(BackendDAETransform.reduceIndexDummyDer,"dummyDerivative",IndexReduction.noStateDeselection,"dummyDerivative"),
+                              (IndexReduction.pantelidesIndexReduction,"Pantelites",IndexReduction.noStateDeselection,"uode"),
                               (IndexReduction.pantelidesIndexReduction,"Pantelites",IndexReduction.dynamicStateSelection,"dynamicStateSelection")};
  strIndexReductionMethod := getIndexReductionMethodString();
  strIndexReductionMethod := Util.getOptionOrDefault(ostrIndexReductionMethod,strIndexReductionMethod);

Compiler/BackEnd/Derive.mo

@@ -160,130 +160,6 @@ algorithm
   end matchcontinue;
 end differentiateEquationTime;
 
-protected function removeCrefFromDerCref "
-Author: Frenkel TUD"
-  input list<DAE.Exp> inCrefOrDerCref;
-  input list<DAE.Exp> inDerCref;
-  output list<DAE.Exp> outCrefOrDerCref;
-algorithm 
-  outCrefOrDerCref := match(inCrefOrDerCref,inDerCref)
-    local
-      list<DAE.Exp> rest,crefOrDerCref,crefOrDerCref1;
-      DAE.Exp e;
-    
-    case (inCrefOrDerCref,{}) then inCrefOrDerCref;
-    
-    case (inCrefOrDerCref,e::rest)
-      equation
-        crefOrDerCref = removeCrefFromDerCref(inCrefOrDerCref,rest);
-        (crefOrDerCref1, _) = List.deleteMemberOnTrue(e,crefOrDerCref,Expression.expEqual);
-      then
-        crefOrDerCref1;
-  end match;
-end removeCrefFromDerCref;
-
-protected function traversingcrefOrDerCrefFinder "
-Author: Frenkel TUD
-Returns a list containing, unique, all componentRef or der(componentRef) in an Expression."
-  input tuple<DAE.Exp, tuple<list<DAE.Exp>,list<DAE.Exp>,BackendDAE.Variables> > inExp;
-  output tuple<DAE.Exp, tuple<list<DAE.Exp>,list<DAE.Exp>,BackendDAE.Variables> > outExp;
-algorithm 
-  outExp := matchcontinue(inExp)
-    local
-      list<DAE.Exp> crefOrDerCref,derCref;
-      DAE.Exp e,e1;
-      BackendDAE.Variables timevars;
-      DAE.ComponentRef cr;
-  
-    // CREF
-    case( (e as DAE.CREF(componentRef = cr), (crefOrDerCref,derCref,timevars)) )
-      equation
-        // exlude time
-        failure(DAE.CREF_IDENT(ident = "time",subscriptLst = {}) = cr);
-        (_,_) = BackendVariable.getVar(cr, timevars);
-      then
-        ((e, (e::crefOrDerCref,derCref,timevars) ));
-    
-    // der(CREF)    
-    case ( (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst={e1 as DAE.CREF(componentRef = cr)}), (crefOrDerCref,derCref,timevars)) )
-      equation
-        (_,_) = BackendVariable.getVar(cr, timevars);
-      then
-        ((e, (e::crefOrDerCref,e1::derCref,timevars) ));
-    
-    // der(der(CREF))
-    case ( (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst={e1 as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst={DAE.CREF(componentRef = cr)})}), (crefOrDerCref,derCref,timevars)) )
-      equation
-        (_,_) = BackendVariable.getVar(cr, timevars);
-      then
-        ((e, (e::crefOrDerCref,e1::derCref,timevars) ));
-    
-    case(inExp) then inExp;
-  end matchcontinue;
-end traversingcrefOrDerCrefFinder;
-
-protected function addArray "
-Author: Frenkel TUD"
-  input Integer inIndex;
-  input array<Type_a> inArray;
-  input Type_a inA;
-  input Integer inNumber;
-  input list<tuple<Integer,Integer,Integer>> inDerivedArray;
-  output Integer outIndex;
-  output array<Type_a> outArray;
-  output list<tuple<Integer,Integer,Integer>> outDerivedArray;
-  output Boolean outAdd;
-  replaceable type Type_a subtypeof Any;
-algorithm
-  (outIndex,outArray,outDerivedArray,outAdd) := matchcontinue (inIndex,inArray,inA,inNumber,inDerivedArray)
-    local
-      list<tuple<Integer,Integer,Integer>> rest,derivedArray;
-      tuple<Integer,Integer,Integer> dArray;
-      list<Type_a> alst,alst1;
-      Integer index,index1,dindex,dnumber,dnumber_1;
-      array<Type_a> a1;
-      Boolean add;
-   // no derived functions without outputs
-   case (inIndex,inArray,inA,inNumber,derivedArray)
-     equation
-       true = intEq(inNumber,0);
-     then
-       (inIndex,inArray,derivedArray,false);
-   // not derived   
-   case (inIndex,inArray,inA,inNumber,{})
-     equation
-        alst = arrayList(inArray);
-        alst1 = listAppend(alst,{inA});
-        a1 = listArray(alst1);
-        index = arrayLength(inArray);
-     then
-       (index,a1,{(inIndex,index,1)},true);
-   // derived    
-   case (inIndex,inArray,inA,inNumber,(dArray as (index,dindex,dnumber))::rest)
-     equation
-       // search
-       true = intEq(inIndex,index);
-       true = dnumber < inNumber;
-       dnumber_1 = dnumber + 1;
-     then
-       (dindex,inArray,(index,dindex,dnumber_1)::rest,true);
-   case (inIndex,inArray,inA,inNumber,(dArray as (index,dindex,dnumber))::rest)
-     equation
-       // search
-       true = intEq(inIndex,index);
-       false = dnumber < inNumber;
-     then
-       (dindex,inArray,(index,dindex,dnumber)::rest,false);
-   case (inIndex,inArray,inA,inNumber,(dArray as (index,dindex,dnumber))::rest)
-     equation
-       false = intEq(inIndex,index);
-       // next
-       (index1,a1,derivedArray,add) = addArray(inIndex,inArray,inA,inNumber,rest);
-     then   
-       (index1,a1,dArray::derivedArray,add);
-  end matchcontinue;
-end addArray;
-
 public function differentiateExpTime "function: differentiateExpTime
   This function differentiates expressions with respect to the \'time\' variable.
   All other variables that are varying over time are given as the second variable.

Compiler/Util/Flags.mo

@@ -619,6 +619,7 @@ constant ConfigFlag INDEX_REDUCTION_METHOD = CONFIG_FLAG(15, "indexReductionMeth
   NONE(), EXTERNAL(), STRING_FLAG("dynamicStateSelection"),
   SOME(STRING_DESC_OPTION({
     ("dummyDerivative", Util.gettext("simple index reduction method, select dummy states based on heuristics")),
+    ("uode", Util.gettext("use the underlying ode without the constraints")),
     ("dynamicStateSelection", Util.gettext("simple index reduction method, select (dynamic) dummy states based on analysis of the system"))})),
     Util.gettext("Sets the index reduction method to use. See +help=optmodules for more info."));
 constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules",

Compiler/runtime/SimulationResultsCmp.c

@@ -696,7 +696,7 @@ void* SimulationResultsCmp_compareResults(int runningTestsuite, const char *file
       fixCommaInName(&var2,len);
       dataref = getData(var2,reffilename,size_ref,&simresglob_ref);
       if (dataref.n==0) {
-        fprintf(stderr, "Get Data of Var %s from file %s failed\n",var,reffilename);
+        fprintf(stderr, "Get Data of Var %s from file %s failed\n",var,runningTestsuite ? SystemImpl__basename(reffilename) : reffilename);
         c_add_message(-1, ErrorType_scripting, ErrorLevel_warning, gettext("Get Data of Var failed!\n"), msg, 0);
         ngetfailedvars++;
         continue;
@@ -710,7 +710,7 @@ void* SimulationResultsCmp_compareResults(int runningTestsuite, const char *file
       data = getData(var1,filename,size,&simresglob_c);
       if (data.n==0)  {
         if (data.data) free(data.data);
-        fprintf(stderr, "Get Data of Var %s from file %s failed\n",var,filename);
+        fprintf(stderr, "Get Data of Var %s from file %s failed\n",var,runningTestsuite ? SystemImpl__basename(filename) : filename);
         c_add_message(-1, ErrorType_scripting, ErrorLevel_warning, gettext("Get Data of Var failed!\n"), msg, 0);
         ngetfailedvars++;
         continue;