fixing FMI directional derivatives and model structure

  - enable directional derivatives for fmi 2.0 by default and generation
    of the corresponding symbolic jacobians
  - rewrite the structure for the dependencies and the partial derivatives generation
    adjust C-runtime code generation
  - fixing model structure for output states
  - rename debug flag disableSymbolicLinearization to disableDirectionalDerivatives

Belonging to [master]:
  - #1715
  - OpenModelica/OpenModelica-testsuite#722

Author: Willi Braun

Compiler/BackEnd/BackendDAE.mo

@@ -709,6 +709,7 @@ public constant Integer SymbolicJacobianDIndex = 4;
 public constant String derivativeNamePrefix = "$DERAlias";
 public constant String partialDerivativeNamePrefix = "$pDER";
 public constant String functionDerivativeNamePrefix = "$funDER";
+public constant String outputStateAliasPrefix = "$outputStateAlias_";
 
 public constant String optimizationMayerTermName = "$OMC$objectMayerTerm";
 public constant String optimizationLagrangeTermName = "$OMC$objectLagrangeTerm";

Compiler/BackEnd/BackendDAEUtil.mo

@@ -93,6 +93,7 @@ import ExpressionSimplify;
 import ExpressionSolve;
 import FindZeroCrossings;
 import Flags;
+import FMI;
 import Global;
 import HpcOmEqSystems;
 import IndexReduction;
@@ -1707,6 +1708,53 @@ algorithm
   end match;
 end reduceEqSystem;
 
+public function createAliasVarsForOutputStates
+" creates for every state that is also output an
+  alias variable $outputStateAlias.stateName and
+  the corresponding equation"
+  input BackendDAE.BackendDAE inBDAE;
+  output BackendDAE.BackendDAE outBDAE = inBDAE;
+protected
+  BackendDAE.EqSystems systems, returnSysts = {};
+  BackendDAE.Variables vars;
+  BackendDAE.EquationArray eqs;
+  list<BackendDAE.Var> states;
+  DAE.ComponentRef newCref;
+  BackendDAE.Var newVar;
+  BackendDAE.Equation newEqn;
+algorithm
+  systems := inBDAE.eqs;
+  for system in systems loop
+    eqs  := system.orderedEqs;
+    vars := system.orderedVars;
+    states := BackendVariable.getAllStateVarFromVariables(vars);
+    for v in states loop
+      if BackendVariable.isVarOnTopLevelAndOutput(v) then
+        // generate new output var and add it
+        newCref := ComponentReference.prependStringCref(BackendDAE.outputStateAliasPrefix, BackendVariable.varCref(v));
+        newVar := BackendVariable.copyVarNewName(newCref, v);
+        newVar := BackendVariable.setVarKind(newVar, BackendDAE.VARIABLE());
+        vars := BackendVariable.addVar(newVar, vars);
+
+        //update states to remove the output direction
+        v := BackendVariable.setVarDirection(v, DAE.BIDIR());
+        vars := BackendVariable.addVar(v, vars);
+
+        // generate new equation and add it
+        newEqn := BackendEquation.generateEquation(Expression.crefToExp(newCref), Expression.crefToExp(BackendVariable.varCref(v)), DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_BINDING);
+        eqs := BackendEquation.add(newEqn, eqs);
+      end if;
+    end for;
+    system.orderedVars := vars;
+    system.orderedEqs := eqs;
+    system := BackendDAEUtil.clearEqSyst(system);
+    returnSysts := system::returnSysts;
+  end for;
+  returnSysts := listReverse(returnSysts);
+  outBDAE.eqs := returnSysts;
+  outBDAE := BackendDAEUtil.transformBackendDAE(outBDAE, SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())), NONE(), NONE());
+end createAliasVarsForOutputStates;
+
 protected function translateArrayList
   input Integer inElement;
   input Integer inIndex;
