From 87beb39c38e93c2691646cf49814d182da103224 Mon Sep 17 00:00:00 2001 From: kabdelhak <38032125+kabdelhak@users.noreply.github.com> Date: Mon, 22 Jan 2024 13:11:07 +0100 Subject: [PATCH] Nb record residuals (#11827) * [NB] update alias module to not use record elements [NSimCode] draft: inline record residuals * [NB] add variable record children when adding records * [NB] inline record residual equations - fixes #11556 * [testsuite] udapte tests - alias module does not apply to record elements anymore --- .../Compiler/NBackEnd/Classes/NBVariable.mo | 56 ++++++++++--------- .../Compiler/NBackEnd/Classes/NBackendDAE.mo | 4 +- .../NBackEnd/Modules/1_Main/NBCausalize.mo | 2 +- .../NBackEnd/Modules/2_Pre/NBAlias.mo | 4 +- .../NBackEnd/Modules/2_Pre/NBInline.mo | 45 ++++++++++++--- .../NBackEnd/Modules/3_Post/NBTearing.mo | 46 +++++++++++---- .../Compiler/NBackEnd/Modules/NBModule.mo | 2 + .../Compiler/NSimCode/NSimStrongComponent.mo | 8 ++- .../modelica/NBackend/records/ComplexTest.mos | 5 +- 9 files changed, 115 insertions(+), 57 deletions(-) diff --git a/OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo b/OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo index 70b06af2848..fd61ec25195 100644 --- a/OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo +++ b/OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo @@ -1964,6 +1964,7 @@ public type VarType = enumeration(STATE, STATE_DER, ALGEBRAIC, DISCRETE, DISC_STATE, PREVIOUS, START, PARAMETER, ITERATOR, RECORD); function addTypedList + "can also be used to add single variables" input output VarData varData; input list> var_lst; input VarType varType; @@ -1971,57 +1972,58 @@ public varData := match (varData, varType) case (VAR_DATA_SIM(), VarType.STATE) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.knowns := VariablePointers.addList(var_lst, varData.knowns); - varData.states := VariablePointers.addList(var_lst, varData.states); - varData.initials := VariablePointers.addList(var_lst, varData.initials); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.knowns := VariablePointers.addList(var_lst, varData.knowns); + varData.states := VariablePointers.addList(var_lst, varData.states); + varData.initials := VariablePointers.addList(var_lst, varData.initials); // also remove from algebraics in the case it was moved - varData.unknowns := VariablePointers.removeList(var_lst, varData.unknowns); - varData.algebraics := VariablePointers.removeList(var_lst, varData.algebraics); + varData.unknowns := VariablePointers.removeList(var_lst, varData.unknowns); + varData.algebraics := VariablePointers.removeList(var_lst, varData.algebraics); then varData; case (VAR_DATA_SIM(), VarType.STATE_DER) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.unknowns := VariablePointers.addList(var_lst, varData.unknowns); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.unknowns := VariablePointers.addList(var_lst, varData.unknowns); varData.derivatives := VariablePointers.addList(var_lst, varData.derivatives); - varData.initials := VariablePointers.addList(var_lst, varData.initials); + varData.initials := VariablePointers.addList(var_lst, varData.initials); then varData; // algebraic variables, dummy states and dummy derivatives are mathematically equal case (VAR_DATA_SIM(), VarType.ALGEBRAIC) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.unknowns := VariablePointers.addList(var_lst, varData.unknowns); - varData.algebraics := VariablePointers.addList(var_lst, varData.algebraics); - varData.initials := VariablePointers.addList(var_lst, varData.initials); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.unknowns := VariablePointers.addList(var_lst, varData.unknowns); + varData.algebraics := VariablePointers.addList(var_lst, varData.algebraics); + varData.initials := VariablePointers.addList(var_lst, varData.initials); then varData; case (VAR_DATA_SIM(), VarType.DISCRETE) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.unknowns := VariablePointers.addList(var_lst, varData.unknowns); - varData.discretes := VariablePointers.addList(var_lst, varData.discretes); - varData.initials := VariablePointers.addList(var_lst, varData.initials); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.unknowns := VariablePointers.addList(var_lst, varData.unknowns); + varData.discretes := VariablePointers.addList(var_lst, varData.discretes); + varData.initials := VariablePointers.addList(var_lst, varData.initials); then varData; case (VAR_DATA_SIM(), VarType.START) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.initials := VariablePointers.addList(var_lst, varData.initials); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.initials := VariablePointers.addList(var_lst, varData.initials); then varData; case (VAR_DATA_SIM(), VarType.PARAMETER) algorithm - varData.parameters := VariablePointers.addList(var_lst, varData.parameters); - varData.knowns := VariablePointers.addList(var_lst, varData.knowns); + varData.parameters := VariablePointers.addList(var_lst, varData.parameters); + varData.knowns := VariablePointers.addList(var_lst, varData.knowns); then varData; case (VAR_DATA_SIM(), VarType.ITERATOR) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.knowns := VariablePointers.addList(var_lst, varData.knowns); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.knowns := VariablePointers.addList(var_lst, varData.knowns); then varData; - // IMPORTANT: does not add the record elements! + // IMPORTANT: requires the record elements to be added as children beforehand! case (VAR_DATA_SIM(), VarType.RECORD) algorithm - varData.variables := VariablePointers.addList(var_lst, varData.variables); - varData.records := VariablePointers.addList(var_lst, varData.records); - varData.knowns := VariablePointers.addList(var_lst, varData.knowns); + varData.variables := VariablePointers.addList(var_lst, varData.variables); + varData.records := VariablePointers.addList(var_lst, varData.records); + varData.knowns := VariablePointers.addList(var_lst, varData.knowns); + varData.records := VariablePointers.mapPtr(varData.records, function BackendDAE.lowerRecordChildren(variables = varData.variables)); then varData; // ToDo: other cases diff --git a/OMCompiler/Compiler/NBackEnd/Classes/NBackendDAE.mo b/OMCompiler/Compiler/NBackEnd/Classes/NBackendDAE.mo index 79a3d429910..bda2a6f2e83 100644 --- a/OMCompiler/Compiler/NBackEnd/Classes/NBackendDAE.mo +++ b/OMCompiler/Compiler/NBackEnd/Classes/NBackendDAE.mo @@ -600,7 +600,7 @@ protected end if; end collectVariableBindingIterators; - function lowerRecordChildren + public function lowerRecordChildren input Pointer var_ptr; input VariablePointers variables; protected @@ -623,7 +623,7 @@ protected Pointer.update(var_ptr, var); end lowerRecordChildren; - function lowerEquationData + protected function lowerEquationData "Lowers all equations to backend structure. kabdelhak: Splitting up the creation of the equation array and the equation pointer arrays in two steps is slightly less effective, but way more readable diff --git a/OMCompiler/Compiler/NBackEnd/Modules/1_Main/NBCausalize.mo b/OMCompiler/Compiler/NBackEnd/Modules/1_Main/NBCausalize.mo index 493c0b77e1b..38497dc5622 100644 --- a/OMCompiler/Compiler/NBackEnd/Modules/1_Main/NBCausalize.mo +++ b/OMCompiler/Compiler/NBackEnd/Modules/1_Main/NBCausalize.mo @@ -208,7 +208,7 @@ public Adjacency.Matrix adj; Matching matching; algorithm - // create scalar adjacency matrix for now + // create scalar adjacency matrix for now adj := Adjacency.Matrix.create(vars, eqs, matrixType); matching := Matching.regular(NBMatching.EMPTY_MATCHING, adj); comps := Sorting.tarjan(adj, matching, vars, eqs); diff --git a/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBAlias.mo b/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBAlias.mo index 709c32501f9..40d1792cadf 100644 --- a/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBAlias.mo +++ b/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBAlias.mo @@ -460,9 +460,9 @@ protected guard(BVariable.isParamOrConst(BVariable.getVarPointer(exp.cref)) or ComponentRef.isTime(exp.cref)) then tpl; - // fail for multidimensional crefs for now + // fail for multidimensional crefs and record elements for now case Expression.CREF() - guard(BVariable.size(BVariable.getVarPointer(exp.cref)) > 1) + guard(BVariable.size(BVariable.getVarPointer(exp.cref)) > 1 or Util.isSome(BVariable.getParent(BVariable.getVarPointer(exp.cref)))) then FAILED_CREF_TPL; // variable found diff --git a/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBInline.mo b/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBInline.mo index 915e5ac4438..ceedfd9fca8 100644 --- a/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBInline.mo +++ b/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBInline.mo @@ -62,6 +62,7 @@ protected import NBVariable.{VariablePointers, VarData}; // Util + import Slice = NBSlice; import StringUtil; // ========================================================================= @@ -146,6 +147,33 @@ public end if; end functionInlineable; + function inlineRecords + "also inlines simple record equalities" + input output EqData eqData; + input VariablePointers variables; + protected + Pointer index = EqData.getUniqueIndex(eqData); + Pointer>> new_eqns = Pointer.create({}); + algorithm + eqData := EqData.map(eqData, function inlineRecordEquation(variables = variables, record_eqns = new_eqns, index = index, inlineSimple = true)); + eqData := EqData.addUntypedList(eqData, Pointer.access(new_eqns), false); + eqData := EqData.compress(eqData); + end inlineRecords; + + function inlineRecordSliceEquation + input Slice> slice; + input VariablePointers variables; + input Pointer index; + input Boolean inlineSimple; + output list>> slices; + protected + Pointer>> record_eqns = Pointer.create({}); + algorithm + inlineRecordEquation(Pointer.access(Slice.getT(slice)), variables, record_eqns, index, inlineSimple); + // somehow split slice.indices + slices := list(Slice.SLICE(eqn, {}) for eqn in Pointer.access(record_eqns)); + end inlineRecordSliceEquation; + protected function inline extends Module.inlineInterface; protected @@ -177,13 +205,14 @@ protected end collectInlineFunctions; function inlineRecordsTuples + "does not inline simple record equalities" input output EqData eqData; input VariablePointers variables; protected Pointer index = EqData.getUniqueIndex(eqData); Pointer>> new_eqns = Pointer.create({}); algorithm - eqData := EqData.map(eqData, function inlineRecordEquation(variables = variables, record_eqns = new_eqns, index = index)); + eqData := EqData.map(eqData, function inlineRecordEquation(variables = variables, record_eqns = new_eqns, index = index, inlineSimple = false)); eqData := EqData.map(eqData, function inlineTupleEquation(tuple_eqns = new_eqns, index = index)); eqData := EqData.addUntypedList(eqData, Pointer.access(new_eqns), false); eqData := EqData.compress(eqData); @@ -197,6 +226,7 @@ protected input VariablePointers variables; input Pointer>> record_eqns; input Pointer index; + input Boolean inlineSimple; algorithm eqn := match eqn local @@ -204,14 +234,14 @@ protected Integer size; // don't inline simple cref equalities - case Equation.RECORD_EQUATION(lhs = Expression.CREF(), rhs = Expression.CREF()) then eqn; - case Equation.ARRAY_EQUATION(lhs = Expression.CREF(), rhs = Expression.CREF()) then eqn; + case Equation.RECORD_EQUATION(lhs = Expression.CREF(), rhs = Expression.CREF()) guard(not inlineSimple) then eqn; + case Equation.ARRAY_EQUATION(lhs = Expression.CREF(), rhs = Expression.CREF()) guard(not inlineSimple) then eqn; // try to inline other record equations. try catch to be sure to not discard case Equation.RECORD_EQUATION(ty = Type.COMPLEX()) algorithm try if Flags.isSet(Flags.DUMPBACKENDINLINE) then print("[" + getInstanceName() + "] Inlining: " + Equation.toString(eqn) + "\n"); end if; - new_eqn := inlineRecordEquationWork(eqn.lhs, eqn.rhs, eqn.attr, eqn.source, eqn.recordSize, variables, record_eqns, index); + new_eqn := inlineRecordEquationWork(eqn.lhs, eqn.rhs, eqn.attr, eqn.source, eqn.recordSize, variables, record_eqns, index, inlineSimple); if Flags.isSet(Flags.DUMPBACKENDINLINE) then print("\n"); end if; else // inlining failed, keep old equation @@ -223,7 +253,7 @@ protected case Equation.ARRAY_EQUATION(recordSize = SOME(size)) algorithm try if Flags.isSet(Flags.DUMPBACKENDINLINE) then print("[" + getInstanceName() + "] Inlining: " + Equation.toString(eqn) + "\n"); end if; - new_eqn := inlineRecordEquationWork(eqn.lhs, eqn.rhs, eqn.attr, eqn.source, size, variables, record_eqns, index); + new_eqn := inlineRecordEquationWork(eqn.lhs, eqn.rhs, eqn.attr, eqn.source, size, variables, record_eqns, index, inlineSimple); else // inlining failed, keep old equation new_eqn := eqn; @@ -232,7 +262,7 @@ protected // iterate over body equations of for-loop case Equation.FOR_EQUATION() algorithm - eqn.body := list(inlineRecordEquation(body_eqn, variables, record_eqns, index) for body_eqn in eqn.body); + eqn.body := list(inlineRecordEquation(body_eqn, variables, record_eqns, index, inlineSimple) for body_eqn in eqn.body); then eqn; else eqn; @@ -248,6 +278,7 @@ protected input VariablePointers variables; input Pointer>> record_eqns; input Pointer index; + input Boolean inlineSimple; output Equation new_eqn; protected list> tmp_eqns; @@ -274,7 +305,7 @@ protected // if the equation still has a record type, inline it further if Equation.isRecordEquation(tmp_eqn) then tmp_eqns_ptr := Pointer.create(tmp_eqns); - _ := inlineRecordEquation(Pointer.access(tmp_eqn), variables, tmp_eqns_ptr, index); + _ := inlineRecordEquation(Pointer.access(tmp_eqn), variables, tmp_eqns_ptr, index, inlineSimple); tmp_eqns := Pointer.access(tmp_eqns_ptr); else tmp_eqns := tmp_eqn :: tmp_eqns; diff --git a/OMCompiler/Compiler/NBackEnd/Modules/3_Post/NBTearing.mo b/OMCompiler/Compiler/NBackEnd/Modules/3_Post/NBTearing.mo index d0044b70731..dae73efd795 100644 --- a/OMCompiler/Compiler/NBackEnd/Modules/3_Post/NBTearing.mo +++ b/OMCompiler/Compiler/NBackEnd/Modules/3_Post/NBTearing.mo @@ -57,6 +57,7 @@ protected import BJacobian = NBJacobian; import BVariable = NBVariable; import Differentiate = NBDifferentiate; + import Inline = NBInline; import Jacobian = NBackendDAE.BackendDAE; import Matching = NBMatching; import Sorting = NBSorting; @@ -119,28 +120,30 @@ public bdae := match (systemType, bdae) local list systems; + VariablePointers variables; + Pointer eq_index; - case (NBSystem.SystemType.ODE, BackendDAE.MAIN(ode = systems, funcTree = funcTree)) + case (NBSystem.SystemType.ODE, BackendDAE.MAIN(ode = systems, funcTree = funcTree, varData = BVariable.VAR_DATA_SIM(variables = variables), eqData = BEquation.EQ_DATA_SIM(uniqueIndex = eq_index))) algorithm - (systems, funcTree) := tearingTraverser(systems, func, funcTree, systemType); + (systems, funcTree) := tearingTraverser(systems, func, funcTree, variables, eq_index, systemType); bdae.ode := systems; bdae.funcTree := funcTree; then bdae; - case (NBSystem.SystemType.INI, BackendDAE.MAIN(init = systems, funcTree = funcTree)) + case (NBSystem.SystemType.INI, BackendDAE.MAIN(init = systems, funcTree = funcTree, varData = BVariable.VAR_DATA_SIM(variables = variables), eqData = BEquation.EQ_DATA_SIM(uniqueIndex = eq_index))) algorithm - (systems, funcTree) := tearingTraverser(systems, func, funcTree, systemType); + (systems, funcTree) := tearingTraverser(systems, func, funcTree, variables, eq_index, systemType); bdae.init := systems; if Util.isSome(bdae.init_0) then - (systems, funcTree) := tearingTraverser(Util.getOption(bdae.init_0), func, funcTree, systemType); + (systems, funcTree) := tearingTraverser(Util.getOption(bdae.init_0), func, funcTree, variables, eq_index, systemType); bdae.init_0 := SOME(systems); end if; bdae.funcTree := funcTree; then bdae; - case (NBSystem.SystemType.DAE, BackendDAE.MAIN(dae = SOME(systems), funcTree = funcTree)) + case (NBSystem.SystemType.DAE, BackendDAE.MAIN(dae = SOME(systems), funcTree = funcTree, varData = BVariable.VAR_DATA_SIM(variables = variables), eqData = BEquation.EQ_DATA_SIM(uniqueIndex = eq_index))) algorithm - (systems, funcTree) := tearingTraverser(systems, func, funcTree, systemType); + (systems, funcTree) := tearingTraverser(systems, func, funcTree, variables, eq_index, systemType); bdae.dae := SOME(systems); bdae.funcTree := funcTree; then bdae; @@ -149,7 +152,11 @@ public end match; end main; - function implicit extends Module.tearingInterface; + function implicit + input output StrongComponent comp "the suspected algebraic loop."; + input output FunctionTree funcTree "Function call bodies"; + input output Integer index "current unique loop index"; + input System.SystemType systemType = NBSystem.SystemType.ODE "system type"; algorithm (comp, funcTree, index) := match comp // create implicit equations @@ -160,7 +167,7 @@ public casual = NONE(), linear = false, mixed = false, - status = NBSolve.Status.IMPLICIT), funcTree, index, systemType); + status = NBSolve.Status.IMPLICIT), funcTree, index, VariablePointers.empty(), Pointer.create(0), systemType); case StrongComponent.MULTI_COMPONENT() then tearingNone(StrongComponent.ALGEBRAIC_LOOP( @@ -169,7 +176,7 @@ public casual = NONE(), linear = false, mixed = false, - status = NBSolve.Status.IMPLICIT), funcTree, index, systemType); + status = NBSolve.Status.IMPLICIT), funcTree, index, VariablePointers.empty(), Pointer.create(0), systemType); // do nothing otherwise else (comp, funcTree, index); @@ -222,6 +229,8 @@ protected input Module.tearingInterface func; output list new_systems = {}; input output FunctionTree funcTree; + input VariablePointers variables; + input Pointer eq_index; input System.SystemType systemType; protected array strongComponents; @@ -232,7 +241,7 @@ protected if isSome(syst.strongComponents) then SOME(strongComponents) := syst.strongComponents; for i in 1:arrayLength(strongComponents) loop - (tmp, funcTree, idx) := func(strongComponents[i], funcTree, idx, systemType); + (tmp, funcTree, idx) := func(strongComponents[i], funcTree, idx, variables, eq_index, systemType); // only update if it changed if not referenceEq(tmp, strongComponents[i]) then arrayUpdate(strongComponents, i, tmp); @@ -251,14 +260,27 @@ protected list residual_comps; Option jacobian; Tearing strict; + protected + list> tmp; + list>> acc = {}; algorithm (comp, index) := match comp case StrongComponent.ALGEBRAIC_LOOP(strict = strict) algorithm index := index + 1; comp.idx := index; + for eqn in listReverse(strict.residual_eqns) loop + tmp := Inline.inlineRecordSliceEquation(eqn, variables, eq_index, true); + if listEmpty(tmp) then + acc := {eqn} :: acc; + else + acc := tmp :: acc; + end if; + end for; + // create residual equations - strict.residual_eqns := list(Slice.apply(eqn, function Equation.createResidual(new = true)) for eqn in strict.residual_eqns); + strict.residual_eqns := list(Slice.apply(eqn, function Equation.createResidual(new = true)) for eqn in List.flatten(acc)); + comp.strict := strict; residual_comps := list(StrongComponent.fromSolvedEquationSlice(eqn) for eqn in strict.residual_eqns); // update jacobian to take slices (just to have correct inner variables and such) diff --git a/OMCompiler/Compiler/NBackEnd/Modules/NBModule.mo b/OMCompiler/Compiler/NBackEnd/Modules/NBModule.mo index 93d75fb1413..043311450fe 100644 --- a/OMCompiler/Compiler/NBackEnd/Modules/NBModule.mo +++ b/OMCompiler/Compiler/NBackEnd/Modules/NBModule.mo @@ -287,6 +287,8 @@ public input output StrongComponent comp "the suspected algebraic loop."; input output FunctionTree funcTree "Function call bodies"; input output Integer index "current unique loop index"; + input VariablePointers variables "all variables"; + input Pointer eq_index "equation index"; input System.SystemType systemType = NBSystem.SystemType.ODE "system type"; end tearingInterface; diff --git a/OMCompiler/Compiler/NSimCode/NSimStrongComponent.mo b/OMCompiler/Compiler/NSimCode/NSimStrongComponent.mo index d8270d9257a..eca0e7aeea3 100644 --- a/OMCompiler/Compiler/NSimCode/NSimStrongComponent.mo +++ b/OMCompiler/Compiler/NSimCode/NSimStrongComponent.mo @@ -60,12 +60,13 @@ protected import BackendDAE = NBackendDAE; import BEquation = NBEquation; import NBEquation.{Equation, EquationAttributes, EquationKind, EquationPointer, EquationPointers, WhenEquationBody, WhenStatement, IfEquationBody, Iterator, SlicingStatus}; - import BVariable = NBVariable; import Jacobian = NBJacobian; import Solve = NBSolve; import StrongComponent = NBStrongComponent; import System = NBSystem; import Tearing = NBTearing; + import BVariable = NBVariable; + import NBVariable.VariablePointers; // Old SimCode imports import OldSimCode = SimCode; @@ -452,7 +453,7 @@ public list tmp; algorithm for system in listReverse(systems) loop - BVariable.VariablePointers.map(system.unknowns, function SimVar.traverseCreate(acc = vars_ptr, indices_ptr = indices_ptr, varType = VarType.RESIDUAL)); + VariablePointers.map(system.unknowns, function SimVar.traverseCreate(acc = vars_ptr, indices_ptr = indices_ptr, varType = VarType.RESIDUAL)); (tmp, simCodeIndices) := fromSystem(system, Pointer.access(indices_ptr), simcode_map, equation_map); blcks := tmp :: blcks; end for; @@ -698,6 +699,7 @@ public Block tmp; list names; list ranges; + Pointer>> record_residuals; case (BEquation.SCALAR_EQUATION(), {}) algorithm tmp := RESIDUAL(simCodeIndices.equationIndex, res_idx, eqn.rhs, eqn.source, eqn.attr); @@ -711,7 +713,7 @@ public res_idx := res_idx + Equation.size(Slice.getT(slice)); then tmp; - // for equations have to be split up before. Since they are not causalized they + // for equations have to be split up before. Since they are not causalized // they can be executed in any order case (BEquation.FOR_EQUATION(), {}) guard(listLength(eqn.body) == 1) algorithm rhs := Equation.getRHS(eqn); diff --git a/testsuite/simulation/modelica/NBackend/records/ComplexTest.mos b/testsuite/simulation/modelica/NBackend/records/ComplexTest.mos index 107765e6fb4..833d8fda0e0 100644 --- a/testsuite/simulation/modelica/NBackend/records/ComplexTest.mos +++ b/testsuite/simulation/modelica/NBackend/records/ComplexTest.mos @@ -396,10 +396,9 @@ simulate(ComplexTestNB.T10); getErrorString(); // *************************************** // // -// Created Parameter Binding Equations (2): +// Created Parameter Binding Equations (0): // ****************************************** -// [SCAL] (1) z.re = 1.0 ($RES_BND_5) -// [SCAL] (1) z.im = 1.0 ($RES_BND_4) +// // // Created Record Parameter Binding Equations (0): // *************************************************