enable discrete vars in symbolic jacobian

Author: Willi Braun

Compiler/BackEnd/Differentiate.mo

@@ -781,19 +781,17 @@ end differentiateExp;
 
       case {} then (listReverse(inStmtsAccum), inFunctionTree);
 
-      // skip discrete statements
-      case currStatement::restStatements guard( isDiscreteAssignStatment(currStatement) )
-        equation
-          derivedStatements1 = currStatement::inStmtsAccum;
-          (derivedStatements2, functions) = differentiateStatements(restStatements, inDiffwrtCref, inInputData, inDiffType, derivedStatements1, inFunctionTree, maxIter);
-        then (derivedStatements2, functions);
-
       case (currStatement as DAE.STMT_ASSIGN(type_=type_, exp1=lhs, exp=rhs, source=source))::restStatements
         equation
           (derivedLHS, functions) = differentiateExp(lhs, inDiffwrtCref, inInputData, inDiffType, inFunctionTree, maxIter);
           (derivedRHS, functions) = differentiateExp(rhs, inDiffwrtCref, inInputData, inDiffType, functions, maxIter);
           (derivedRHS,_) = ExpressionSimplify.simplify(derivedRHS);
-          derivedStatements1 = {DAE.STMT_ASSIGN(type_, derivedLHS, derivedRHS, source), currStatement};
+          /* if assigment is empty remove derived assignment */
+          if (Expression.isZero(derivedLHS)) then
+            derivedStatements1 = {currStatement};
+          else
+            derivedStatements1 = {DAE.STMT_ASSIGN(type_, derivedLHS, derivedRHS, source), currStatement};
+          end if;
           derivedStatements1 = listAppend(derivedStatements1, inStmtsAccum);
           (derivedStatements2, functions) = differentiateStatements(restStatements, inDiffwrtCref, inInputData, inDiffType, derivedStatements1, functions, maxIter);
         then (derivedStatements2, functions);
