Minor changes

- some comments for symbolic jacobian
- recursion -> loop
- some renaming

Author: ptaeuber

Compiler/BackEnd/BackendDAE.mo

@@ -741,9 +741,9 @@ type SymbolicJacobians = list<tuple<Option<SymbolicJacobian>, SparsePattern, Spa
 public
 type SymbolicJacobian = tuple<BackendDAE,               // symbolic equation system
                               String,                   // Matrix name
-                              list<Var>,                // diff vars
-                              list<Var>,                // result diffed equation
-                              list<Var>                 // all diffed equation
+                              list<Var>,                // diff vars (independent vars)
+                              list<Var>,                // diffed vars (residual vars)
+                              list<Var>                 // all diffed vars (residual vars + dependent vars)
                               >;
 
 public

Compiler/BackEnd/BackendDAEOptimize.mo

@@ -582,7 +582,7 @@ algorithm
         eqn = BackendEquation.equationNth1(eqns,pos);
         BackendDAE.EQUATION(exp=e1,scalar=e2) = eqn;
         // variable time not there
-        globalKnownVars = BackendVariable.daeKnVars(shared);
+        globalKnownVars = BackendVariable.daeGlobalKnownVars(shared);
         (_,(false,_,_,_,_)) = Expression.traverseExpTopDown(e1, traversingTimeEqnsFinder, (false,vars,globalKnownVars,true,false));
         (_,(false,_,_,_,_)) = Expression.traverseExpTopDown(e2, traversingTimeEqnsFinder, (false,vars,globalKnownVars,true,false));
         cr = BackendVariable.varCref(var);
@@ -601,7 +601,7 @@ algorithm
         eqn = BackendEquation.equationNth1(eqns,pos);
         BackendDAE.EQUATION(exp=e1,scalar=e2) = eqn;
         // variable time not there
-        globalKnownVars = BackendVariable.daeKnVars(shared);
+        globalKnownVars = BackendVariable.daeGlobalKnownVars(shared);
         (_,(false,_,_,_,_)) = Expression.traverseExpTopDown(e1, traversingTimeEqnsFinder, (false,vars,globalKnownVars,false,false));
         (_,(false,_,_,_,_)) = Expression.traverseExpTopDown(e2, traversingTimeEqnsFinder, (false,vars,globalKnownVars,false,false));
         cr = BackendVariable.varCref(var);
@@ -5209,7 +5209,7 @@ algorithm
   tmpv := BackendVariable.makeVar(cref);
   //tmpv := BackendVariable.setVarKind(tmpv, BackendDAE.PARAM());
   tmpv := BackendVariable.setBindExp(tmpv, SOME(DAE.RCONST(0.0)));
-  shared := BackendVariable.addKnVarDAE(tmpv, inDAE.shared);
+  shared := BackendVariable.addGlobalKnownVarDAE(tmpv, inDAE.shared);
 
   for syst in inDAE.eqs loop
    (syst_, shared) := symEulerUpdateSyst(syst, b, shared);

Compiler/BackEnd/BackendDAEUtil.mo

@@ -8418,18 +8418,18 @@ algorithm
   outDAE := BackendDAE.DAE(systs, shared);
 end setAliasVars;
 
-public function setKnownVars "author: lochel"
+public function setDAEGlobalKnownVars "author: lochel"
   input BackendDAE.BackendDAE inDAE;
-  input BackendDAE.Variables inKnownVars;
+  input BackendDAE.Variables inGlobalKnownVars;
   output BackendDAE.BackendDAE outDAE;
 protected
   BackendDAE.EqSystems systs;
   BackendDAE.Shared shared;
 algorithm
   BackendDAE.DAE(systs, shared) := inDAE;
-  shared := setSharedGlobalKnownVars(shared, inKnownVars);
+  shared := setSharedGlobalKnownVars(shared, inGlobalKnownVars);
   outDAE := BackendDAE.DAE(systs, shared);
-end setKnownVars;
+end setDAEGlobalKnownVars;
 
 public function setFunctionTree "author: lochel"
   input BackendDAE.BackendDAE inDAE;

Compiler/BackEnd/BackendEquation.mo

@@ -2414,7 +2414,7 @@ algorithm
     eqnVars := equationVars(eqn, ivars);
     b := listEmpty(eqnVars) and not Expression.expHasCref(y, DAE.crefTime);
     if b then
