From c80f58e72430cab6019affe7782446f320b71ac0 Mon Sep 17 00:00:00 2001 From: phannebohm Date: Wed, 1 Sep 2021 19:29:43 +0200 Subject: [PATCH] Invent nominal values for derivatives (#7819) A new heuristic for estimating the nominal value of derivatives is to take the nominal value from the corresponding state and divide that by the simulation interval. der(x).nominal := x.nominal/Interval See issue #7794 for the discussion. --- OMCompiler/Compiler/BackEnd/BackendDAE.mo | 15 ++-- .../Compiler/BackEnd/BackendDAECreate.mo | 1 + OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo | 1 + .../Compiler/Script/CevalScriptBackend.mo | 27 +++----- OMCompiler/Compiler/SimCode/SimCodeMain.mo | 3 +- OMCompiler/Compiler/SimCode/SimCodeUtil.mo | 69 +++++++++++++------ .../fmu/modelExchange/2.0/testDrumBoiler.mos | 4 +- .../optimization/benchmark/runDrumBoiler.mos | 2 +- .../benchmark/runReduceDrumBoiler.mos | 2 +- .../ModelExchange/2.0/fmi_attributes_01.mos | 2 +- 10 files changed, 75 insertions(+), 51 deletions(-) diff --git a/OMCompiler/Compiler/BackEnd/BackendDAE.mo b/OMCompiler/Compiler/BackEnd/BackendDAE.mo index bdd2d2267b7..dbf0e2b6bcb 100644 --- a/OMCompiler/Compiler/BackEnd/BackendDAE.mo +++ b/OMCompiler/Compiler/BackEnd/BackendDAE.mo @@ -79,7 +79,7 @@ uniontype EqSystem "An independent system of equations (and their corresponding StateSets stateSets "the state sets of the system"; BaseClockPartitionKind partitionKind; EquationArray removedEqs "these are equations that cannot solve for a variable. - e.g. assertions, external function calls, algorithm sections without effect"; + e.g. assertions, external function calls, algorithm sections without effect"; end EQSYSTEM; end EqSystem; @@ -121,8 +121,8 @@ uniontype Shared "Data shared for all equation-systems" pointer to their values (trajectories)."; EquationArray initialEqs "Initial equations"; EquationArray removedEqs "these are equations that cannot solve for a variable. for example assertions, external function calls, algorithm sections without effect"; - list< .DAE.Constraint> constraints "constraints (Optimica extension)"; - list< .DAE.ClassAttributes> classAttrs "class attributes (Optimica extension)"; + list< .DAE.Constraint> constraints "constraints (Optimica extension)"; + list< .DAE.ClassAttributes> classAttrs "class attributes (Optimica extension)"; FCore.Cache cache; FCore.Graph graph; .DAE.FunctionTree functionTree "functions for Backend"; @@ -130,10 +130,11 @@ uniontype Shared "Data shared for all equation-systems" ExternalObjectClasses extObjClasses "classes of external objects, contains constructor & destructor"; BackendDAEType backendDAEType "indicate for what the BackendDAE is used"; SymbolicJacobians symjacs "Symbolic Jacobians"; - ExtraInfo info "contains extra info that we send around like the model name"; + ExtraInfo info "contains extra info that we send around like the model name"; PartitionsInfo partitionsInfo; - BackendDAEModeData daeModeData "DAEMode Data"; + BackendDAEModeData daeModeData "DAEMode Data"; Option dataReconciliationData; + Option<.DAE.Exp> timeInterval "from experiment annotation Interval, used for derivative nominal guesswork"; end SHARED; end Shared; @@ -167,8 +168,8 @@ uniontype PartitionsInfo end PartitionsInfo; uniontype ExtraInfo "extra information that we should send around with the DAE" - record EXTRA_INFO "extra information that we should send around with the DAE" - String description "the model description string"; + record EXTRA_INFO + String description "the model description string"; String fileNamePrefix "the model name to be used in the dumps"; end EXTRA_INFO; end ExtraInfo; diff --git a/OMCompiler/Compiler/BackEnd/BackendDAECreate.mo b/OMCompiler/Compiler/BackEnd/BackendDAECreate.mo index 26fdd6197bf..1e3abfcf32f 100644 --- a/OMCompiler/Compiler/BackEnd/BackendDAECreate.mo +++ b/OMCompiler/Compiler/BackEnd/BackendDAECreate.mo @@ -170,6 +170,7 @@ algorithm symjacs,inExtraInfo, BackendDAEUtil.emptyPartitionsInfo(), BackendDAE.emptyDAEModeData, + NONE(), NONE() )); BackendDAEUtil.checkBackendDAEWithErrorMsg(outBackendDAE); diff --git a/OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo b/OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo index 661c40e5a0e..95bb55ba962 100644 --- a/OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo +++ b/OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo @@ -9179,6 +9179,7 @@ algorithm ei, emptyPartitionsInfo(), BackendDAE.emptyDAEModeData, + NONE(), NONE() ); end createEmptyShared; diff --git a/OMCompiler/Compiler/Script/CevalScriptBackend.mo b/OMCompiler/Compiler/Script/CevalScriptBackend.mo index 8c6552f2ef4..66accc218f6 100644 --- a/OMCompiler/Compiler/Script/CevalScriptBackend.mo +++ b/OMCompiler/Compiler/Script/CevalScriptBackend.mo @@ -1266,7 +1266,7 @@ algorithm case (cache,env,"translateModel",vals as {Values.CODE(Absyn.C_TYPENAME(className)),_,_,_,_,_,Values.STRING(filenameprefix),_,_,_,_,_},_) equation - (cache,simSettings) = calculateSimulationSettings(cache,env,vals,msg); + (cache,simSettings) = calculateSimulationSettings(cache, vals); (b,cache,_,_,_) = translateModel(cache, env, className, filenameprefix, true, SOME(simSettings)); then (cache,Values.BOOL(b)); @@ -1499,7 +1499,7 @@ algorithm if Config.simCodeTarget() == "omsicpp" then filenameprefix := AbsynUtil.pathString(className); - (cache,simSettings) := calculateSimulationSettings(cache, env, vals, msg); + (cache,simSettings) := calculateSimulationSettings(cache, vals); try (cache, Values.STRING(str)) := buildModelFMU(cache, env, className, "2.0", "me", "", true, {"static"},SOME(simSettings)); if stringEmpty(str) then @@ -1524,7 +1524,7 @@ algorithm if b then exeDir := compileDir; - (cache,simSettings) := calculateSimulationSettings(cache,env,vals,msg); + (cache,simSettings) := calculateSimulationSettings(cache, vals); SimCode.SIMULATION_SETTINGS(outputFormat = outputFormat_str) := simSettings; result_file := stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str})); // result file might have been set by simflags (-r ...) @@ -1696,7 +1696,7 @@ algorithm (b,cache,compileDir,executable,_,outputFormat_str,_,simflags,resultValues,vals) = buildModel(cache,env,vals,msg); if b then exeDir=compileDir; - (cache,simSettings) = calculateSimulationSettings(cache,env,vals,msg); + (cache,simSettings) = calculateSimulationSettings(cache, vals); SimCode.SIMULATION_SETTINGS(outputFormat = outputFormat_str) = simSettings; result_file = stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str})); executableSuffixedExe = stringAppend(executable, getSimulationExtension(Config.simCodeTarget(),Autoconf.platform)); @@ -4103,36 +4103,29 @@ end translateGraphics; protected function calculateSimulationSettings " author: x02lucpo calculates the start,end,interval,stepsize, method and initFileName" input FCore.Cache inCache; - input FCore.Graph inEnv; input list vals; - input Absyn.Msg inMsg; output FCore.Cache outCache; output SimCode.SimulationSettings outSimSettings; algorithm - (outCache,outSimSettings) := match (inCache,inEnv,vals,inMsg) + (outCache,outSimSettings) := match (inCache,vals) local - String method_str,options_str,outputFormat_str,variableFilter_str,s; + String method_str,options_str,outputFormat_str,variableFilter_str; Values.Value starttime_v,stoptime_v,tolerance_v; Integer interval_i; Real starttime_r,stoptime_r,tolerance_r; - FCore.Graph env; - Absyn.Msg msg; FCore.Cache cache; - String cflags,simflags; - case (cache,_,{Values.CODE(Absyn.C_TYPENAME(_)),starttime_v,stoptime_v,Values.INTEGER(interval_i),tolerance_v,Values.STRING(method_str),_,Values.STRING(options_str),Values.STRING(outputFormat_str),Values.STRING(variableFilter_str),Values.STRING(cflags),Values.STRING(_)},_) + String cflags; + case (cache, {Values.CODE(Absyn.C_TYPENAME(_)),starttime_v,stoptime_v,Values.INTEGER(interval_i),tolerance_v,Values.STRING(method_str),_,Values.STRING(options_str),Values.STRING(outputFormat_str),Values.STRING(variableFilter_str),Values.STRING(cflags),Values.STRING(_)}) equation starttime_r = ValuesUtil.valueReal(starttime_v); stoptime_r = ValuesUtil.valueReal(stoptime_v); tolerance_r = ValuesUtil.valueReal(tolerance_v); outSimSettings = SimCodeMain.createSimulationSettings(starttime_r,stoptime_r,interval_i,tolerance_r,method_str,options_str,outputFormat_str,variableFilter_str,cflags); - - then (cache, outSimSettings); else equation - s = "CevalScript.calculateSimulationSettings failed: " + ValuesUtil.valString(Values.TUPLE(vals)); - Error.addMessage(Error.INTERNAL_ERROR, {s}); + Error.addMessage(Error.INTERNAL_ERROR, {"CevalScript.calculateSimulationSettings failed: " + ValuesUtil.valString(Values.TUPLE(vals))}); then fail(); end match; @@ -5459,7 +5452,7 @@ algorithm end if; compileDir := System.pwd() + Autoconf.pathDelimiter; - (cache,simSettings) := calculateSimulationSettings(cache, env, values, msg); + (cache,simSettings) := calculateSimulationSettings(cache, values); SimCode.SIMULATION_SETTINGS(method = method_str, outputFormat = outputFormat_str) := simSettings; (success,cache,libs,file_dir,resultValues) := translateModel(cache,env, classname, filenameprefix,true, SOME(simSettings)); diff --git a/OMCompiler/Compiler/SimCode/SimCodeMain.mo b/OMCompiler/Compiler/SimCode/SimCodeMain.mo index 5c7b519d35e..d6d5d255fdb 100644 --- a/OMCompiler/Compiler/SimCode/SimCodeMain.mo +++ b/OMCompiler/Compiler/SimCode/SimCodeMain.mo @@ -336,7 +336,8 @@ protected function createSimCode " input BackendDAE.SymbolicJacobians inFMIDer = {}; output SimCode.SimCode simCode; algorithm - simCode := matchcontinue(inBackendDAE, inClassName, filenamePrefix, inString11, functions, externalFunctionIncludes, includeDirs, libs, libPaths, program,simSettingsOpt, recordDecls, literals, args) + // FIXME This matchcontinue is extremely horrible! Please remove it + simCode := matchcontinue(inBackendDAE, inClassName, filenamePrefix, inString11, functions, externalFunctionIncludes, includeDirs, libs, libPaths, program, simSettingsOpt, recordDecls, literals, args) local Integer numProc; SimCode.SimCode tmpSimCode; diff --git a/OMCompiler/Compiler/SimCode/SimCodeUtil.mo b/OMCompiler/Compiler/SimCode/SimCodeUtil.mo index ef960a64720..64719519377 100644 --- a/OMCompiler/Compiler/SimCode/SimCodeUtil.mo +++ b/OMCompiler/Compiler/SimCode/SimCodeUtil.mo @@ -290,12 +290,20 @@ protected SimCode.OMSIFunction omsiInitEquations, omsiSimEquations; Option omsiOptData; + SimCode.SimulationSettings theSettings; constant Boolean debug = false; algorithm try execStat("Backend phase and start with SimCode phase"); dlow := inBackendDAE; + // transfer timeInterval from siulation settings to shared + if isSome(simSettingsOpt) then + SOME(theSettings) := simSettingsOpt; + shared := dlow.shared; + shared.timeInterval := SOME(DAE.RCONST(theSettings.stepSize)); + dlow.shared := shared; + end if; System.tmpTickReset(0); uniqueEqIndex := 1; ifcpp := (stringEqual(Config.simCodeTarget(), "Cpp")); @@ -3999,7 +4007,6 @@ algorithm Boolean linear, mixedSystem; Option derivativeMatrix; Integer algEqIndex; - list eqns; list variables; @@ -4007,14 +4014,14 @@ algorithm case BackendDAE.SINGLEEQUATION() equation ({eqn}, {var}, _) = BackendDAETransform.getEquationAndSolvedVar(component, constSyst.orderedEqs, constSyst.orderedVars); (tmpEqns, tmpInputVars, tmpOutputVars, tmpInnerVars, uniqueEqIndex) = - generateSingleEquation(eqn, var, shared.functionTree, uniqueEqIndex); + generateSingleEquation(eqn, var, shared.functionTree, shared.timeInterval, uniqueEqIndex); then (); // case for singe when equations case BackendDAE.SINGLEWHENEQUATION() equation (eqnlst, varlst, _) = BackendDAETransform.getEquationAndSolvedVar(component, constSyst.orderedEqs, constSyst.orderedVars); (tmpEqns, tmpInputVars, tmpOutputVars, tmpInnerVars, uniqueEqIndex) = - generateSingleEquation(listHead(eqnlst), listHead(varlst), shared.functionTree, uniqueEqIndex); + generateSingleEquation(listHead(eqnlst), listHead(varlst), shared.functionTree, shared.timeInterval, uniqueEqIndex); then(); // case for single comlpex equation @@ -4216,6 +4223,7 @@ function generateSingleEquation input BackendDAE.Equation eqn; input BackendDAE.Var var; input DAE.FunctionTree funcTree; + input Option timeInterval "from experiment annotation Interval, used for derivative nominal"; output list equations = {}; output list inputVars = {}; output list outputVars = {}; @@ -4278,7 +4286,7 @@ algorithm // add der(newSimVar) to outputVars if newSimVar is state if BackendVariable.isStateVar(var) then - outputVars := listAppend({derVarFromStateVar(newSimVar)}, outputVars); + outputVars := listAppend({derVarFromStateVar(newSimVar, timeInterval)}, outputVars); inputVars := listAppend({newSimVar}, inputVars); else outputVars := listAppend({newSimVar}, outputVars); @@ -7953,6 +7961,7 @@ protected array> simVars = arrayCreate(size(SimVarsIndex,1), {}); Integer primeSize; list iterationVars; + Option timeInterval = NONE(); constant Boolean debug = false; algorithm @@ -7981,45 +7990,45 @@ algorithm // ### simulation ### // Extract from variable list - simVars := List.fold1(list(BackendVariable.daeVars(syst) for syst in systs1), BackendVariable.traverseBackendDAEVars, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, iterationVars=iterationVars), simVars); + simVars := List.fold1(list(BackendVariable.daeVars(syst) for syst in systs1), BackendVariable.traverseBackendDAEVars, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: variable list"); end if; // Extract from known variable list - simVars := BackendVariable.traverseBackendDAEVars(globalKnownVars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(globalKnownVars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: known variable list"); end if; // Extract from localKnownVars variable list - simVars := BackendVariable.traverseBackendDAEVars(localKnownVars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(localKnownVars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: local known variables list"); end if; // Extract from removed variable list - simVars := BackendVariable.traverseBackendDAEVars(aliasVars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(aliasVars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: removed variables list"); end if; // Extract from external object list - simVars := BackendVariable.traverseBackendDAEVars(extvars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(extvars1, function extractVarsFromList(aliasVars=aliasVars1, vars=globalKnownVars1, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: external object list"); end if; // ### initialization ### // Extract from variable list - simVars := List.fold1(list(BackendVariable.daeVars(syst) for syst in systs2), BackendVariable.traverseBackendDAEVars, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, iterationVars=iterationVars), simVars); + simVars := List.fold1(list(BackendVariable.daeVars(syst) for syst in systs2), BackendVariable.traverseBackendDAEVars, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, timeInterval=NONE(), iterationVars=iterationVars), simVars); if debug then execStat("createVars: variable list (init)"); end if; // Extract from known variable list - simVars := BackendVariable.traverseBackendDAEVars(globalKnownVars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(globalKnownVars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: known variable list (init)"); end if; // Extract from localKnownVars variable list - simVars := BackendVariable.traverseBackendDAEVars(localKnownVars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(localKnownVars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: local known variables list (init)"); end if; // Extract from removed variable list - simVars := BackendVariable.traverseBackendDAEVars(aliasVars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(aliasVars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: removed variables list (init)"); end if; // Extract from external object list - simVars := BackendVariable.traverseBackendDAEVars(extvars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, iterationVars=iterationVars), simVars); + simVars := BackendVariable.traverseBackendDAEVars(extvars2, function extractVarsFromList(aliasVars=aliasVars2, vars=globalKnownVars2, hs=hs, timeInterval=shared.timeInterval, iterationVars=iterationVars), simVars); if debug then execStat("createVars: external object list (init)"); end if; addTempVars(simVars, tempvars); @@ -8083,12 +8092,13 @@ protected function extractVarsFromList input output array> simVars; input BackendDAE.Variables aliasVars, vars; input Mutable hs; - input list iterationVars "list of iterationVars in InitializationMode" ; + input Option timeInterval "from experiment annotation Interval, used for derivative nominal"; + input list iterationVars "list of iterationVars in InitializationMode"; algorithm if if ComponentReference.isPreCref(var.varName) or ComponentReference.isStartCref(var.varName) then false else not BaseHashSet.has(var.varName, Mutable.access(hs)) then /* ignore variable, since they are treated by kind in the codegen */ if not BackendVariable.isAlgebraicOldState(var) then - extractVarFromVar(var, aliasVars, vars, simVars, hs, iterationVars); + extractVarFromVar(var, aliasVars, vars, simVars, hs, timeInterval, iterationVars); end if; // print("Added " + ComponentReference.printComponentRefStr(inVar.varName) + "\n"); //else @@ -8160,6 +8170,7 @@ protected function extractVarFromVar input BackendDAE.Variables inVars; input array> simVars; input Mutable hs "all processed crefs"; + input Option timeInterval "from experiment annotation Interval, used for derivative nominal"; input list iterationVars "list of iterationVars in InitializationMode" ; protected list scalar_crefs; @@ -8172,11 +8183,11 @@ algorithm // extract the sim var scalarVar := BackendVariable.copyVarNewName(cref, dlowVar); scalarVar.varType := ComponentReference.crefTypeFull(cref); - extractVarFromVar2(scalarVar, inAliasVars, inVars, simVars, hs, iterationVars); + extractVarFromVar2(scalarVar, inAliasVars, inVars, simVars, hs, timeInterval, iterationVars); end for; else // extract the sim var - extractVarFromVar2(dlowVar, inAliasVars, inVars, simVars, hs, iterationVars); + extractVarFromVar2(dlowVar, inAliasVars, inVars, simVars, hs, timeInterval, iterationVars); end if; end extractVarFromVar; @@ -8188,6 +8199,7 @@ protected function extractVarFromVar2 input BackendDAE.Variables inVars; input array> simVars; input Mutable hs "all processed crefs"; + input Option timeInterval "from experiment annotation Interval, used for derivative nominal"; input list iterationVars "list of iterationVars in InitializationMode" ; protected SimCodeVar.SimVar simVar; @@ -8228,7 +8240,7 @@ algorithm // update HashSet Mutable.update(hs, BaseHashSet.add(simVar.name, Mutable.access(hs))); if (not isalias) and (BackendVariable.isStateVar(dlowVar) or BackendVariable.isAlgState(dlowVar)) then - derivSimvar := derVarFromStateVar(simVar, iterationVars); + derivSimvar := derVarFromStateVar(simVar, timeInterval, iterationVars); Mutable.update(hs, BaseHashSet.add(derivSimvar.name, Mutable.access(hs))); else derivSimvar := simVar; // Just in case @@ -8356,10 +8368,12 @@ end addSimVar; protected function derVarFromStateVar input SimCodeVar.SimVar state; - input list iterationVars = {} "list of iterationVars in InitializationMode" ; + input Option timeInterval "from experiment annotation Interval, used for derivative nominal"; + input list iterationVars = {} "list of iterationVars in InitializationMode"; output SimCodeVar.SimVar deriv = state; protected Unit.Unit unit; + DAE.Exp nominal; algorithm deriv.arrayCref := Util.applyOption(deriv.arrayCref, ComponentReference.crefPrefixDer); deriv.name := ComponentReference.crefPrefixDer(deriv.name); @@ -8377,7 +8391,20 @@ algorithm deriv.displayUnit := ""; deriv.minValue := NONE(); deriv.maxValue := NONE(); - deriv.nominalValue := NONE(); + + // Only give nominal to iteration variables + if ComponentReference.crefInLst(deriv.name, iterationVars) then + // guess a nominal value for the derivative, if we have that information + // der(x).nominal = x.nominal/simulationInterval + // otherwise just keep the nominal value of the state + if isSome(timeInterval) then + nominal := Expression.makeDiv(Util.getOptionOrDefault(deriv.nominalValue, DAE.RCONST(1.0)), Util.getOption(timeInterval)); + deriv.nominalValue := SOME(ExpressionSimplify.simplify(nominal)); + end if; + else + deriv.nominalValue := NONE(); + end if; + deriv.isFixed := false; deriv.aliasvar := SimCodeVar.NOALIAS(); deriv.causality := SOME(SimCodeVar.LOCAL()); diff --git a/testsuite/openmodelica/cppruntime/fmu/modelExchange/2.0/testDrumBoiler.mos b/testsuite/openmodelica/cppruntime/fmu/modelExchange/2.0/testDrumBoiler.mos index 023dfe3db2d..9345f137765 100644 --- a/testsuite/openmodelica/cppruntime/fmu/modelExchange/2.0/testDrumBoiler.mos +++ b/testsuite/openmodelica/cppruntime/fmu/modelExchange/2.0/testDrumBoiler.mos @@ -219,7 +219,7 @@ val(evaporator_qm_S, 100); // valueReference=\"4\" // description=\"der(volumes of liquid phase)\" // initial=\"approx\"> -// +// // // // -// +// // // // -// +// // // // "