@@ -7436,6 +7484,7 @@ end allPreOptimizationModules;
 protected function allPostOptimizationModules
   "This list contains all back end sim-optimization modules."
   output list<tuple<BackendDAEFunc.optimizationModule, String>> allPostOptimizationModules = {
+    (BackendDAEUtil.createAliasVarsForOutputStates, "createAliasVarsForOutputStates"),
     (BackendInline.lateInlineFunction, "lateInlineFunction"),
     (DynamicOptimization.simplifyConstraints, "simplifyConstraints"),
     (CommonSubExpression.wrapFunctionCalls, "wrapFunctionCalls"),
@@ -8638,6 +8687,17 @@ algorithm
   end match;
 end setSharedSymJacs;
 
+public function getSharedSymJacs
+  input BackendDAE.Shared inShared;
+  output BackendDAE.SymbolicJacobians outSymjacs;
+algorithm
+  outSymjacs := match inShared
+    local
+      BackendDAE.Shared shared;
+    case shared as BackendDAE.SHARED() then shared.symjacs;
+  end match;
+end getSharedSymJacs;
+
 public function setSharedFunctionTree
   input BackendDAE.Shared inShared;
   input DAE.FunctionTree inFunctionTree;

Compiler/BackEnd/BackendVariable.mo

@@ -2318,6 +2318,17 @@ algorithm
   end match;
 end isVarKindVariable;
 
+public function isVarKindState
+  input BackendDAE.VarKind inVarKind;
+  output Boolean result;
+algorithm
+  result :=
+  match (inVarKind)
+    case (BackendDAE.STATE()) then true;
+    else false;
+  end match;
+end isVarKindState;
+
 public function isTopLevelInputOrOutput "author: LP
 
   This function checks if the provided cr is from a var that is on top model

Compiler/BackEnd/Differentiate.mo

@@ -1762,6 +1762,25 @@ algorithm
         (res1, _) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
       then
        (res1, inFunctionTree);
+    /* floor ceil and interger are expanded by the zeroCrossing index, thus they
+       have 2 arguments */
+    case ("floor", _, DAE.CALL_ATTR(ty=tp))
+      equation
+        (res1, _) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
+      then
+       (res1, inFunctionTree);
+
+    case ("ceil", _, DAE.CALL_ATTR(ty=tp))
+      equation
+        (res1, _) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
+      then
+       (res1, inFunctionTree);
+
+    case ("integer", _, DAE.CALL_ATTR(ty=tp))
+      equation
+        (res1, _) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
+      then
+       (res1, inFunctionTree);
 
   end match;
 end differentiateCallExpNArg;

Compiler/BackEnd/SymbolicJacobian.mo

@@ -324,7 +324,7 @@ algorithm
   case(_) equation
     true = Flags.getConfigBool(Flags.GENERATE_SYMBOLIC_LINEARIZATION);
     BackendDAE.DAE(eqs=eqs,shared=shared) = inBackendDAE;
-    (linearModelMatrixes, funcs) = createLinearModelMatrixes(inBackendDAE, Config.acceptOptimicaGrammar(), Flags.isSet(Flags.DIS_SYMJAC_FMI20));
+    (linearModelMatrixes, funcs) = createLinearModelMatrixes(inBackendDAE, Config.acceptOptimicaGrammar());
     shared = BackendDAEUtil.setSharedSymJacs(shared, linearModelMatrixes);
     functionTree = BackendDAEUtil.getFunctions(shared);
     functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
@@ -1582,17 +1582,102 @@ algorithm
   end if;
 end createBipartiteGraph;
 
+public function createFMIModelDerivatives
+"This function genererate the stucture output and the
+ partial derivatives for FMI, which are basically the jacobian matrices.
+ author: wbraun"
+  input BackendDAE.BackendDAE inBackendDAE;
+  output BackendDAE.SymbolicJacobians outJacobianMatrixes = {};
+  output DAE.FunctionTree outFunctionTree;
+protected
+  BackendDAE.BackendDAE backendDAE,emptyBDAE;
+  BackendDAE.EqSystem eqSyst;
+  Option<BackendDAE.SymbolicJacobian> outJacobian;
+
+  list<BackendDAE.Var> varlst, knvarlst, states, inputvars, outputvars, paramvars, indepVars, depVars;
+
+  BackendDAE.Variables v,globalKnownVars,statesarr,inputvarsarr,paramvarsarr,outputvarsarr, depVarsArr;
+
+  BackendDAE.SparsePattern sparsePattern;
+  BackendDAE.SparseColoring sparseColoring;
+
+  DAE.FunctionTree funcs, functionTree;
+
+  BackendDAE.ExtraInfo ei;
+  FCore.Cache cache;
+  FCore.Graph graph;
+algorithm
+try
+  // for now perform on collapsed system
+  backendDAE := BackendDAEUtil.copyBackendDAE(inBackendDAE);
+  backendDAE := BackendDAEOptimize.collapseIndependentBlocks(backendDAE);
+  backendDAE := BackendDAEUtil.transformBackendDAE(backendDAE,SOME((BackendDAE.NO_INDEX_REDUCTION(),BackendDAE.EXACT())),NONE(),NONE());
+
+  // get all variables
+  eqSyst::{} := backendDAE.eqs;
+  v := eqSyst.orderedVars;
+  globalKnownVars := backendDAE.shared.globalKnownVars;
+
+  // prepare all needed variables
+  varlst := BackendVariable.varList(v);
+  knvarlst := BackendVariable.varList(globalKnownVars);
+  states := BackendVariable.getAllStateVarFromVariables(v);
+
+  inputvars := List.select(knvarlst,BackendVariable.isVarOnTopLevelAndInput);
+  outputvars := List.select(varlst, BackendVariable.isVarOnTopLevelAndOutput);
+
+  // independent varibales states + inputs
+  indepVars := listAppend(states, inputvars);
+
+  // dependent varibales der(states) + outputs
+  depVars := listAppend(states, outputvars);
+
+  // Generate sparse pattern for matrices states
+  // prepare more needed variables
+  if Flags.isSet(Flags.DIS_SYMJAC_FMI20) then
+    // empty BackendDAE in case derivates should not calclulated
+    cache := backendDAE.shared.cache;
+    graph := backendDAE.shared.graph;
+    ei := backendDAE.shared.info;
+    emptyBDAE := BackendDAE.DAE({BackendDAEUtil.createEqSystem(BackendVariable.emptyVars(), BackendEquation.emptyEqns())}, BackendDAEUtil.createEmptyShared(BackendDAE.JACOBIAN(), ei, cache, graph));
+
+    (sparsePattern, sparseColoring) := generateSparsePattern(backendDAE, indepVars, depVars);
+    if Flags.isSet(Flags.JAC_DUMP2) then
+      BackendDump.dumpSparsityPattern(sparsePattern, "FMI sparsity");
+    end if;
+    outJacobianMatrixes := (SOME((emptyBDAE,"FMIDER",{},{},{})), sparsePattern, sparseColoring)::outJacobianMatrixes;
+    outFunctionTree := inBackendDAE.shared.functionTree;
+  else
+    // prepare more needed variables
+    paramvars := List.select(knvarlst, BackendVariable.isParam);
+    statesarr := BackendVariable.listVar1(states);
+    inputvarsarr := BackendVariable.listVar1(inputvars);
+    paramvarsarr := BackendVariable.listVar1(paramvars);
+    depVarsArr := BackendVariable.listVar1(depVars);
+
+    (outJacobian, outFunctionTree, sparsePattern, sparseColoring) := generateGenericJacobian(backendDAE,indepVars,statesarr,inputvarsarr,paramvarsarr,depVarsArr,varlst,"FMIDER", Flags.isSet(Flags.DIS_SYMJAC_FMI20));
+    if Flags.isSet(Flags.JAC_DUMP2) then
+      BackendDump.dumpSparsityPattern(sparsePattern, "FMI sparsity");
+    end if;
+    outJacobianMatrixes := (outJacobian, sparsePattern, sparseColoring)::outJacobianMatrixes;
+  end if;
+else
+  Error.addInternalError("function createFMIModelDerivatives failed", sourceInfo());
+  outJacobianMatrixes := {};
+  outFunctionTree := inBackendDAE.shared.functionTree;
+end try;
+end createFMIModelDerivatives;
+
 protected function createLinearModelMatrixes "This function creates the linear model matrices column-wise
   author: wbraun"
   input BackendDAE.BackendDAE inBackendDAE;
   input Boolean useOptimica;
-  input Boolean noGenSymbolicJac;
   output BackendDAE.SymbolicJacobians outJacobianMatrixes;
   output DAE.FunctionTree outFunctionTree;
 
 algorithm
   (outJacobianMatrixes, outFunctionTree) :=
-  match (inBackendDAE, useOptimica, noGenSymbolicJac)
+  match (inBackendDAE, useOptimica)
     local
       BackendDAE.BackendDAE backendDAE,backendDAE2,emptyBDAE;
 
@@ -1616,42 +1701,7 @@ algorithm
       FCore.Cache cache;
       FCore.Graph graph;
 
-    case (backendDAE, false, true)
-      equation
-        backendDAE2 = BackendDAEUtil.copyBackendDAE(backendDAE);
-        backendDAE2 = BackendDAEOptimize.collapseIndependentBlocks(backendDAE2);
-        backendDAE2 = BackendDAEUtil.transformBackendDAE(backendDAE2,SOME((BackendDAE.NO_INDEX_REDUCTION(),BackendDAE.EXACT())),NONE(),NONE());
-        BackendDAE.DAE({BackendDAE.EQSYSTEM(orderedVars = v)}, BackendDAE.SHARED(globalKnownVars = globalKnownVars, functionTree = functionTree, cache=cache, graph=graph, info=ei)) = backendDAE2;
-
-        emptyBDAE = BackendDAE.DAE({BackendDAEUtil.createEqSystem(BackendVariable.emptyVars(), BackendEquation.emptyEqns())}, BackendDAEUtil.createEmptyShared(BackendDAE.JACOBIAN(), ei, cache, graph));
-        // Prepare all needed variables
-        varlst = BackendVariable.varList(v);
-        knvarlst = BackendVariable.varList(globalKnownVars);
-        states = BackendVariable.getAllStateVarFromVariables(v);
-        _ = List.select(knvarlst,BackendVariable.isInput);
-        _ = List.select(knvarlst, BackendVariable.isParam);
-        inputvars2 = List.select(knvarlst,BackendVariable.isVarOnTopLevelAndInput);
-        outputvars = List.select(varlst, BackendVariable.isVarOnTopLevelAndOutput);
-
-        // Generate sparse pattern for matrices A
-        (sparsePattern, sparseColoring) = generateSparsePattern(backendDAE2, states, states);
-        linearModelMatrices = {(SOME((emptyBDAE,"A",{},{},{})), sparsePattern, sparseColoring)};
-
-        // Generate sparse pattern for matrices B
-        (sparsePattern, sparseColoring) = generateSparsePattern(backendDAE2, inputvars2, states);
-        linearModelMatrices = listAppend(linearModelMatrices,{(SOME((emptyBDAE,"B",{},{},{})), sparsePattern, sparseColoring)});
-
-        // Generate sparse pattern for matrices C
-        (sparsePattern, sparseColoring) = generateSparsePattern(backendDAE2, states, outputvars);
-        linearModelMatrices = listAppend(linearModelMatrices,{(SOME((emptyBDAE,"C",{},{},{})), sparsePattern, sparseColoring)});
-
-        // Generate sparse pattern for matrices D
-        (sparsePattern, sparseColoring) = generateSparsePattern(backendDAE2, inputvars2, outputvars);
-        linearModelMatrices = listAppend(linearModelMatrices,{(SOME((emptyBDAE,"D",{},{},{})), sparsePattern, sparseColoring)});
-      then
-        (linearModelMatrices, functionTree);
-
-    case (backendDAE, false, _)
+    case (backendDAE, false)
       equation
         backendDAE2 = BackendDAEUtil.copyBackendDAE(backendDAE);
         backendDAE2 = BackendDAEOptimize.collapseIndependentBlocks(backendDAE2);
@@ -1709,7 +1759,7 @@ algorithm
       then
         (linearModelMatrices, functionTree);
 
-    case (backendDAE, true, _) //  created linear model (matrixes) for optimization
+    case (backendDAE, true) //  created linear model (matrixes) for optimization
       equation
         // A := der(x)
         // B := {der(x), con(x), L(x)}

Compiler/SimCode/SimCode.mo

@@ -487,6 +487,7 @@ public uniontype FmiModelStructure
   record FMIMODELSTRUCTURE
     FmiOutputs fmiOutputs;
     FmiDerivatives fmiDerivatives;
+    Option<JacobianMatrix> continuousPartialDerivatives;
     FmiDiscreteStates fmiDiscreteStates;
     FmiInitialUnknowns fmiInitialUnknowns;
   end FMIMODELSTRUCTURE;