-      knowVars := BackendVariable.daeKnVars(oshared);
+      knowVars := BackendVariable.daeGlobalKnownVars(oshared);
       eqnKnVars := equationVars(eqn, knowVars);
       (inputsKnVars,_) := List.splitOnTrue(eqnKnVars, BackendVariable.isInput);
        b := listEmpty(inputsKnVars);
@@ -2428,7 +2428,7 @@ algorithm
       else
         tmpvar := BackendVariable.setBindExp(tmpvar, SOME(y));
         tmpvar := BackendVariable.setVarKind(tmpvar, BackendDAE.PARAM());
-        oshared := BackendVariable.addKnVarDAE(tmpvar, oshared);
+        oshared := BackendVariable.addGlobalKnownVarDAE(tmpvar, oshared);
         para := true;
       end if;
     else

Compiler/BackEnd/BackendVariable.mo

@@ -2124,10 +2124,10 @@ public function daeVars "returns orderedVars"
   output BackendDAE.Variables vars = inEqSystem.orderedVars;
 end daeVars;
 
-public function daeKnVars
+public function daeGlobalKnownVars
   input BackendDAE.Shared inShared;
   output BackendDAE.Variables outGlobalKnownVars = inShared.globalKnownVars;
-end daeKnVars;
+end daeGlobalKnownVars;
 
 public function daeAliasVars
   input BackendDAE.Shared inShared;
@@ -2500,27 +2500,27 @@ algorithm
   outEqSystem := List.fold(inVars, addVarDAE, outEqSystem);
 end addVarsDAE;
 
-public function addKnVarDAE
+public function addGlobalKnownVarDAE
 "author: Frenkel TUD 2011-04
   Add a variable to Variables of a BackendDAE.
   If the variable already exists, the function updates the variable."
-  input BackendDAE.Var inVar;
+  input BackendDAE.Var inGlobalKnownVar;
   input BackendDAE.Shared inShared;
   output BackendDAE.Shared outShared;
 algorithm
-  outShared := BackendDAEUtil.setSharedGlobalKnownVars(inShared, addVar(inVar, inShared.globalKnownVars));
-end addKnVarDAE;
+  outShared := BackendDAEUtil.setSharedGlobalKnownVars(inShared, addVar(inGlobalKnownVar, inShared.globalKnownVars));
+end addGlobalKnownVarDAE;
 
-public function addNewKnVarDAE
+public function addNewGlobalKnownVarDAE
 "author: Frenkel TUD 2011-04
   Add a variable to Variables of a BackendDAE.
   No Check if variable already exist. Use only for new variables"
-  input BackendDAE.Var inVar;
+  input BackendDAE.Var inGlobalKnownVar;
   input BackendDAE.Shared inShared;
   output BackendDAE.Shared outShared;
 algorithm
-  outShared := BackendDAEUtil.setSharedGlobalKnownVars(inShared, addNewVar(inVar, inShared.globalKnownVars));
-end addNewKnVarDAE;
+  outShared := BackendDAEUtil.setSharedGlobalKnownVars(inShared, addNewVar(inGlobalKnownVar, inShared.globalKnownVars));
+end addNewGlobalKnownVarDAE;
 
 public function addAliasVarDAE
 "author: Frenkel TUD 2012-09

Compiler/BackEnd/DynamicOptimization.mo

@@ -454,7 +454,7 @@ algorithm
       BackendDAE.Variables vars;
 
     case BackendDAE.EQSYSTEM(orderedEqs=orderedEqs) algorithm
-      vars := BackendVariable.daeKnVars(outShared);
+      vars := BackendVariable.daeGlobalKnownVars(outShared);
 
       ((_, idercr, icr, varLst)) := BackendDAEUtil.traverseBackendDAEExpsEqnsWithUpdate(orderedEqs, traverserinputDerivativesForDynOpt, (vars, idercr, icr, varLst));
       if listEmpty(idercr) then
@@ -463,16 +463,16 @@ algorithm
       // der(u) -> u has der
       varLst := BackendVariable.setVarsKind(varLst, BackendDAE.OPT_INPUT_WITH_DER());
       for v in varLst loop
-        outShared := BackendVariable.addKnVarDAE(v, outShared);
+        outShared := BackendVariable.addGlobalKnownVarDAE(v, outShared);
       end for;
       //  der(u) -> new input var
       varLst := List.map(idercr, BackendVariable.makeVar);
       varLst := List.map1(varLst, BackendVariable.setVarDirection, DAE.INPUT());
       for v in varLst loop
         v := BackendVariable.setVarKind(v,BackendDAE.OPT_INPUT_DER());
