diff --git a/OMCompiler/Compiler/BackEnd/BackendVariable.mo b/OMCompiler/Compiler/BackEnd/BackendVariable.mo index 3f2e6052cb9..84a193ce6b7 100644 --- a/OMCompiler/Compiler/BackEnd/BackendVariable.mo +++ b/OMCompiler/Compiler/BackEnd/BackendVariable.mo @@ -1540,6 +1540,16 @@ algorithm end match; end isOutputVar; +public function isRealVar "Return true if variable is type Real" + input BackendDAE.Var inVar; + output Boolean outBoolean; +algorithm + outBoolean := match (inVar) + case (BackendDAE.VAR(varType = DAE.T_REAL())) then true; + else false; + end match; +end isRealVar; + public function isRealOutputVar "Return true if variable is declared as output and type is Real. Note that the output attribute sticks with a variable even if it is originating from a sub component, which is not the case for Dymola." diff --git a/OMCompiler/Compiler/BackEnd/SymbolicJacobian.mo b/OMCompiler/Compiler/BackEnd/SymbolicJacobian.mo index 87e68185178..57a29b3eca9 100644 --- a/OMCompiler/Compiler/BackEnd/SymbolicJacobian.mo +++ b/OMCompiler/Compiler/BackEnd/SymbolicJacobian.mo @@ -1769,6 +1769,153 @@ else end try; end createFMIModelDerivatives; +public function createFMIModelDerivativesForInitialization +"This function genererate the stucture output and the + partial derivatives for FMI, which are basically the jacobian matrices." + input BackendDAE.BackendDAE initDAE; + input BackendDAE.BackendDAE simDAE; + input list depVars; + input list indepVars; + input BackendDAE.Variables orderedVars; + input BackendDAE.SparsePattern sparsePattern_; + input BackendDAE.SparseColoring sparseColoring_; + output BackendDAE.SymbolicJacobians outJacobianMatrixes = {}; +protected + BackendDAE.BackendDAE backendDAE, backendDAE_1, emptyBDAE; + BackendDAE.EqSystem eqSyst, currentSystem; + Option outJacobian; + list varlst, knvarlst, states, inputvars, outputvars, paramvars, indepVars_1, depVars_1; + 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; + BackendDAE.EquationArray newEqArray, newOrderedEquationArray; + BackendDAE.Shared shared; + DAE.Exp lhs, rhs; + BackendDAE.Equation eqn; + list eqlistToRemove; + DAE.ComponentRef cr; + list crefsVarsToRemove; + BackendDAE.Variables newVars; +algorithm +try + + backendDAE_1 := BackendDAEUtil.copyBackendDAE(initDAE); + backendDAE_1 := BackendDAEOptimize.collapseIndependentBlocks(backendDAE_1); + + //BackendDump.printBackendDAE(backendDAE_1); + //BackendDump.dumpVariables(simDAE.shared.globalKnownVars, "check global vars"); + + /* add the calculated parameter equations here which does not have constant binding + parameter Real x = 10; + Real m = x; */ + BackendDAE.DAE(currentSystem::{}, shared) := backendDAE_1; + for var in depVars loop + if BackendVariable.isParam(var) and not BackendVariable.varHasConstantBindExp(var) then + //print("\n PARAM_CHECK: " + ComponentReference.printComponentRefStr(var.varName)); + lhs := BackendVariable.varExp(var); + rhs := BackendVariable.varBindExpStartValueNoFail(var) "bindings are optional"; + eqn := BackendDAE.EQUATION(lhs, rhs, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_BINDING); + //BackendDump.printEquation(eqn); + BackendEquation.add(eqn, currentSystem.orderedEqs); + if not BackendVariable.containsCref(var.varName, currentSystem.orderedVars) then + currentSystem := BackendVariable.addVarDAE(BackendVariable.makeVar(var.varName), currentSystem); + end if; + end if; + end for; + + // remove equations and vars of the form a = $START.b from Eqsyst to simplify jacobian calculations + newOrderedEquationArray := BackendEquation.emptyEqns(); + crefsVarsToRemove:= {}; + for eq in BackendEquation.equationList(currentSystem.orderedEqs) loop + if not BackendEquation.isAlgorithm(eq) then + lhs := BackendEquation.getEquationLHS(eq); + rhs := BackendEquation.getEquationRHS(eq); + // print("\nlhs :" + anyString(lhs)); + // print("\nrhs :" + anyString(rhs)); + // BackendDump.printEquation(eq); + if Expression.isExpCref(lhs) and Expression.isExpCref(rhs) and (ComponentReference.isStartCref(Expression.expCref(rhs)) and ComponentReference.crefEqual(ComponentReference.popCref(Expression.expCref(rhs)), Expression.expCref(lhs))) then + crefsVarsToRemove := Expression.expCref(lhs) :: crefsVarsToRemove; + else + BackendEquation.add(eq, newOrderedEquationArray); + end if; + else + BackendEquation.add(eq, newOrderedEquationArray); + end if; + end for; + + newVars := BackendVariable.emptyVars(); + for var in BackendVariable.varList(currentSystem.orderedVars) loop + if not listMember(var.varName, crefsVarsToRemove) then + newVars := BackendVariable.addVar(var, newVars); + end if; + end for; + + currentSystem := BackendDAEUtil.setEqSystEqs(currentSystem, newOrderedEquationArray); + currentSystem := BackendDAEUtil.setEqSystVars(currentSystem, newVars); + + // put the shared globalknown Vars + // for var in BackendVariable.varList(simDAE.shared.globalKnownVars) loop + // if not BackendVariable.containsCref(var.varName, currentSystem.orderedVars) then + // shared := BackendVariable.addGlobalKnownVarDAE(var, shared); + // end if; + // end for; + + + backendDAE_1 := BackendDAE.DAE({currentSystem}, shared); + backendDAE_1 := BackendDAEUtil.transformBackendDAE(backendDAE_1, SOME((BackendDAE.NO_INDEX_REDUCTION(),BackendDAE.EXACT())),NONE(),NONE()); + + //BackendDump.printBackendDAE(backendDAE_1); + + //prepare simulation DAE + backendDAE := BackendDAEUtil.copyBackendDAE(simDAE); + backendDAE := BackendDAEOptimize.collapseIndependentBlocks(backendDAE); + + eqSyst::{} := backendDAE.eqs; + v := eqSyst.orderedVars; + // get state var from simulation DAE + states := if Config.languageStandardAtLeast(Config.LanguageStandard.'3.3') then + BackendVariable.getAllClockedStatesFromVariables(v) else {}; + states := listAppend(BackendVariable.getAllStateVarFromVariables(v), states); + + // prepare all needed variables from initialization DAE + varlst := BackendVariable.varList(currentSystem.orderedVars); + knvarlst := BackendVariable.varList(simDAE.shared.globalKnownVars); + //BackendDump.dumpVarList(knvarlst, "shared simulation DAE"); + inputvars := List.select(knvarlst, BackendVariable.isVarOnTopLevelAndInput); + + // Generate empty jacobian martices + if Flags.isSet(Flags.DIS_SYMJAC_FMI20) then + cache := initDAE.shared.cache; + graph := initDAE.shared.graph; + ei := initDAE.shared.info; + emptyBDAE := BackendDAE.DAE({BackendDAEUtil.createEqSystem(BackendVariable.emptyVars(), BackendEquation.emptyEqns())}, BackendDAEUtil.createEmptyShared(BackendDAE.JACOBIAN(), ei, cache, graph)); + outJacobianMatrixes := (SOME((emptyBDAE,"FMIDERINIT",{},{},{}, {})), BackendDAE.emptySparsePattern, {})::outJacobianMatrixes; + 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, _, _) := generateGenericJacobian(backendDAE_1, indepVars, BackendVariable.emptyVars(), BackendVariable.emptyVars(), BackendVariable.emptyVars(), depVarsArr, depVars, "FMIDERINIT", Flags.isSet(Flags.DIS_SYMJAC_FMI20)); + (outJacobian, _, _, _) := generateGenericJacobian(backendDAE_1, indepVars, statesarr, inputvarsarr, paramvarsarr, depVarsArr, varlst, "FMIDERINIT", 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 createFMIModelDerivativesForInitialization failed", sourceInfo()); + outJacobianMatrixes := {}; +end try; +end createFMIModelDerivativesForInitialization; + protected function createLinearModelMatrixes "This function creates the linear model matrices column-wise author: wbraun" input BackendDAE.BackendDAE inBackendDAE; @@ -1979,7 +2126,9 @@ algorithm outJacobian := NONE(); end if; // generate sparse pattern - (outSparsePattern,outSparseColoring) := generateSparsePattern(inBackendDAE, inDiffVars, BackendVariable.varList(inDifferentiatedVars)); + if (not stringEq(inName, "FMIDERINIT")) then + (outSparsePattern,outSparseColoring) := generateSparsePattern(inBackendDAE, inDiffVars, BackendVariable.varList(inDifferentiatedVars)); + end if; else fail(); end try; diff --git a/OMCompiler/Compiler/FrontEnd/Expression.mo b/OMCompiler/Compiler/FrontEnd/Expression.mo index 1b418b5aa22..6106d936ae4 100644 --- a/OMCompiler/Compiler/FrontEnd/Expression.mo +++ b/OMCompiler/Compiler/FrontEnd/Expression.mo @@ -9690,6 +9690,17 @@ algorithm outBoolean:= expContains(inExp2,inExp1); end containsExp; +public function isExpCref +"Returns true if expression is a componentRef" + input DAE.Exp e; + output Boolean res; +algorithm + res := match(e) + case(DAE.CREF(_,_)) then true; + else false; + end match; +end isExpCref; + public function isExpCrefOrIfExp "Returns true if expression is a componentRef or an if expression" input DAE.Exp e; diff --git a/OMCompiler/Compiler/SimCode/SimCode.mo b/OMCompiler/Compiler/SimCode/SimCode.mo index ca0d0ddd11e..cd4bd9a0455 100644 --- a/OMCompiler/Compiler/SimCode/SimCode.mo +++ b/OMCompiler/Compiler/SimCode/SimCode.mo @@ -631,6 +631,8 @@ end FmiDiscreteStates; public uniontype FmiInitialUnknowns record FMIINITIALUNKNOWNS list fmiUnknownsList; + list> sortedUnknownCrefs "use the sorted crefs to get the ValueReference of unknowns"; + list> sortedknownCrefs "use the sorted crefs to get the ValueReference of knowns"; end FMIINITIALUNKNOWNS; end FmiInitialUnknowns; @@ -639,6 +641,7 @@ public uniontype FmiModelStructure FmiOutputs fmiOutputs; FmiDerivatives fmiDerivatives; Option continuousPartialDerivatives; + Option initialPartialDerivatives; FmiDiscreteStates fmiDiscreteStates; FmiInitialUnknowns fmiInitialUnknowns; end FMIMODELSTRUCTURE; diff --git a/OMCompiler/Compiler/SimCode/SimCodeUtil.mo b/OMCompiler/Compiler/SimCode/SimCodeUtil.mo index 709133652d2..a130124936b 100644 --- a/OMCompiler/Compiler/SimCode/SimCodeUtil.mo +++ b/OMCompiler/Compiler/SimCode/SimCodeUtil.mo @@ -246,7 +246,7 @@ protected list constraints; list lits; list clockedPartitions; - list LinearMatrices, SymbolicJacs, SymbolicJacsTemp, SymbolicJacsStateSelect, SymbolicJacsStateSelectInternal, SymbolicJacsNLS, SymbolicJacsFMI={},SymbolicJacsdatarecon={}; + list LinearMatrices, SymbolicJacs, SymbolicJacsTemp, SymbolicJacsStateSelect, SymbolicJacsStateSelectInternal, SymbolicJacsNLS, SymbolicJacsFMI={}, SymbolicJacsFMIINIT={}, SymbolicJacsdatarecon={}; list algorithmAndEquationAsserts; list localKnownVars; list allEquations; @@ -5261,6 +5261,47 @@ algorithm end if; end makeTmpRealSimCodeVar; +protected function sortInitialUnknowsSimVars + "Sorts the crefs, according to FMI-INDEX" + input list inSimVars; + output list> sortedCrefs = {}; +protected + DAE.ComponentRef cref; + list> test; + list> unsortedCrefs={}; + Integer index; +algorithm + // get the FMIINDEX of the vars + for var in inSimVars loop + if isRealInput(var) then + unsortedCrefs := (getVariableFMIIndex(var), var.name) :: unsortedCrefs; + end if; + end for; + + // sort the crefs and set the index which will be used by fmi2GetDirectionalDerivative() to get the partial derivatives + index := 0; + for i in List.sort(unsortedCrefs, Util.compareTupleIntGt) loop + (_, cref) := i; + sortedCrefs := (index, cref) :: sortedCrefs; + index := index + 1; + end for; + sortedCrefs := listReverse(sortedCrefs); + //dumpSortedInitialUnknownCrefs(sortedCrefs); +end sortInitialUnknowsSimVars; + +protected function dumpSortedInitialUnknownCrefs + input list> sortedCrefs; +protected + DAE.ComponentRef cref; + Integer index; +algorithm + for i in sortedCrefs loop + (index, cref) := i; + print("\nindex :" + intString(index) + "=>" + ComponentReference.printComponentRefStr(cref)); + end for; + print("\n*********"); +end dumpSortedInitialUnknownCrefs; + protected function sortSparsePattern "Sorts the indices and dependencies for the modelStructure section in modeldescription.xml." input list inSimVars; @@ -9626,7 +9667,7 @@ algorithm and isFixed; caus = getCausality(dlowVar, vars, isValueChangeable); variability = SimCodeVar.FIXED(); // PARAMETERS() - initial_ = setInitialAttribute(dlowVar, variability, caus, isFixed, iterationVars, aliasvar); + initial_ = setInitialAttribute(dlowVar, variability, caus, isFixed, iterationVars, aliasvar, vars); initVal = updateStartValue(dlowVar, initVal, initial_, caus); then SimCodeVar.SIMVAR(cr, kind, commentStr, unit, displayUnit, -1 /* use -1 to get an error in simulation if something failed */, @@ -9666,7 +9707,7 @@ algorithm isValueChangeable = BackendVariable.varHasConstantStartExp(dlowVar); caus = getCausality(dlowVar, vars, isValueChangeable); variability = SimCodeVar.CONTINUOUS(); // state() should be CONTINUOUS - initial_ = setInitialAttribute(dlowVar, variability, caus, isFixed, iterationVars, aliasvar); + initial_ = setInitialAttribute(dlowVar, variability, caus, isFixed, iterationVars, aliasvar, vars); initVal = updateStartValue(dlowVar, initVal, initial_, caus); then SimCodeVar.SIMVAR(cr, kind, commentStr, unit, displayUnit, -1 /* use -1 to get an error in simulation if something failed */, @@ -9707,7 +9748,7 @@ algorithm isValueChangeable = match dir case DAE.INPUT() then true; else false; end match; caus = getCausality(dlowVar, vars, isValueChangeable); variability = getVariabilityAttribute(dlowVar); - initial_ = setInitialAttribute(dlowVar, variability, caus, isFixed, iterationVars, aliasvar); + initial_ = setInitialAttribute(dlowVar, variability, caus, isFixed, iterationVars, aliasvar, vars); initVal = updateStartValue(dlowVar, initVal, initial_, caus); then SimCodeVar.SIMVAR(cr, kind, commentStr, unit, displayUnit, -1 /* use -1 to get an error in simulation if something failed */, @@ -9748,6 +9789,7 @@ protected function setInitialAttribute input Boolean isFixed; input list iterationVars; input SimCodeVar.AliasVariable aliasvar; + input BackendDAE.Variables globalknownVars; output SimCodeVar.Initial initial_; algorithm initial_ := match (variability, causality) @@ -13511,24 +13553,27 @@ public function createFMIModelStructure output list symJacs = {}; output Integer uniqueEqIndex = inUniqueEqIndex; protected - BackendDAE.SparsePatternCrefs spTA, spTB; + BackendDAE.SparsePatternCrefs spTA, spTB, spTA1, spTB1; SimCode.SparsityPattern sparseInts; list allUnknowns, derivatives, outputs, discreteStates, allInitialUnknowns; list varsA, varsB, varsC, varsD, clockedStates, allOutputVars, allParamVars, tmpInitialUnknowns; - list diffCrefsA, diffedCrefsA, derdiffCrefsA; + list diffCrefsA, diffCrefsA1, diffedCrefsA, diffedCrefsA1, derdiffCrefsA; list diffCrefsB, diffedCrefsB; DoubleEnded.MutableList delst; SimCode.VarInfo varInfo; - Option optcontPartDer; - BackendDAE.SparsePattern spPattern; - BackendDAE.SparseColoring spColors; - BackendDAE.SymbolicJacobians contPartDer; - SimCode.JacobianMatrix contSimJac; - Option contPartSimDer; + Option optcontPartDer, optinitialPartDer; + BackendDAE.SparsePattern spPattern, spPattern1; + BackendDAE.SparseColoring spColors, spColors1; + BackendDAE.SymbolicJacobians contPartDer, initPartDer; + SimCode.JacobianMatrix contSimJac, initSimJac; + Option contPartSimDer, initPartSimDer = NONE(); list tempvars; SimCodeVar.SimVars vars; SimCode.HashTableCrefToSimVar crefSimVarHT; list intLst; + BackendDAE.SymbolicJacobians fmiDerInit = {}; + list symJacsInit={}, symJacFMIINIT={}; + list> sortedUnknownCrefs = {}, sortedknownCrefs = {}; algorithm try //print("Start creating createFMIModelStructure\n"); @@ -13605,19 +13650,39 @@ algorithm // get FMI initialUnknowns list with dependencies if not listEmpty(tmpInitialUnknowns) then - allInitialUnknowns := getFmiInitialUnknowns(inInitDAE, inSimDAE, crefSimVarHT, tmpInitialUnknowns); + (allInitialUnknowns, fmiDerInit, sortedUnknownCrefs, sortedknownCrefs) := getFmiInitialUnknowns(inInitDAE, inSimDAE, crefSimVarHT, tmpInitialUnknowns); else allInitialUnknowns := {}; end if; + // get jacobian matrix FMIDERINT + if not listEmpty(fmiDerInit) then + SOME((optinitialPartDer, spPattern1 as (_, spTA1, (diffCrefsA1, diffedCrefsA1),_), spColors1)) := SymbolicJacobian.getJacobianMatrixbyName(fmiDerInit, "FMIDERINIT"); + // partial derivatives for fmu's during enter_initialization_mode and exit_initialization_mode + if not checkForEmptyBDAE(optinitialPartDer) then + initPartDer := {(optinitialPartDer,spPattern1,spColors1)}; + ({initSimJac}, uniqueEqIndex) := createSymbolicJacobianssSimCode(initPartDer, crefSimVarHT, uniqueEqIndex, {"FMIDERINIT"}, {}); + // collect algebraic loops and symjacs for FMIDer + ({initSimJac}, _, symJacsInit) := addAlgebraicLoopsModelInfoSymJacs({initSimJac}, inModelInfo); + initPartSimDer := SOME(initSimJac); + // set partition index to number of clocks (max index) for now + // TODO: use actual clock indices to support multirate systems + symJacFMIINIT := {rewriteJacPartIdx(initSimJac, inModelInfo.nSubClocks)}; + // append the jacobian matrix of initDAE with simDAE + symJacFMI := listAppend(symJacFMIINIT, symJacFMI); + symJacs := listAppend(symJacsInit, symJacs); + end if; + end if; + outFmiModelStructure := SOME( SimCode.FMIMODELSTRUCTURE( SimCode.FMIOUTPUTS(outputs), SimCode.FMIDERIVATIVES(derivatives), contPartSimDer, + initPartSimDer, SimCode.FMIDISCRETESTATES(discreteStates), - SimCode.FMIINITIALUNKNOWNS(allInitialUnknowns))); + SimCode.FMIINITIALUNKNOWNS(allInitialUnknowns, sortedUnknownCrefs, sortedknownCrefs))); else // create empty model structure try @@ -13636,15 +13701,16 @@ else for v in getScalarVars(clockedStates)); contPartSimDer := NONE(); - + initPartSimDer := NONE(); outFmiModelStructure := SOME( SimCode.FMIMODELSTRUCTURE( SimCode.FMIOUTPUTS(outputs), SimCode.FMIDERIVATIVES(derivatives), contPartSimDer, + initPartSimDer, SimCode.FMIDISCRETESTATES(discreteStates), - SimCode.FMIINITIALUNKNOWNS({}))); + SimCode.FMIINITIALUNKNOWNS({}, {}, {}))); else Error.addInternalError("SimCodeUtil.createFMIModelStructure failed", sourceInfo()); fail(); @@ -13724,16 +13790,22 @@ protected function getFmiInitialUnknowns input SimCode.HashTableCrefToSimVar crefSimVarHT; input list initialUnknownList; output list outFmiUnknownlist; + output BackendDAE.SymbolicJacobians fmiDerInit = {} "partial derivative of initDAE"; + output list> sortedUnknownCrefs = {} "sorted crefs of unknowns"; + output list> sortedknownCrefs = {} "sorted crefs of knowns"; protected - list initialUnknownCrefs, indepCrefs, depCrefs; - BackendDAE.BackendDAE tmpBDAE; - list orderedVars, indepVars, depVars; + list initialUnknownCrefs, indepCrefs, depCrefs, crefs; + DAE.ComponentRef cref; + BackendDAE.BackendDAE tmpBDAE, tmpBDAE1; + list orderedVars, indepVars, depVars, fmiDerInitIndepVars, fmiDerInitDepVars, stateVars; BackendDAE.SparsePattern sparsePattern; + BackendDAE.SparseColoring sparseColoring; BackendDAE.SparsePatternCrefs rowspt; SimCode.SparsityPattern sparseInts; list vars1, vars2; BackendDAE.Shared shared; - BackendDAE.EqSystem currentSystem; + BackendDAE.EqSystem currentSystem, currentSystemSimDAE; + BackendDAE.EqSystems eqs; DAE.Exp lhs, rhs; BackendDAE.Equation eqn; String strMatchingAlgorithm, strIndexReductionMethod; @@ -13755,6 +13827,7 @@ algorithm BackendDump.dumpVariables(currentSystem.orderedVars,"orderedVariables"); BackendDump.dumpEquationArray(currentSystem.orderedEqs,"orderedEquation"); BackendDump.dumpVariables(shared.globalKnownVars,"globalknownVars"); + BackendDump.dumpVariables(inSimDAE.shared.globalKnownVars,"SimulationGlobalknownVars"); end if; // traverse the simulation DAE globalknownVars and update the initialization DAE with new equations and vars @@ -13805,8 +13878,11 @@ algorithm BackendDump.dumpVarList(indepVars, "indepVars"); end if; + // (fmiDerInit, _) := SymbolicJacobian.createFMIModelDerivativesForInitialization(tmpBDAE, inSimDAE, depVars, indepVars, currentSystem.orderedVars); + //tmpBDAE1 := BackendDAEUtil.copyBackendDAE(tmpBDAE); + // Calculate the dependecies of initialUnknowns - (sparsePattern, _) := SymbolicJacobian.generateSparsePattern(tmpBDAE, indepVars, depVars); + (sparsePattern, sparseColoring) := SymbolicJacobian.generateSparsePattern(tmpBDAE, indepVars, depVars); if debug then dumpFmiInitialUnknownsDependencies(sparsePattern, "FmiInitialUnknownDependency"); end if; @@ -13815,14 +13891,86 @@ algorithm (_, rowspt, (indepCrefs, depCrefs), _) := sparsePattern; vars1 := getSimVars2Crefs(indepCrefs, crefSimVarHT); vars2 := getSimVars2Crefs(depCrefs, crefSimVarHT); + vars2 := listAppend(vars1, vars2); + indepCrefs := {}; + depCrefs := {}; + for i in rowspt loop + (cref, crefs) := i; + depCrefs := cref :: depCrefs; + for cr in crefs loop + if not listMember(cr, indepCrefs) then + indepCrefs := cr :: indepCrefs; + end if; + end for; + end for; + + //print("\nUnknownVars :" + ComponentReference.printComponentRefListStr(depCrefs)); + //print("\nknownVars :" + ComponentReference.printComponentRefListStr(indepCrefs)); + + // generate Partial derivative for initDAE here, as we have the list of all depVars and inDepVars + if not Flags.isSet(Flags.FMI20_DEPENDENCIES) and not stringEq(Config.simCodeTarget(), "Cpp") then + fmiDerInitDepVars := getDependentAndIndepentVarsForJacobian(depCrefs, BackendVariable.listVar(depVars)); + fmiDerInitIndepVars := getDependentAndIndepentVarsForJacobian(indepCrefs, BackendVariable.listVar(indepVars)); + if debug then + BackendDump.dumpVarList(fmiDerInitDepVars, "fmiDerInit_unknownVars"); + BackendDump.dumpVarList(fmiDerInitIndepVars, "fmiDerInit_knownVars"); + end if; + fmiDerInit := SymbolicJacobian.createFMIModelDerivativesForInitialization(inInitDAE, inSimDAE, fmiDerInitDepVars, fmiDerInitIndepVars, currentSystem.orderedVars, sparsePattern, sparseColoring); + + // sort the cref according to FMIINDEX, to be used by fmi2GetDirectionalDerivative() + sortedknownCrefs := sortInitialUnknowsSimVars(getSimVars2Crefs(indepCrefs, crefSimVarHT)); + sortedUnknownCrefs := sortInitialUnknowsSimVars(getSimVars2Crefs(depCrefs, crefSimVarHT)); + end if; + // sort the vars with FMI Index sparseInts := sortSparsePattern(vars2, rowspt, true); // populate the FmiInitial unknowns according to FMI ModelDescription.xml format outFmiUnknownlist := translateSparsePatterInts2FMIUnknown(sparseInts, {}); end getFmiInitialUnknowns; +protected function removeKnownVarsWithFixedTrue + "checks if a known var is present in shared.globalKnownVars and in orderedVars + and remove from fmiderInit_KnownVars to simplify jacobian calculation" + input list inVar; + input BackendDAE.Variables globalKnownVars; + output list outVar = {}; +protected + list varlst; + list crefList; +algorithm + crefList := List.map(BackendVariable.varList(globalKnownVars), BackendVariable.varCref); + BackendDump.dumpVariables(globalKnownVars, "checkGlobalVars*******"); + for var in inVar loop + if listMember(var.varName, crefList) then + (varlst, _ ) := BackendVariable.getVar(var.varName, globalKnownVars); + if not BackendVariable.isParam(List.first(varlst)) and BackendVariable.varFixed(List.first(varlst)) then + //print("\n Matched Var: " + ComponentReference.printComponentRefStr(var.varName)); + else + outVar := var :: outVar; + end if; + end if; + end for; +end removeKnownVarsWithFixedTrue; + +protected function getDependentAndIndepentVarsForJacobian + "function which returns the rows and columns vars for jacobian matrix which will + be used to get partial derivatives of fmu's using fmi2GetDirectionalDerivative" + input list crefs; + input BackendDAE.Variables orderedVars; + output list outVar = {}; +protected + BackendDAE.Var var; +algorithm + for cr in crefs loop + var := BackendVariable.getVarSingle(cr, orderedVars); + if BackendVariable.isRealVar(var) then + outVar := BackendVariable.getVarSingle(cr, orderedVars) :: outVar; + end if; + end for; +end getDependentAndIndepentVarsForJacobian; + protected function getDepAndIndepVarsForInitialUnknowns "function which extracts the depVars and indepVars from initiDAE depVars contains: diff --git a/OMCompiler/Compiler/Template/CodegenC.tpl b/OMCompiler/Compiler/Template/CodegenC.tpl index 3783c674079..5c8764135eb 100644 --- a/OMCompiler/Compiler/Template/CodegenC.tpl +++ b/OMCompiler/Compiler/Template/CodegenC.tpl @@ -1314,7 +1314,10 @@ template simulationFile(SimCode simCode, String guid, String isModelExchangeFMU) <% if isModelExchangeFMU then symbolName(modelNamePrefixStr,"read_input_fmu") else "NULL" %>, <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(continuousPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"initialAnalyticJacobianFMIDER") else "NULL" else "NULL" %>, <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(continuousPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"functionJacFMIDER_column") else "NULL" else "NULL" %>, - <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(continuousPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"INDEX_JAC_FMIDER") else "-1" else "-1" %> + <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(continuousPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"INDEX_JAC_FMIDER") else "-1" else "-1" %>, + <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(initialPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"initialAnalyticJacobianFMIDERINIT") else "NULL" else "NULL" %>, + <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(initialPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"functionJacFMIDERINIT_column") else "NULL" else "NULL" %>, + <% if isSome(modelStructure) then match modelStructure case SOME(FMIMODELSTRUCTURE(initialPartialDerivatives=SOME(__))) then symbolName(modelNamePrefixStr,"INDEX_JAC_FMIDERINIT") else "-1" else "-1" %> <%\n%> }; diff --git a/OMCompiler/Compiler/Template/CodegenFMU.tpl b/OMCompiler/Compiler/Template/CodegenFMU.tpl index 5f89371d529..c49ae0d5a92 100644 --- a/OMCompiler/Compiler/Template/CodegenFMU.tpl +++ b/OMCompiler/Compiler/Template/CodegenFMU.tpl @@ -281,6 +281,8 @@ case SIMCODE(__) then fmi2ValueReference mapInputReference2InputNumber(const fmi2ValueReference vr); fmi2ValueReference mapOutputReference2OutputNumber(const fmi2ValueReference vr); fmi2ValueReference mapOutputReference2RealOutputDerivatives(const fmi2ValueReference vr); + fmi2ValueReference mapInitialUnknownsdependentIndex(const fmi2ValueReference vr); + fmi2ValueReference mapInitialUnknownsIndependentIndex(const fmi2ValueReference vr); >> else << @@ -331,6 +333,8 @@ case SIMCODE(__) then <%setExternalFunction2(modelInfo)%> <%mapInputAndOutputs(simCode)%> <%mapRealOutputDerivatives(simCode, FMUType)%> + <%mapInitialUnknownsdependentCrefs(simCode)%> + <%mapInitialUnknownsIndependentCrefs(simCode)%> >> else << @@ -1193,6 +1197,44 @@ case SIMCODE(modelInfo=MODELINFO(vars=SIMVARS(outputVars=outputVars))) then end match end mapRealOutputDerivatives; +template mapInitialUnknownsdependentCrefs(SimCode simCode) +"" +::= +match simCode +case SIMCODE(modelStructure=SOME(FMIMODELSTRUCTURE(fmiInitialUnknowns=FMIINITIALUNKNOWNS(sortedUnknownCrefs=sortedUnknownCrefs)))) then + << + /* function maps initialUnknowns UnknownVars ValueReferences to an internal partial derivatives index */ + fmi2ValueReference mapInitialUnknownsdependentIndex(const fmi2ValueReference vr) { + switch (vr) { + <%sortedUnknownCrefs |> (index, cref) => + 'case <%lookupVR(cref, simCode)%>: return <%index%>; break;' ;separator="\n"%> + default: + return -1; + } + } + >> +end match +end mapInitialUnknownsdependentCrefs; + +template mapInitialUnknownsIndependentCrefs(SimCode simCode) +"" +::= +match simCode +case SIMCODE(modelStructure=SOME(FMIMODELSTRUCTURE(fmiInitialUnknowns=FMIINITIALUNKNOWNS(sortedknownCrefs=sortedknownCrefs)))) then + << + /* function maps initialUnknowns knownVars ValueReferences to an internal partial derivatives index */ + fmi2ValueReference mapInitialUnknownsIndependentIndex(const fmi2ValueReference vr) { + switch (vr) { + <%sortedknownCrefs |> (index, cref) => + 'case <%lookupVR(cref, simCode)%>: return <%index%>; break;' ;separator="\n"%> + default: + return -1; + } + } + >> +end match +end mapInitialUnknownsIndependentCrefs; + template getPlatformString2(String modelNamePrefix, String platform, String fileNamePrefix, String fmuTargetName, String dirExtra, String libsPos1, String libsPos2, String omhome, String FMUVersion) "returns compilation commands for the platform. " ::= diff --git a/OMCompiler/Compiler/Template/SimCodeTV.mo b/OMCompiler/Compiler/Template/SimCodeTV.mo index a7f4618c52a..93bd8f4c0a4 100644 --- a/OMCompiler/Compiler/Template/SimCodeTV.mo +++ b/OMCompiler/Compiler/Template/SimCodeTV.mo @@ -846,6 +846,8 @@ package SimCode uniontype FmiInitialUnknowns record FMIINITIALUNKNOWNS list fmiUnknownsList; + list> sortedUnknownCrefs "use the sorted crefs to get the ValueReference of unknowns"; + list> sortedknownCrefs "use the sorted crefs to get the ValueReference of knowns"; end FMIINITIALUNKNOWNS; end FmiInitialUnknowns; @@ -854,6 +856,7 @@ package SimCode FmiOutputs fmiOutputs; FmiDerivatives fmiDerivatives; Option continuousPartialDerivatives; + Option initialPartialDerivatives; FmiDiscreteStates fmiDiscreteStates; FmiInitialUnknowns fmiInitialUnknowns; end FMIMODELSTRUCTURE; diff --git a/OMCompiler/SimulationRuntime/c/openmodelica_func.h b/OMCompiler/SimulationRuntime/c/openmodelica_func.h index a43594bde5a..b89d5768706 100644 --- a/OMCompiler/SimulationRuntime/c/openmodelica_func.h +++ b/OMCompiler/SimulationRuntime/c/openmodelica_func.h @@ -357,6 +357,12 @@ int (*initialPartialFMIDER)(void* data, threadData_t *threadData, ANALYTIC_JACOB int (*functionJacFMIDER_column)(void* data, threadData_t *threadData, ANALYTIC_JACOBIAN* thisJacobian, ANALYTIC_JACOBIAN* parentJacobian); const int INDEX_JAC_FMIDER; +/* + * FMU partial derivative functions for initilization DAE + */ +int (*initialPartialFMIDERINIT)(void* data, threadData_t *threadData, ANALYTIC_JACOBIAN* thisJacobian); +int (*functionJacFMIDERINIT_column)(void* data, threadData_t *threadData, ANALYTIC_JACOBIAN* thisJacobian, ANALYTIC_JACOBIAN* parentJacobian); +const int INDEX_JAC_FMIDERINIT; }; diff --git a/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.c.inc b/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.c.inc index 8467d442011..83d900630da 100644 --- a/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.c.inc +++ b/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.c.inc @@ -580,6 +580,32 @@ fmi2Component fmi2Instantiate(fmi2String instanceName, fmi2Type fmuType, fmi2Str } } + /* allocate memory for Jacobian during initialization DAE */ + comp->_has_jacobian_intialization = 0; + comp->fmiDerJacInitialization = NULL; + if (comp->fmuData->callback->initialPartialFMIDERINIT != NULL) + { + comp->fmiDerJacInitialization = (ANALYTIC_JACOBIAN*) functions->allocateMemory(1, sizeof(ANALYTIC_JACOBIAN)); + if (! comp->fmuData->callback->initialPartialFMIDERINIT(comp->fmuData, comp->threadData, comp->fmiDerJacInitialization)) + { + comp->_has_jacobian_intialization = 1; + } + } + + // int cols = comp->fmiDerJac->sizeCols; + // int rows = comp->fmiDerJac->sizeRows; + // printf("\nFMIDER number of rows and colums"); + // printf("\nNumber of rows : %i", rows); + // printf("\nNumber of columns: %i", cols); + // printf("\n"); + + // int cols_ = comp->fmiDerJacInitialization->sizeCols; + // int rows_ = comp->fmiDerJacInitialization->sizeRows; + // printf("\nFMIDER INITIALIZATION number of rows and colums"); + // printf("\nNumber of rows : %i", rows_); + // printf("\nNumber of columns: %i", cols_); + // printf("\n"); + comp->states = (fmi2Real*)functions->allocateMemory(NUMBER_OF_STATES, sizeof(fmi2Real)); comp->states_der = (fmi2Real*)functions->allocateMemory(NUMBER_OF_STATES, sizeof(fmi2Real)); comp->event_indicators = (fmi2Real*)functions->allocateMemory(NUMBER_OF_EVENT_INDICATORS, sizeof(fmi2Real)); @@ -649,6 +675,23 @@ void fmi2FreeInstance(fmi2Component c) freeMemory(comp->fmiDerJac); comp->fmiDerJac=NULL; } + + /* Free jacobian data */ + if (comp->_has_jacobian_intialization == 1) { + /* TODO: Use comp->functions->freeMemory insted of free, + * but generated code uses malloc / calloc instead of comp->functions->allocateMemory */ + free(comp->fmiDerJacInitialization->seedVars); comp->fmiDerJacInitialization->seedVars = NULL; + free(comp->fmiDerJacInitialization->resultVars); comp->fmiDerJacInitialization->resultVars = NULL; + free(comp->fmiDerJacInitialization->tmpVars); comp->fmiDerJacInitialization->tmpVars = NULL; + + free(comp->fmiDerJacInitialization->sparsePattern->leadindex); comp->fmiDerJacInitialization->sparsePattern->leadindex = NULL; + free(comp->fmiDerJacInitialization->sparsePattern->index); comp->fmiDerJacInitialization->sparsePattern->index = NULL; + free(comp->fmiDerJacInitialization->sparsePattern->colorCols); comp->fmiDerJacInitialization->sparsePattern->colorCols = NULL; + free(comp->fmiDerJacInitialization->sparsePattern); comp->fmiDerJacInitialization->sparsePattern = NULL; + + freeMemory(comp->fmiDerJacInitialization); comp->fmiDerJacInitialization=NULL; + } + freeMemory(comp->states); comp->states = NULL; freeMemory(comp->states_der); comp->states_der = NULL; freeMemory(comp->event_indicators); comp->event_indicators = NULL; @@ -1141,6 +1184,69 @@ fmi2Status fmi2DeSerializeFMUstate(fmi2Component c, const fmi2Byte serializedSta return unsupportedFunction(c, "fmi2DeSerializeFMUstate", modelInstantiated|modelInitializationMode|modelEventMode|modelContinuousTimeMode|modelTerminated|modelError); } +fmi2Status fmi2GetDirectionalDerivativeForInitialization(ModelInstance *comp, MODEL_DATA* modelData, DATA* fmudata, threadData_t* td, + const fmi2ValueReference vUnknown_ref[], size_t nUnknown, + const fmi2ValueReference vKnown_ref[] , size_t nKnown, + const fmi2Real dvKnown[], fmi2Real dvUnknown[]) +{ + if (!comp->_has_jacobian_intialization) + return unsupportedFunction(comp, "fmi2GetDirectionalDerivative", modelInitializationMode|modelEventMode|modelContinuousTimeMode|modelTerminated|modelError); + + /***************************************/ + /* This code assumes that the FMU variables are always sorted, + states first and then derivatives. + This is true for the actual OMC FMUs. + The input values references are mapped with mapInputReference2InputNumber + and mapOutputReference2OutputNumber functions + */ + /* eval constant part of jacobian */ + + int i,j; + + int independent = comp->fmiDerJacInitialization->sizeCols; + int dependent = comp->fmiDerJacInitialization->sizeRows; + + /* TODO: Evaluate only once for one evaluation of jacobian */ + if (comp->fmiDerJacInitialization->constantEqns != NULL) { + comp->fmiDerJacInitialization->constantEqns(fmudata, td, comp->fmiDerJacInitialization, NULL); + } + + /* clear out the seeds */ + for (i = 0; i < independent; i++) + { + comp->fmiDerJacInitialization->seedVars[i] = 0; + } + + for (i = 0; i < nKnown; i++) + { + // map the known ValueReferences to an internal index + int idx = mapInitialUnknownsIndependentIndex(vKnown_ref[i]); + if (vrOutOfRange(comp, "fmi2GetDirectionalDerivative input index during initialization", idx, independent)) + return fmi2Error; + /* Put the supplied value in the seeds */ + comp->fmiDerJacInitialization->seedVars[idx] = dvKnown[i]; + } + + /* Call the Jacobian evaluation function. This function evaluates the whole column of the Jacobian. + * More efficient code could only evaluate the equations needed for the + * known variables only */ + setThreadData(comp); + fmudata->callback->functionJacFMIDERINIT_column(fmudata, td, comp->fmiDerJacInitialization, NULL); + resetThreadData(comp); + + /* Write the results to dvUnknown array */ + for (i=0;ifmiDerJacInitialization->resultVars[idx]; + } + + return fmi2OK; +} + fmi2Status fmi2GetDirectionalDerivative(fmi2Component c, const fmi2ValueReference vUnknown_ref[], size_t nUnknown, const fmi2ValueReference vKnown_ref[] , size_t nKnown, @@ -1160,6 +1266,13 @@ fmi2Status fmi2GetDirectionalDerivative(fmi2Component c, if (invalidState(comp, "fmi2GetDirectionalDerivative", modelInstantiated|modelEventMode|modelContinuousTimeMode, ~0)) return fmi2Error; FILTERED_LOG(comp, fmi2OK, LOG_FMI2_CALL, "fmi2GetDirectionalDerivative") + + if (modelInitializationMode == comp->state) + { + //printf("\ngetDirectional Derivative initialized state\n"); + return fmi2GetDirectionalDerivativeForInitialization(comp, modelData, fmudata, td, vUnknown_ref, nUnknown, vKnown_ref, nKnown, dvKnown, dvUnknown); + } + if (!comp->_has_jacobian) return unsupportedFunction(c, "fmi2GetDirectionalDerivative", modelInitializationMode|modelEventMode|modelContinuousTimeMode|modelTerminated|modelError); /***************************************/ diff --git a/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.h b/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.h index e44c3361a7b..ec2fe2cf16d 100644 --- a/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.h +++ b/OMCompiler/SimulationRuntime/fmi/export/openmodelica/fmu2_model_interface.h @@ -91,7 +91,9 @@ typedef struct { int _need_update; int _has_jacobian; + int _has_jacobian_intialization; ANALYTIC_JACOBIAN* fmiDerJac; + ANALYTIC_JACOBIAN* fmiDerJacInitialization; fmi2Real* states; fmi2Real* states_der; diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_01.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_01.mos index 5e22435ca4c..3a12d107733 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_01.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_01.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_01.fmu fmi_attributes_01.log fmi_attributes_01.xml fmi_attributes_01_tmp.xml +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_01 Real x(start=-1.0, fixed=true); @@ -26,6 +29,8 @@ readFile("fmi_attributes_01.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_01.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_02.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_02.mos index 25418c7a56b..78b2e0bad5f 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_02.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_02.mos @@ -3,6 +3,10 @@ // status: correct // teardown_command: rm -rf fmi_attributes_02.fmu fmi_attributes_02.log fmi_attributes_02.xml fmi_attributes_02_tmp.xml + +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_02 input Real u; @@ -27,6 +31,8 @@ readFile("fmi_attributes_02.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_02.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_03.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_03.mos index 06f6febc204..8b90e3dfbb8 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_03.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_03.mos @@ -2,6 +2,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_03.fmu fmi_attributes_03.log fmi_attributes_03.xml fmi_attributes_03_tmp.xml fmi_attributes_03.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_03 Real x(fixed=true, start=x_start); @@ -24,6 +27,8 @@ readFile("fmi_attributes_03.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_03.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_04.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_04.mos index 0f94f1aceff..79750ea5191 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_04.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_04.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_04.fmu fmi_attributes_04.log fmi_attributes_04.xml fmi_attributes_04_tmp.xml fmi_attributes_04.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_04 input Real u; @@ -29,6 +32,8 @@ readFile("fmi_attributes_04.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_04.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_05.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_05.mos index 879a6de89f0..072e94dac3f 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_05.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_05.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_05.fmu fmi_attributes_05.log fmi_attributes_05.xml fmi_attributes_05_tmp.xml fmi_attributes_05.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_05 input Real u; @@ -32,6 +35,8 @@ readFile("fmi_attributes_05.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_05.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_06.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_06.mos index db1c20e172a..30752b49f1e 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_06.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_06.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_06.fmu fmi_attributes_06.log fmi_attributes_06.xml fmi_attributes_06_tmp.xml fmi_attributes_06.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_06 parameter Real m=0.5; @@ -32,6 +35,8 @@ readFile("fmi_attributes_06.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_06.fmu" // "Warning: The initial conditions are not fully specified. For more information set -d=initialization. In OMEdit Tools->Options->Simulation->Show additional information from the initialization process, in OMNotebook call setCommandLineOptions(\"-d=initialization\"). // " diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_07.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_07.mos index 12109885305..4060763431f 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_07.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_07.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_07.fmu fmi_attributes_07.log fmi_attributes_07.xml fmi_attributes_07_tmp.xml fmi_attributes_07.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_07 input Real u; @@ -33,6 +36,8 @@ readFile("fmi_attributes_07.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_07.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_08.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_08.mos index 88192fcf42a..c16d570e15d 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_08.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_08.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_08.fmu fmi_attributes_08.log fmi_attributes_08.xml fmi_attributes_08_tmp.xml fmi_attributes_08.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_08 parameter Real p; @@ -27,6 +30,8 @@ readFile("fmi_attributes_08.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_08.fmu" // "[:3:3-3:19:writable] Warning: Parameter p has no value, and is fixed during initialization (fixed=true), using available start value (start=0.0) as default value. // " diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_09.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_09.mos index 2630171fb76..c790653132a 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_09.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_09.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_09.fmu fmi_attributes_09.log fmi_attributes_09.xml fmi_attributes_09_tmp.xml fmi_attributes_09.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_09 function foo @@ -47,6 +50,8 @@ readFile("fmi_attributes_09.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_09.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_10.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_10.mos index 9b1efc7f12c..680dafddacf 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_10.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_10.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_10.fmu fmi_attributes_10.log fmi_attributes_10.xml fmi_attributes_10_tmp.xml fmi_attributes_10.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_10 Real x(start=1, fixed=true); @@ -25,6 +28,8 @@ readFile("fmi_attributes_10.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_10.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_11.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_11.mos index 4b40f57ff73..31070cf835b 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_11.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_11.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_11.fmu fmi_attributes_11.log fmi_attributes_11.xml fmi_attributes_11_tmp.xml fmi_attributes_11.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_11 input Real u; @@ -37,6 +40,8 @@ readFile("fmi_attributes_11.xml"); getErrorString(); // "" // true // "" +// true +// "" // "fmi_attributes_11.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_12.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_12.mos index db83929a01c..ce4e1a8bc89 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_12.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_12.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_12.fmu fmi_attributes_12.log fmi_attributes_12.xml fmi_attributes_12_tmp.xml fmi_attributes_12.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_12 input Real u; @@ -41,6 +44,8 @@ readFile("fmi_attributes_12.xml"); getErrorString(); // "" // true // "" +// true +// "" // "fmi_attributes_12.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_13.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_13.mos index a39af4a25e1..091c9e5db9b 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_13.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_13.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_13.fmu fmi_attributes_13.log fmi_attributes_13.xml fmi_attributes_13_tmp.xml fmi_attributes_13.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_13 input Real u; @@ -41,6 +44,8 @@ readFile("fmi_attributes_13.xml"); getErrorString(); // "" // true // "" +// true +// "" // "fmi_attributes_13.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_14.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_14.mos index 5a24b920ada..79bba9df3c4 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_14.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_14.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_14.fmu fmi_attributes_14.log fmi_attributes_14.xml fmi_attributes_14_tmp.xml fmi_attributes_14.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_14 input Real u; @@ -41,6 +44,8 @@ readFile("fmi_attributes_14.xml"); getErrorString(); // "" // true // "" +// true +// "" // "fmi_attributes_14.fmu" // "" // 0 diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_15.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_15.mos index 99f54e4ad8f..d2ff5ec5575 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_15.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_15.mos @@ -3,6 +3,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_15.fmu fmi_attributes_15.log fmi_attributes_15_tmp.xml fmi_attributes_15.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_15 Real x(unit = \"kg2\"); @@ -25,6 +28,8 @@ readFile("fmi_attributes_15_tmp.xml") // Result: // true // "" +// true +// "" // "fmi_attributes_15.fmu" // "" // 0 @@ -117,17 +122,17 @@ readFile("fmi_attributes_15_tmp.xml") // // // -// -// -// -// -// -// -// -// -// -// -// +// +// +// +// +// +// +// +// +// +// +// // // // diff --git a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_16.mos b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_16.mos index c557de90145..80d00a1b8af 100644 --- a/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_16.mos +++ b/testsuite/openmodelica/fmi/ModelExchange/2.0/fmi_attributes_16.mos @@ -2,6 +2,9 @@ // status: correct // teardown_command: rm -rf fmi_attributes_16.fmu fmi_attributes_16.log fmi_attributes_16.xml fmi_attributes_16_tmp.xml fmi_attributes_16.fmutmp/ +setCommandLineOptions("-d=newInst,-disableDirectionalDerivatives,fmuExperimental"); +getErrorString(); + loadString(" model fmi_attributes_16 Real x(fixed=true, start=x_start); @@ -26,6 +29,8 @@ readFile("fmi_attributes_16.xml"); getErrorString(); // Result: // true // "" +// true +// "" // "fmi_attributes_16.fmu" // "" // 0