@@ -825,7 +823,7 @@ end differentiateExp;
         equation
           cref = ComponentReference.makeCrefIdent(ident, DAE.T_INTEGER_DEFAULT, {});
           controlVar = BackendDAE.VAR(cref, BackendDAE.DISCRETE(), DAE.BIDIR(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.BCONST(false), NONE(), DAE.NON_CONNECTOR(), DAE.NOT_INNER_OUTER(), false);
-          inputData = addAllVars({controlVar}, inInputData);
+          inputData = addGlobalVars({controlVar}, inInputData);
           (derivedStatements1, functions) = differentiateStatements(statementLst, inDiffwrtCref, inputData, inDiffType, {}, inFunctionTree, maxIter);
 
           derivedStatements1 = {DAE.STMT_FOR(type_, iterIsArray, ident, index, exp, derivedStatements1, source)};
@@ -1110,7 +1108,7 @@ algorithm
         (zero, inFunctionTree);
 
     // d(discrete)/d(x) = 0
-    case ((DAE.CREF(componentRef = cr,ty = tp)), _, BackendDAE.DIFFINPUTDATA(allVars=SOME(timevars)), _, _)
+    case ((DAE.CREF(componentRef = cr,ty = tp)), _, BackendDAE.DIFFINPUTDATA(allVars=SOME(timevars)), BackendDAE.DIFFERENTIATION_TIME(), _)
       equation
         (BackendDAE.VAR(varKind = kind),_) = BackendVariable.getVarSingle(cr, timevars);
         //print("\nExp-Cref\n known vars: " + ComponentReference.printComponentRefStr(cr));
@@ -1466,9 +1464,8 @@ algorithm
 
     case ("pre",_) equation
       tp = Expression.typeof(exp);
-      (exp_1, funcs) = differentiateExp(exp, inDiffwrtCref, inInputData,inDiffType,inFuncs, maxIter);
-      exp_2 = Expression.makePureBuiltinCall("pre", {exp_1}, tp);
-    then (exp_2, inFuncs);
+      exp_1 = Expression.makeZeroExpression(Expression.arrayDimension(tp));
+    then (exp_1, inFuncs);
 
     case ("previous",_) equation
       tp = Expression.typeof(exp);
@@ -1786,6 +1783,12 @@ algorithm
       then
         (res1, funcs);
 
+    case ("sample", _, DAE.CALL_ATTR(ty=tp))
+      equation
+        (res1, _) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
+      then
+       (res1, inFunctionTree);
+
   end match;
 end differentiateCallExpNArg;
 
@@ -2578,6 +2581,11 @@ algorithm
       //print("Function diff: statemeants");
       (derbodyStmts, functions) = differentiateStatements(listReverse(bodyStmts), inDiffwrtCref, inputData, BackendDAE.DIFFERENTIATION_FUNCTION(), {}, functions, maxIter);
 
+      if Flags.isSet(Flags.DEBUG_DIFFERENTIATION_VERBOSE) then
+        funstring = DAEDump.ppStmtListStr(derbodyStmts, 0);
+        print("### Differentiate differentiateFunctionCallPartial stmts: \n" + funstring + "\n\n");
+      end if;
+
       // create function and add it to function tree
       dpath = Util.getOptionOrDefault(dpathOption, Absyn.stringPath("$DER" + funcname));
 
@@ -3003,6 +3011,35 @@ algorithm
   end match;
 end addAllVars;
 
+protected function addGlobalVars
+  input list<BackendDAE.Var> inVarsLst;
+  input BackendDAE.DifferentiateInputData inDiffData;
+  output BackendDAE.DifferentiateInputData outDiffData;
+algorithm
+  outDiffData := match(inVarsLst, inDiffData)
+    local
+      Option<BackendDAE.Variables> depVars, allVars, indepVars;
+      BackendDAE.Variables glVars;
+      list<BackendDAE.Var> algVars;
+      list< .DAE.ComponentRef> diffCrefs;
+      Option<String> diffname;
+
+    case ({}, _)
+    then inDiffData;
+
+    case (_, BackendDAE.DIFFINPUTDATA(indepVars, depVars, SOME(glVars), allVars, algVars, diffCrefs, diffname)) equation
+      glVars = BackendVariable.addVars(inVarsLst, glVars);
+      //BackendDump.dumpVariables(allVars, "indep Vars: ");
+    then BackendDAE.DIFFINPUTDATA(indepVars, depVars, SOME(glVars), allVars, algVars, diffCrefs, diffname);
+
+    case (_, BackendDAE.DIFFINPUTDATA(indepVars, depVars, NONE(), allVars, algVars, diffCrefs, diffname)) equation
+      glVars = BackendVariable.listVar(inVarsLst);
+      //BackendDump.dumpVariables(allVars, "indep Vars: ");
+    then BackendDAE.DIFFINPUTDATA(indepVars, depVars, SOME(glVars), allVars, algVars, diffCrefs, diffname);
+
+  end match;
+end addGlobalVars;
+
 protected function lowerVarsElementVars
   input list<DAE.Element> inElementLstVars;
   input DAE.FunctionTree functions;
@@ -3040,7 +3077,6 @@ algorithm
   end try;
 end addElementVars2Dep;
 
-
 protected function dumpInputData
   input BackendDAE.DifferentiateInputData inDiffData;
 protected

Compiler/BackEnd/SymbolicJacobian.mo

@@ -2123,11 +2123,6 @@ algorithm
     case({}, _, _, _, _, _)
     then listReverse(iVars);
 
-    // skip for dicrete variable
-    case(BackendDAE.VAR(varKind=BackendDAE.DISCRETE())::restVar, cref, _, _, _, _)
-     then
-       createAllDiffedVarsWork(restVar,cref,inAllVars,inIndex, inMatrixName,iVars);
-
      case(BackendDAE.VAR(varName=currVar,varKind=BackendDAE.STATE())::restVar, cref, _, index, _, _) algorithm
        try
         (_, _) := BackendVariable.getVarSingle(currVar, inAllVars);
@@ -2159,7 +2154,7 @@ algorithm
   end match;
 end createAllDiffedVarsWork;
 
-protected function deriveAll "author: lochel"
+protected function deriveAll
   input list<BackendDAE.Equation> inEquations;
   input list<Integer> ass2;
   input DAE.ComponentRef inDiffCref;
@@ -2169,7 +2164,7 @@ protected function deriveAll "author: lochel"
   output DAE.FunctionTree outFunctions = inFunctions;
 protected
   BackendDAE.Variables allVars;
-  list<BackendDAE.Equation> currDerivedEquations;
+  BackendDAE.Equation currDerivedEquation;
   list<BackendDAE.Var> solvedvars;
   list<Integer> ass2_1 = ass2, solvedfor;
   Boolean b;
@@ -2183,17 +2178,11 @@ algorithm
         print("\n");
       end if;
 
-      // filter discrete equataions
-      (solvedfor,ass2_1) := List.split(ass2_1, BackendEquation.equationSize(currEquation));
-      solvedvars := List.map1r(solvedfor,BackendVariable.getVarAt, allVars);
-      b := List.mapAllValueBool(solvedvars, BackendVariable.isVarDiscrete, true);
-      b := b or BackendEquation.isWhenEquation(currEquation);
-
-      (currDerivedEquations, outFunctions) := deriveAllHelper(b, currEquation, inDiffCref, inDiffData, outFunctions);
-      outDerivedEquations := listAppend(currDerivedEquations, outDerivedEquations);
+      (currDerivedEquation, outFunctions) := Differentiate.differentiateEquation(currEquation, inDiffCref, inDiffData, BackendDAE.GENERIC_GRADIENT(), outFunctions);
+      outDerivedEquations := currDerivedEquation::outDerivedEquations;
 
       if Flags.isSet(Flags.JAC_DUMP_EQN) then
-        BackendDump.printEquationList(currDerivedEquations);
+        BackendDump.printEquationList(outDerivedEquations);
         print("\n");
       end if;
     end for;
@@ -2206,36 +2195,6 @@ algorithm
   end try;
 end deriveAll;
 
-protected function deriveAllHelper "author: wbraun"
-  input Boolean isDiscrete;
-  input BackendDAE.Equation inEquation;
-  input DAE.ComponentRef inDiffCref;
-  input BackendDAE.DifferentiateInputData inDiffData;
-  input DAE.FunctionTree inFunctions;
-  output list<BackendDAE.Equation> outDerivedEquations;
-  output DAE.FunctionTree outFunctions;
-algorithm
-  (outDerivedEquations, outFunctions) :=
-  match (isDiscrete)
-    local
-      BackendDAE.Equation derEquation;
-      DAE.FunctionTree functions;
-      list<DAE.ComponentRef> vars;
-      BackendDAE.Variables allVars, paramVars, stateVars, globalKnownVars;
-      list<Integer> ass2_1, solvedfor;
-
-    case (true) equation
-      if Flags.isSet(Flags.JAC_WARNINGS) then
-        print("BackendDAEOptimize.derive: discrete equation has been removed.\n");
-      end if;
-    then ({}, inFunctions);
-
-    case (false) equation
-      (derEquation, functions) = Differentiate.differentiateEquation(inEquation, inDiffCref, inDiffData, BackendDAE.GENERIC_GRADIENT(), inFunctions);
-    then ({derEquation}, functions);
-  end match;
-end deriveAllHelper;
-
 public function getJacobianMatrixbyName
   input BackendDAE.SymbolicJacobians injacobianMatrixes;
   input String inJacobianName;

Compiler/FrontEnd/DAEDump.mo

@@ -1792,7 +1792,7 @@ algorithm
   end match;
 end ppStmtList;
 
-protected function ppStmtListStr "
+public function ppStmtListStr "
   Helper function to pp_stmt_str
 "
   input list<DAE.Statement> inAlgorithmStatementLst;

Compiler/SimCode/SimCodeUtil.mo

@@ -4905,12 +4905,7 @@ algorithm
 
     case({}, _, _, _, _, _) then listReverse(iVars);
 
-    // skip for dicrete variable
-    case(BackendDAE.VAR(varKind=BackendDAE.DISCRETE())::restVar, cref, _, _, _, _) equation
-     then
-       createAllDiffedSimVars(restVar, cref, inAllVars, inIndex, inMatrixName, iVars);
-
-     case(BackendDAE.VAR(varName=currVar, varKind=varkind, values = dae_var_attr)::restVar, cref, _, index, _, _) algorithm
+    case(BackendDAE.VAR(varName=currVar, varKind=varkind, values = dae_var_attr)::restVar, cref, _, index, _, _) algorithm
       try
         BackendVariable.getVarSingle(currVar, inAllVars);
         r1 := match (varkind)