-        outShared := BackendVariable.addKnVarDAE(v, outShared);
+        outShared := BackendVariable.addGlobalKnownVarDAE(v, outShared);
       end for;
-      _ := BackendVariable.daeKnVars(outShared);
+      _ := BackendVariable.daeGlobalKnownVars(outShared);
        //BackendDump.printVariables(vars);
     then (isyst, true);
 
@@ -725,7 +725,7 @@ algorithm
       var := BackendVariable.mergeAliasVars(var, var_, false, globalKnownVars);
       var := BackendVariable.setVarKind(var, BackendDAE.OPT_LOOP_INPUT(cr_var));
     end if;
-    oshared := BackendVariable.addKnVarDAE(var, oshared);
+    oshared := BackendVariable.addGlobalKnownVarDAE(var, oshared);
     oeqns := BackendEquation.addEquation(BackendDAE.EQUATION(e, Expression.crefExp(cr), DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN), oeqns);
   end for;
 

Compiler/BackEnd/IndexReduction.mo

@@ -971,7 +971,7 @@ algorithm
     // 1th try to replace final parameter
     case (_,_,_,_,_,syst as BackendDAE.EQSYSTEM(m=SOME(_), mT=SOME(_)))
       equation
-        ((eqns, eqnslst as _::_, _)) = List.fold1( inEqns, replaceFinalVars, BackendVariable.daeKnVars(inShared),
+        ((eqns, eqnslst as _::_, _)) = List.fold1( inEqns, replaceFinalVars, BackendVariable.daeGlobalKnownVars(inShared),
                                                    (syst.orderedEqs, {}, BackendVarTransform.emptyReplacements()));
         syst.orderedEqs = eqns;
         // unassign changed equations and assigned vars
@@ -1806,7 +1806,7 @@ algorithm
         // get orgequations of that level
         (eqnslst1,orgEqnsLst) = removeFirstOrgEqns(iOrgEqnsLst);
         // replace final parameter
-        (eqnslst,_) = BackendEquation.traverseExpsOfEquationList(eqnslst1, replaceFinalVarsEqn,(BackendVariable.daeKnVars(inShared),false,BackendVarTransform.emptyReplacements()));
+        (eqnslst,_) = BackendEquation.traverseExpsOfEquationList(eqnslst1, replaceFinalVarsEqn,(BackendVariable.daeGlobalKnownVars(inShared),false,BackendVarTransform.emptyReplacements()));
         // replace all der(x) with dx
         (eqnslst,_) = BackendEquation.traverseExpsOfEquationList(eqnslst, Expression.traverseSubexpressionsHelper, (replaceDerStatesStatesExp,so));
         // force inline

Compiler/BackEnd/Initialization.mo

@@ -857,7 +857,7 @@ algorithm
     GC.free(secondary);
     outPrimaryParameters := listReverse(outPrimaryParameters);
     outAllPrimaryParameters := listReverse(outAllPrimaryParameters);
-    dae := BackendDAEUtil.setKnownVars(dae, otherVariables);
+    dae := BackendDAEUtil.setDAEGlobalKnownVars(dae, otherVariables);
 
     //BackendDump.dumpVarList(outPrimaryParameters, "outPrimaryParameters");
     //BackendDump.dumpVarList(outAllPrimaryParameters, "outAllPrimaryParameters");

Compiler/BackEnd/OnRelaxation.mo

@@ -325,7 +325,7 @@ algorithm
           BackendDAEUtil.profilerreset1();
           BackendDAEUtil.profilerstart1();
         // replace evaluated parametes
-        //_ = BackendDAEUtil.traverseBackendDAEExpsEqnsWithUpdate(eqns, replaceFinalParameter, BackendVariable.daeKnVars(shared));
+        //_ = BackendDAEUtil.traverseBackendDAEExpsEqnsWithUpdate(eqns, replaceFinalParameter, BackendVariable.daeGlobalKnownVars(shared));
 
         subsyst = BackendDAEUtil.createEqSystem(vars, eqns);
         (subsyst, m, _) = BackendDAEUtil.getIncidenceMatrix(subsyst, BackendDAE.ABSOLUTE(), SOME(funcs));

Compiler/BackEnd/RemoveSimpleEquations.mo

@@ -217,7 +217,7 @@ algorithm
   end for;
 
   outDAE := BackendDAEUtil.setAliasVars(inDAE, BackendVariable.listVar(aliasVarList));
-  outDAE := BackendDAEUtil.setKnownVars(outDAE, BackendVariable.listVar(knownVarList));
+  outDAE := BackendDAEUtil.setDAEGlobalKnownVars(outDAE, BackendVariable.listVar(knownVarList));
 end fixAliasVars;
 
 protected function fixKnownVars "author: lochel
@@ -257,7 +257,7 @@ algorithm
     dae.eqs := eqs::dae.eqs;
   end if;
 
-  dae := BackendDAEUtil.setKnownVars(dae, BackendVariable.listVar(knownVarList));
+  dae := BackendDAEUtil.setDAEGlobalKnownVars(dae, BackendVariable.listVar(knownVarList));
 end fixKnownVars;
 
 protected function fixAliasAndKnownVarsCausal "author: lochel
@@ -302,7 +302,7 @@ algorithm
     end if;
   end for;
   //BackendDump.dumpVarList(knownVarList, "knownVarList out");
-  outDAE := BackendDAEUtil.setKnownVars(outDAE, BackendVariable.listVar(knownVarList));
+  outDAE := BackendDAEUtil.setDAEGlobalKnownVars(outDAE, BackendVariable.listVar(knownVarList));
 end fixAliasAndKnownVarsCausal;
 
 protected function fixAliasVarsCausal2
@@ -1817,7 +1817,7 @@ algorithm
         // alias
         (negated, cra) = aliasExp(exp);
         // get Variables
-        globalKnownVars = BackendVariable.daeKnVars(shared);
+        globalKnownVars = BackendVariable.daeGlobalKnownVars(shared);
         (vars2, ilst2) = BackendVariable.getVar(cra, globalKnownVars);
         // add to Simple Equations List
         (seqns, index, mT) = generateSimpleContainters({var}, false, {i}, false, false, vars2, negated, ilst2, true, false, eqnAttributes, seqns, index, mT);
@@ -2408,7 +2408,7 @@ algorithm
        arrayUpdate(simpleeqnsarr, r, setVisited(mark, s));
        (v as BackendDAE.VAR(varName=cr)) = BackendVariable.getVarAt(iVars, i);
        (replaceable_, replaceble1) = replaceableAlias(v, unReplaceable); // (isreplaceable, isNotInUnreplaceblaHashMap)
-       (vars, shared, isState, eqnslst) = optMoveVarShared(replaceable_, v, i, eqnAttributes, exp, BackendVariable.addKnVarDAE, iMT, iVars, ishared, iEqnslst);
+       (vars, shared, isState, eqnslst) = optMoveVarShared(replaceable_, v, i, eqnAttributes, exp, BackendVariable.addGlobalKnownVarDAE, iMT, iVars, ishared, iEqnslst);
        constExp = Expression.isConstValue(exp);
        // add to replacements if constant
        repl = if replaceable_ and constExp and replaceble1 then BackendVarTransform.addReplacement(iRepl, cr, exp, SOME(BackendVarTransform.skipPreChangeEdgeOperator)) else iRepl;
@@ -2431,7 +2431,7 @@ algorithm
        (v as BackendDAE.VAR(varName=cr)) = BackendVariable.getVarAt(iVars, i);
        exp = if Types.isRealOrSubTypeReal(ComponentReference.crefLastType(cr)) then DAE.RCONST(0.0) else DAE.ICONST(0);
        (replaceable_, replaceble1) = replaceableAlias(v, unReplaceable); // (isreplaceable, isNotInUnreplaceblaHashMap)
-       (vars, shared, isState, eqnslst) = optMoveVarShared(replaceable_, v, i, eqnAttributes, exp, BackendVariable.addKnVarDAE, iMT, iVars, ishared, iEqnslst);
+       (vars, shared, isState, eqnslst) = optMoveVarShared(replaceable_, v, i, eqnAttributes, exp, BackendVariable.addGlobalKnownVarDAE, iMT, iVars, ishared, iEqnslst);
        constExp = Expression.isConstValue(exp);
        // add to replacements if constant
        repl = if replaceable_ and constExp and replaceble1 then BackendVarTransform.addReplacement(iRepl, cr, exp, SOME(BackendVarTransform.skipPreChangeEdgeOperator)) else iRepl;