diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo index 5c0a5d20772..c0377de39b1 100644 --- a/Compiler/BackEnd/BackendDAEOptimize.mo +++ b/Compiler/BackEnd/BackendDAEOptimize.mo @@ -810,6 +810,9 @@ algorithm end matchcontinue; end simpleEquation; +/* + * remove constant equations + */ protected function removeConstantEqns "autor: Frenkel TUD 2010-12" @@ -850,39 +853,215 @@ algorithm (vars1,eqns,aliasvars) = removeConstantEqns(vars,rest,inAlias); then (vars1,eqns,aliasvars); + case (inVars,eqn::rest,inAlias) + equation + (vars,eqns,aliasvars) = removeConstantEqns(inVars,rest,inAlias); + then + (vars,eqn::eqns,aliasvars); + end matchcontinue; +end removeConstantEqns; + +/* + * remove alias equations + */ + + public function removeAliasEquationsPast +"function lateInlineDAE" + input BackendDAE.BackendDAE inDAE; + input DAE.FunctionTree inFunctionTree; + input BackendDAE.IncidenceMatrix inM; + input BackendDAE.IncidenceMatrix inMT; + input array inAss1; + input array inAss2; + input list> inComps; + output BackendDAE.BackendDAE outDAE; + output BackendDAE.IncidenceMatrix outM; + output BackendDAE.IncidenceMatrix outMT; + output array outAss1; + output array outAss2; + output list> outComps; + output Boolean outRunMatching; +protected + Option om,omT; +algorithm + (outDAE,om,omT) := removeAliasEquations(inDAE,inFunctionTree,SOME(inM),SOME(inMT)); + (outM,outMT) := BackendDAEUtil.getIncidenceMatrixfromOption(outDAE,om,omT); + outAss1 := inAss1; + outAss2 := inAss2; + outComps := inComps; + outRunMatching := false; +end removeAliasEquationsPast; + +public function removeAliasEquations +"function: removeAliasEquations" + input BackendDAE.BackendDAE inDAE; + input DAE.FunctionTree inFunctionTree; + input Option inM; + input Option inMT; + output BackendDAE.BackendDAE outDAE; + output Option outM; + output Option outMT; +algorithm + (outDAE,outM,outMT):= + match (inDAE,inFunctionTree,inM,inMT) + local + DAE.FunctionTree funcs; + Option m,mT; + BackendDAE.Variables vars,vars_1,knvars,exobj,knvars_1; + BackendDAE.AliasVariables av,varsAliases; + BackendDAE.EquationArray eqns,eqns1,remeqns,remeqns1,inieqns,inieqns1; + array arreqns; + array algorithms; + BackendDAE.EventInfo einfo; + BackendDAE.ExternalObjectClasses eoc; + list reqns,reqns_1; + list algs; + + case (BackendDAE.DAE(vars,knvars,exobj,av,eqns,remeqns,inieqns,arreqns,algorithms,einfo,eoc),funcs,m,mT) + equation + reqns = BackendDAEUtil.equationList(remeqns); + (knvars_1,reqns_1,varsAliases,vars_1) = removeAliasEquations1(knvars,reqns,av,vars); + Debug.fcall("dumpalias", BackendDump.dumpAliasVariables, varsAliases); + remeqns1 = BackendDAEUtil.listEquation(reqns_1); + then + (BackendDAE.DAE(vars_1,knvars_1,exobj,varsAliases,eqns,remeqns1,inieqns,arreqns,algorithms,einfo,eoc),m,mT); + end match; +end removeAliasEquations; + +protected function removeAliasEquations1 +"autor: Frenkel TUD 2010-12" + input BackendDAE.Variables inKnVars; + input list inEqns; + input BackendDAE.AliasVariables inAlias; + input BackendDAE.Variables inVars; + output BackendDAE.Variables outKnVars; + output list outEqns; + output BackendDAE.AliasVariables outAlias; + output BackendDAE.Variables outVars; +algorithm + (outKnVars,outEqns,outAlias,outVars) := + matchcontinue (inKnVars,inEqns,inAlias,inVars) + local + BackendDAE.Variables vars,vars1,knvars,knvars1; + BackendDAE.Var var,var2,var3; + DAE.ComponentRef cr,vcr; + DAE.Exp e; + BackendDAE.Equation eqn; + list rest,eqns; + BackendDAE.AliasVariables aliasvars,aliasvars1; + Boolean negate; + case (inKnVars,{},inAlias,inVars) then (inKnVars,{},inAlias,inVars); // alias vars - case (inVars,(eqn as BackendDAE.SOLVED_EQUATION(componentRef=cr,exp=e))::rest,inAlias) + case (inKnVars,(eqn as BackendDAE.SOLVED_EQUATION(componentRef=cr,exp=e))::rest,inAlias,inVars) equation // test exp - removeConstantEqns1(e); + (vcr,negate) = removeAliasEquations2(e); // get var - ({var},_) = BackendVariable.getVar(cr,inVars); + ({var},_) = BackendVariable.getVar(cr,inKnVars); // add bindExp - var2 = BackendVariable.setBindExp(var,e); + var2 = BackendVariable.setBindExp(var,e); // add aliasvars = BackendDAEUtil.addAliasVariables(inAlias,var2,e); + // set attributes + vars = mergeAliasVarAttributes(var,vcr,inVars,negate); // next - (vars,eqns,aliasvars1) = removeConstantEqns(inVars,rest,aliasvars); + (knvars,eqns,aliasvars1,vars1) = removeAliasEquations1(inKnVars,rest,aliasvars,vars); then - (vars,eqn::eqns,aliasvars1); - case (inVars,eqn::rest,inAlias) + (knvars,eqns,aliasvars1,vars1); + case (inKnVars,eqn::rest,inAlias,inVars) equation - (vars,eqns,aliasvars) = removeConstantEqns(inVars,rest,inAlias); + (knvars,eqns,aliasvars,vars) = removeAliasEquations1(inKnVars,rest,inAlias,inVars); then - (vars,eqn::eqns,aliasvars); + (knvars,eqn::eqns,aliasvars,vars); end matchcontinue; -end removeConstantEqns; +end removeAliasEquations1; -protected function removeConstantEqns1 +protected function removeAliasEquations2 "autor: Frenkel TUD 2010-12" input DAE.Exp inExp; + output DAE.ComponentRef ouCref; + output Boolean negate; algorithm - _ := + (ouCref,negate) := match (inExp) - case (DAE.CREF(componentRef=_)) then (); - case (DAE.UNARY(exp = DAE.CREF(componentRef=_))) then (); + local DAE.ComponentRef cr; + case (DAE.CREF(componentRef=cr)) then (cr,false); + case (DAE.UNARY(exp = DAE.CREF(componentRef=cr))) then (cr,true); end match; -end removeConstantEqns1; +end removeAliasEquations2; + +protected function mergeAliasVarAttributes + input BackendDAE.Var inAVar; + input DAE.ComponentRef inCref; + input BackendDAE.Variables inVars; + input Boolean negate; + output BackendDAE.Variables outVars; +algorithm + outVars := + matchcontinue (inAVar,inCref,inVars,negate) + local + DAE.ComponentRef name,cr; + BackendDAE.Var v,var,var1,var2; + BackendDAE.Variables vars; + Boolean fixeda, fixedb,starta,startb; + case (v as BackendDAE.VAR(varName=name),cr,inVars,negate) + equation + ((var :: _),_) = BackendVariable.getVar(cr,inVars); + // fixed + fixeda = BackendVariable.varFixed(v); + fixedb = BackendVariable.varFixed(var); + var1 = BackendVariable.setVarFixed(var,fixeda or fixedb); + // start + var2 = mergeStartAttribute(v,var1,negate); + // update vars + vars = BackendVariable.addVar(var2,inVars); + then vars; + case(_,_,inVars,negate) then inVars; + end matchcontinue; +end mergeAliasVarAttributes; + +protected function mergeStartAttribute + input BackendDAE.Var inAVar; + input BackendDAE.Var inVar; + input Boolean negate; + output BackendDAE.Var outVar; +algorithm + outVar := + matchcontinue (inAVar,inVar,negate) + local + BackendDAE.Var v,var,var1; + Option attr,attr1; + DAE.Exp e,e1; + case (v as BackendDAE.VAR(values = attr),var as BackendDAE.VAR(values = attr1),negate) + equation + // start + e = BackendVariable.varStartValueFail(v); + mergeStartAttribute1(attr1); + e1 = Util.if_(negate,Expression.negate(e),e); + var1 = BackendVariable.setVarStartValue(var,e1); + then var1; + case(_,inVar,_) then inVar; + end matchcontinue; +end mergeStartAttribute; + +protected function mergeStartAttribute1 + input Option attr; +algorithm + () := + matchcontinue (attr) + local + DAE.Exp e; + case (attr) + equation + false = DAEUtil.hasStartAttr(attr); + then (); + case (attr) + equation + e = DAEUtil.getStartAttr(attr); + true = Expression.isZero(e); + then (); + end matchcontinue; +end mergeStartAttribute1; /* * remove parameter equations diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo index a309715b86a..9393c68240d 100644 --- a/Compiler/BackEnd/BackendDAEUtil.mo +++ b/Compiler/BackEnd/BackendDAEUtil.mo @@ -772,6 +772,25 @@ algorithm end match; end calculateSizes; +public function numberOfZeroCrossings "function: numberOfZeroCrossings + author: Frenkel TUD" + input BackendDAE.BackendDAE inBackendDAE; + output Integer outng "number of zerocrossings"; + output Integer outng_sample "number of zerocrossings that are samples"; +algorithm + (outng,outng_sample):= + match (inBackendDAE) + local + BackendDAE.Value ng,nsam; + list zc; + case (BackendDAE.DAE(eventInfo = BackendDAE.EVENT_INFO(zeroCrossingLst = zc))) + equation + (ng,nsam) = calculateNumberZeroCrossings(zc, 0, 0); + then + (ng,nsam); + end match; +end numberOfZeroCrossings; + protected function calculateNumberZeroCrossings input list zcLst; input Integer zc_index; @@ -5547,6 +5566,7 @@ protected algorithm allPreOptModules := {(BackendDAEOptimize.removeSimpleEquations,"removeSimpleEquations"), (BackendDAEOptimize.removeParameterEqns,"removeParameterEqns"), + (BackendDAEOptimize.removeAliasEquations,"removeAliasEquations"), (BackendDAECreate.expandDerOperator,"expandDerOperator")}; preOptModules := selectOptModules(strPreOptModules,allPreOptModules,{}); preOptModules := listReverse(preOptModules); @@ -5577,6 +5597,7 @@ protected algorithm allPastOptModules := {(BackendDAEOptimize.lateInline,"lateInline"), (BackendDAEOptimize.removeSimpleEquationsPast,"removeSimpleEquations"), + (BackendDAEOptimize.removeAliasEquationsPast,"removeAliasEquations"), (BackendDump.dumpComponentsGraphStr,"dumpComponentsGraphStr")}; pastOptModules := selectOptModules(strPastOptModules,allPastOptModules,{}); pastOptModules := listReverse(pastOptModules); diff --git a/Compiler/BackEnd/BackendDump.mo b/Compiler/BackEnd/BackendDump.mo index adcb7bab082..cd6b727d491 100644 --- a/Compiler/BackEnd/BackendDump.mo +++ b/Compiler/BackEnd/BackendDump.mo @@ -552,6 +552,9 @@ algorithm print(")\n"); print("=============================\n"); dumpExtObjCls(extObjCls); + + dumpAliasVariables(av); + print("\nEquations ("); eqnsl = BackendDAEUtil.equationList(eqns); eqnlen = listLength(eqnsl); diff --git a/Compiler/BackEnd/BackendVariable.mo b/Compiler/BackEnd/BackendVariable.mo index 895cff84cda..493fbd61060 100644 --- a/Compiler/BackEnd/BackendVariable.mo +++ b/Compiler/BackEnd/BackendVariable.mo @@ -139,18 +139,13 @@ algorithm Option f; list g; BackendDAE.Value i; - DAE.ElementSource source "the element source"; - Option l,m,n; - tuple, Option> o; - Option p,q; - Option r; + DAE.ElementSource source; + DAE.VariableAttributes attr; + Option oattr; Option s; DAE.Flow t; DAE.Stream streamPrefix; Boolean fixed; - Option equationBound; - Option isProtected; - Option finalPrefix; case (BackendDAE.VAR(varName = a, varKind = b, @@ -161,67 +156,13 @@ algorithm arryDim = g, index = i, source = source, - values = SOME(DAE.VAR_ATTR_REAL(l,m,n,o,p,_,q,r,equationBound,isProtected,finalPrefix)), + values = SOME(attr), comment = s, flowPrefix = t, streamPrefix = streamPrefix),fixed) - then BackendDAE.VAR(a,b,c,d,e,f,g,i,source, - SOME(DAE.VAR_ATTR_REAL(l,m,n,o,p,SOME(DAE.BCONST(fixed)),q,r,equationBound,isProtected,finalPrefix)), - s,t,streamPrefix); - - case (BackendDAE.VAR(varName = a, - varKind = b, - varDirection = c, - varType = d, - bindExp = e, - bindValue = f, - arryDim = g, - index = i, - source = source, - values = SOME(DAE.VAR_ATTR_INT(l,o,n,_,equationBound,isProtected,finalPrefix)), - comment = s, - flowPrefix = t, - streamPrefix = streamPrefix),fixed) - then - BackendDAE.VAR(a,b,c,d,e,f,g,i,source, - SOME(DAE.VAR_ATTR_INT(l,o,n,SOME(DAE.BCONST(fixed)),equationBound,isProtected,finalPrefix)), - s,t,streamPrefix); - - case (BackendDAE.VAR(varName = a, - varKind = b, - varDirection = c, - varType = d, - bindExp = e, - bindValue = f, - arryDim = g, - index = i, - source = source, - values = SOME(DAE.VAR_ATTR_BOOL(l,m,_,equationBound,isProtected,finalPrefix)), - comment = s, - flowPrefix = t, - streamPrefix = streamPrefix),fixed) - then - BackendDAE.VAR(a,b,c,d,e,f,g,i,source, - SOME(DAE.VAR_ATTR_BOOL(l,m,SOME(DAE.BCONST(fixed)),equationBound,isProtected,finalPrefix)), - s,t,streamPrefix); - - case (BackendDAE.VAR(varName = a, - varKind = b, - varDirection = c, - varType = d, - bindExp = e, - bindValue = f, - arryDim = g, - index = i, - source = source, - values = SOME(DAE.VAR_ATTR_ENUMERATION(l,o,n,_,equationBound,isProtected,finalPrefix)), - comment = s, - flowPrefix = t, - streamPrefix = streamPrefix),fixed) - then - BackendDAE.VAR(a,b,c,d,e,f,g,i,source, - SOME(DAE.VAR_ATTR_ENUMERATION(l,o,n,SOME(DAE.BCONST(fixed)),equationBound,isProtected,finalPrefix)), - s,t,streamPrefix); + equation + oattr = DAEUtil.setFixedAttr(SOME(attr),SOME(DAE.BCONST(fixed))); + then BackendDAE.VAR(a,b,c,d,e,f,g,i,source,oattr,s,t,streamPrefix); case (BackendDAE.VAR(varName = a, varKind = b, @@ -334,6 +275,122 @@ algorithm end matchcontinue; end varFixed; +public function setVarStartValue +"function: setVarStartValue + author: Frenkel TUD + Sets the start value attribute of a variable." + input BackendDAE.Var inVar; + input DAE.Exp inExp; + output BackendDAE.Var outVar; +algorithm + outVar := match (inVar,inExp) + local + DAE.ComponentRef a; + BackendDAE.VarKind b; + DAE.VarDirection c; + BackendDAE.Type d; + Option e; + Option f; + list g; + BackendDAE.Value i; + DAE.ElementSource source; + DAE.VariableAttributes attr; + Option oattr,oattr1; + Option s; + DAE.Flow t; + DAE.Stream streamPrefix; + + case (BackendDAE.VAR(varName = a, + varKind = b, + varDirection = c, + varType = d, + bindExp = e, + bindValue = f, + arryDim = g, + index = i, + source = source, + values = SOME(attr), + comment = s, + flowPrefix = t, + streamPrefix = streamPrefix),inExp) + equation + oattr1 = DAEUtil.setStartAttr(SOME(attr),inExp); + then BackendDAE.VAR(a,b,c,d,e,f,g,i,source,oattr1,s,t,streamPrefix); + + case (BackendDAE.VAR(varName = a, + varKind = b, + varDirection = c, + varType = BackendDAE.REAL(), + bindExp = e, + bindValue = f, + arryDim = g, + index = i, + source = source, + values = NONE(), + comment = s, + flowPrefix = t, + streamPrefix = streamPrefix),inExp) + then + BackendDAE.VAR(a,b,c,BackendDAE.REAL(),e,f,g,i,source, + SOME(DAE.VAR_ATTR_REAL(NONE(),NONE(),NONE(),(NONE(),NONE()),SOME(inExp),NONE(),NONE(),NONE(),NONE(),NONE(),NONE())), + s,t,streamPrefix); + + case (BackendDAE.VAR(varName = a, + varKind = b, + varDirection = c, + varType = BackendDAE.INT(), + bindExp = e, + bindValue = f, + arryDim = g, + index = i, + source = source, + values = NONE(), + comment = s, + flowPrefix = t, + streamPrefix = streamPrefix),inExp) + then + BackendDAE.VAR(a,b,c,BackendDAE.REAL(),e,f,g,i,source, + SOME(DAE.VAR_ATTR_INT(NONE(),(NONE(),NONE()),SOME(inExp),NONE(),NONE(),NONE(),NONE())), + s,t,streamPrefix); + + case (BackendDAE.VAR(varName = a, + varKind = b, + varDirection = c, + varType = BackendDAE.BOOL(), + bindExp = e, + bindValue = f, + arryDim = g, + index = i, + source = source, + values = NONE(), + comment = s, + flowPrefix = t, + streamPrefix = streamPrefix),inExp) + then + BackendDAE.VAR(a,b,c,BackendDAE.REAL(),e,f,g,i,source, + SOME(DAE.VAR_ATTR_BOOL(NONE(),SOME(inExp),NONE(),NONE(),NONE(),NONE())), + s,t,streamPrefix); + + case (BackendDAE.VAR(varName = a, + varKind = b, + varDirection = c, + varType = BackendDAE.ENUMERATION(_), + bindExp = e, + bindValue = f, + arryDim = g, + index = i, + source = source, + values = NONE(), + comment = s, + flowPrefix = t, + streamPrefix = streamPrefix),inExp) + then + BackendDAE.VAR(a,b,c,BackendDAE.REAL(),e,f,g,i,source, + SOME(DAE.VAR_ATTR_ENUMERATION(NONE(),(NONE(),NONE()),SOME(inExp),NONE(),NONE(),NONE(),NONE())), + s,t,streamPrefix); + end match; +end setVarStartValue; + public function varStartValue "function varStartValue author: PA diff --git a/Compiler/BackEnd/SimCode.mo b/Compiler/BackEnd/SimCode.mo index c75f962689a..73dc9883e41 100644 --- a/Compiler/BackEnd/SimCode.mo +++ b/Compiler/BackEnd/SimCode.mo @@ -192,9 +192,9 @@ uniontype VarInfo Integer numAlgVars; Integer numIntAlgVars; Integer numBoolAlgVars; - Integer numAliasAlgVars; - Integer numAliasIntAlgVars; - Integer numAliasBoolAlgVars; + Integer numAlgAliasVars; + Integer numIntAliasVars; + Integer numBoolAliasVars; Integer numParams; Integer numIntParams; Integer numBoolParams; @@ -204,6 +204,7 @@ uniontype VarInfo Integer numExternalObjects; Integer numStringAlgVars; Integer numStringParamVars; + Integer numStringAliasVars; Integer numJacobianVars; end VARINFO; end VarInfo; @@ -218,11 +219,15 @@ uniontype SimVars list boolAlgVars; list inputVars; list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; list paramVars; list intParamVars; list boolParamVars; list stringAlgVars; list stringParamVars; + list stringAliasVars; list extObjVars; list jacobianVars; //all vars for the matrices A,B,C,D end SIMVARS; @@ -940,7 +945,8 @@ algorithm funcs = Env.getFunctionTree(cache); dlow = BackendDAECreate.lower(dae,funcs,true); preOptModules = {"removeSimpleEquations","removeParameterEqns","expandDerOperator"}; - pastOptModules = {"lateInline","removeSimpleEquations"}; + pastOptModules = Util.listConsOnTrue(RTOpts.debugFlag("removeAliasEquations"),"removeAliasEquations",{}); + pastOptModules = "lateInline"::("removeSimpleEquations"::pastOptModules); (dlow_1,m,mT,ass1,ass2,comps) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, preOptModules, BackendDAETransform.dummyDerivative, pastOptModules); Debug.fprintln("dynload", "translateModel: Generating simulation code and functions."); @@ -1069,7 +1075,8 @@ algorithm funcs = Env.getFunctionTree(cache); dlow = BackendDAECreate.lower(dae,funcs,true); preOptModules = {"removeSimpleEquations","removeParameterEqns","expandDerOperator"}; - pastOptModules = {"lateInline","removeSimpleEquations"}; + pastOptModules = Util.listConsOnTrue(RTOpts.debugFlag("removeAliasEquations"),"removeAliasEquations",{}); + pastOptModules = "lateInline"::("removeSimpleEquations"::pastOptModules); (dlow_1,m,mT,ass1,ass2,comps) = BackendDAEUtil.getSolvedSystem(cache, env, dlow, funcs, preOptModules, BackendDAETransform.dummyDerivative, pastOptModules); (indexed_dlow_1,libs,file_dir,timeBackend,timeSimCode,timeTemplates) = @@ -2037,19 +2044,19 @@ algorithm VarInfo varinfo; list functions; Integer nx, ny, np, ng, ng_sam, ng_sam_1, next, ny_string, np_string, ng_1; - Integer nhv,nin, nresi, nout, ny_int, np_int, ny_bool, np_bool, na, na_int, na_bool; + Integer nhv,nin, nresi, nout, ny_int, np_int, ny_bool, np_bool, na, na_int, na_bool, na_string; Integer njacvars; case(inJacs,minfo as (MODELINFO(name,dir,VARINFO(nhv, ng_1, ng_sam_1, nx, ny, ny_int, ny_bool, na, na_int, na_bool, np, np_int, np_bool, nout, nin, - nresi, next, ny_string, np_string,_),vars,functions))) + nresi, next, ny_string, np_string, na_string,_),vars,functions))) equation jacvars = appendAllVars(inJacs); jacvars = rewriteIndex(jacvars,0); njacvars = listLength(jacvars); - linearVars = SIMVARS({}, {}, {}, {}, {}, {}, {}, {}, {},{},{},{},{},jacvars); + linearVars = SIMVARS({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {},{},{},{},{},{},jacvars); simvarsandlinearvars = mergeVars(vars,linearVars); then MODELINFO(name, dir, VARINFO(nhv, ng_1, ng_sam_1, nx, ny, ny_int, ny_bool, na, na_int, na_bool, np, np_int, np_bool, nout, nin, - nresi, next, ny_string, np_string,njacvars), simvarsandlinearvars, functions); + nresi, next, ny_string, np_string, na_string, njacvars), simvarsandlinearvars, functions); end match; end expandModelInfoVars; @@ -5077,10 +5084,12 @@ algorithm array ae; array al; BackendDAE.EventInfo ev; - list resEqus1,resEqus2,resEqus3,resEqus4; + list resEqus1,resEqus2,resEqus3,resEqus4; + BackendDAE.AliasVariables av; case ((dlow as BackendDAE.DAE(orderedVars=vars, knownVars=knvars, + aliasVars=av, orderedEqs=eqns, removedEqs=se, initialEqs=ie, @@ -5089,8 +5098,8 @@ algorithm eventInfo=ev)), ass1, ass2) equation - ie2_lst = BackendVariable.traverseBackendDAEVars(vars,generateInitialEquationsFromStart,{}); - ie2_lst = BackendVariable.traverseBackendDAEVars(knvars,generateInitialEquationsFromStart,ie2_lst); + ((ie2_lst,_)) = BackendVariable.traverseBackendDAEVars(vars,generateInitialEquationsFromStart,({},av)); + ((ie2_lst,_)) = BackendVariable.traverseBackendDAEVars(knvars,generateInitialEquationsFromStart,(ie2_lst,av)); ie2_lst = listReverse(ie2_lst); ((_,_,_,eqns_lst)) = BackendEquation.traverseBackendDAEEqns(eqns,selectContinuousEquations,(1, ass2, vars,{})); eqns_lst = listReverse(eqns_lst); @@ -5188,15 +5197,16 @@ algorithm BackendDAE.Variables vars,knvars; array algs; list initialEquationsTmp,initialEquationsTmp2; + BackendDAE.AliasVariables av; // this is the old version if the new fails - case (BackendDAE.DAE(orderedVars=vars, knownVars=knvars,algorithms=algs)) + case (BackendDAE.DAE(orderedVars=vars, knownVars=knvars, aliasVars=av, algorithms=algs)) equation // vars - initialEquationsTmp2 = BackendVariable.traverseBackendDAEVars(vars,createInitialAssignmentsFromStart,{}); + ((initialEquationsTmp2,_)) = BackendVariable.traverseBackendDAEVars(vars,createInitialAssignmentsFromStart,({},av)); initialEquationsTmp2 = listReverse(initialEquationsTmp2); // kvars - initialEquationsTmp = BackendVariable.traverseBackendDAEVars(knvars,createInitialAssignmentsFromStart,{}); + ((initialEquationsTmp,_)) = BackendVariable.traverseBackendDAEVars(knvars,createInitialAssignmentsFromStart,({},av)); initialEquationsTmp = listReverse(initialEquationsTmp); initialEquationsTmp2 = listAppend(initialEquationsTmp2, initialEquationsTmp); @@ -5280,8 +5290,8 @@ algorithm end createParameterEquations; protected function createInitialAssignmentsFromStart - input tuple> inTpl; - output tuple> outTpl; + input tuple,BackendDAE.AliasVariables>> inTpl; + output tuple,BackendDAE.AliasVariables>> outTpl; algorithm outTpl:= matchcontinue (inTpl) @@ -5292,19 +5302,21 @@ algorithm Option attr; DAE.ComponentRef name; DAE.Exp startv; - DAE.ElementSource source "the origin of the element"; + DAE.ElementSource source; + BackendDAE.AliasVariables av; // also add an assignment for variables that have non-constant // expressions, e.g. parameter values, as start. NOTE: such start // attributes can then not be changed in the text file, since the initial // calc. will override those entries! - case ((var as BackendDAE.VAR(values=attr, varName=name, source=source),eqns)) + case ((var as BackendDAE.VAR(values=attr, varName=name, source=source),(eqns,av))) equation + NOALIAS() = getAliasVar(var,SOME(av)); startv = DAEUtil.getStartAttr(attr); false = Expression.isConst(startv); initialEquation = BackendDAE.SOLVED_EQUATION(name, startv, source); then - ((var,initialEquation :: eqns)); + ((var,(initialEquation :: eqns,av))); case (inTpl) then inTpl; end matchcontinue; @@ -5543,20 +5555,51 @@ algorithm String directory; VarInfo varInfo; SimVars vars; - Integer numOutVars; - Integer numInVars; - list iv; - list ov; + list stateVars; + list algVars; + list intAlgVars; + list boolAlgVars; + list inputVars; + list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; + list paramVars; + list intParamVars; + list boolParamVars; + list stringAlgVars; + list stringParamVars; + list stringAliasVars; + list extObjVars; + Integer nx,ny,np,na,next,numOutVars,numInVars,ny_int,np_int,na_int,ny_bool,np_bool; + Integer na_bool,ny_string,np_string,na_string; case (class_, dlow, functions, numHelpVars, numResiduals, fileDir) equation //name = Absyn.pathString(class_); directory = System.trim(fileDir, "\""); vars = createVars(dlow); - SIMVARS(inputVars=iv, outputVars=ov) = vars; - numOutVars = listLength(ov); - numInVars = listLength(iv); - varInfo = createVarInfo(dlow, numOutVars, numInVars, numHelpVars, - numResiduals); + SIMVARS(stateVars=stateVars,algVars=algVars,intAlgVars=intAlgVars,boolAlgVars=boolAlgVars, + inputVars=inputVars,outputVars=outputVars,aliasVars=aliasVars,intAliasVars=intAliasVars,boolAliasVars=boolAliasVars, + paramVars=paramVars,intParamVars=intParamVars,boolParamVars=boolParamVars,stringAlgVars=stringAlgVars, + stringParamVars=stringParamVars,stringAliasVars=stringAliasVars,extObjVars=extObjVars) = vars; + nx = listLength(stateVars); + ny = listLength(algVars); + ny_int = listLength(intAlgVars); + ny_bool = listLength(boolAlgVars); + numOutVars = listLength(outputVars); + numInVars = listLength(inputVars); + na = listLength(aliasVars); + na_int = listLength(intAliasVars); + na_bool = listLength(boolAliasVars); + np = listLength(paramVars); + np_int = listLength(intParamVars); + np_bool = listLength(boolParamVars); + ny_string = listLength(stringAlgVars); + np_string = listLength(stringParamVars); + na_string = listLength(stringAliasVars); + next = listLength(extObjVars); + varInfo = createVarInfo(dlow,nx, ny, np, na, next, numOutVars, numInVars, numHelpVars, numResiduals, + ny_int, np_int, na_int, ny_bool, np_bool, na_bool, ny_string, np_string, na_string); then MODELINFO(class_, directory, varInfo, vars, functions); else @@ -5569,30 +5612,41 @@ end createModelInfo; protected function createVarInfo input BackendDAE.BackendDAE dlow; + input Integer nx; + input Integer ny; + input Integer np; + input Integer na; + input Integer next; input Integer numOutVars; input Integer numInVars; input Integer numHelpVars; input Integer numResiduals; + input Integer ny_int; + input Integer np_int; + input Integer na_int; + input Integer ny_bool; + input Integer np_bool; + input Integer na_bool; + input Integer ny_string; + input Integer np_string; + input Integer na_string; output VarInfo varInfo; algorithm varInfo := - matchcontinue (dlow, numOutVars, numInVars, numHelpVars, numResiduals) + matchcontinue (dlow, nx, ny, np, na, next, numOutVars, numInVars, numHelpVars, numResiduals, + ny_int, np_int, na_int, ny_bool, np_bool, na_bool, ny_string, np_string, na_string) local - Integer nx, ny, np, ng, ng_sam, ng_sam_1, next, ny_string, np_string, ng_1; - Integer ny_int, np_int, ny_bool, np_bool, na, na_int, na_bool; - case (dlow, numOutVars, numInVars, numHelpVars, numResiduals) + Integer ng, ng_sam, ng_sam_1, ng_1; + case (dlow, nx, ny, np, na, next, numOutVars, numInVars, numHelpVars, numResiduals, + ny_int, np_int, na_int, ny_bool, np_bool, na_bool, ny_string, np_string, na_string) equation - (nx, ny, np, ng, ng_sam, next, ny_string, np_string, ny_int, np_int, ny_bool, np_bool) = - BackendDAEUtil.calculateSizes(dlow); + (ng, ng_sam) = BackendDAEUtil.numberOfZeroCrossings(dlow); ng_1 = filterNg(ng); ng_sam_1 = filterNg(ng_sam); - na = 0; - na_int = 0; - na_bool = 0; then VARINFO(numHelpVars, ng_1, ng_sam_1, nx, ny, ny_int, ny_bool, na, na_int, na_bool, np, np_int, np_bool, numOutVars, numInVars, - numResiduals, next, ny_string, np_string,0); - case (_,_,_,_,_) + numResiduals, next, ny_string, np_string, na_string, 0); + case (_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_) equation Error.addMessage(Error.INTERNAL_ERROR, {"createVarInfo failed"}); then @@ -5620,7 +5674,7 @@ algorithm initialEqs=ie)) equation /* Extract from variable list */ - ((varsOut,_,_)) = BackendVariable.traverseBackendDAEVars(vars,extractVarsFromList,(SIMVARS({}, {}, {}, {}, {}, {}, {}, {}, {},{},{},{},{},{}),aliasVars,knvars)); + ((varsOut,_,_)) = BackendVariable.traverseBackendDAEVars(vars,extractVarsFromList,(SIMVARS({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {},{},{},{},{},{},{}),aliasVars,knvars)); /* Extract from known variable list */ ((varsOut,_,_)) = BackendVariable.traverseBackendDAEVars(knvars,extractVarsFromList,(varsOut,aliasVars,knvars)); /* Extract from external object list */ @@ -5662,12 +5716,12 @@ end extractVarsFromList; // of algvars for example protected function extractVarFromVar input BackendDAE.Var dlowVar; - input BackendDAE.AliasVariables aliasVars; + input BackendDAE.AliasVariables inAliasVars; input BackendDAE.Variables inVars; output SimVars varsOut; algorithm varsOut := - match (dlowVar,aliasVars,inVars) + match (dlowVar,inAliasVars,inVars) local list stateVars; list derivativeVars; @@ -5676,16 +5730,21 @@ algorithm list boolAlgVars; list inputVars; list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; list paramVars; list intParamVars; list boolParamVars; list stringAlgVars; list stringParamVars; + list stringAliasVars; list extObjVars; SimVar simvar; SimVar derivSimvar; BackendDAE.Variables v; - case (dlowVar,aliasVars,v) + Boolean isalias; + case (dlowVar,inAliasVars,v) equation /* start with empty lists */ stateVars = {}; @@ -5695,45 +5754,59 @@ algorithm boolAlgVars = {}; inputVars = {}; outputVars = {}; + aliasVars = {}; + intAliasVars = {}; + boolAliasVars = {}; paramVars = {}; intParamVars = {}; boolParamVars = {}; stringAlgVars = {}; stringParamVars = {}; + stringAliasVars = {}; extObjVars = {}; /* extract the sim var */ - simvar = dlowvarToSimvar(dlowVar,SOME(aliasVars),v); + simvar = dlowvarToSimvar(dlowVar,SOME(inAliasVars),v); derivSimvar = derVarFromStateVar(simvar); + isalias = isAliasVar(simvar); /* figure out in which lists to put it */ - stateVars = addSimvarIfTrue( + stateVars = addSimvarIfTrue((not isalias) and BackendVariable.isStateVar(dlowVar), simvar, stateVars); - derivativeVars = addSimvarIfTrue( + derivativeVars = addSimvarIfTrue((not isalias) and BackendVariable.isStateVar(dlowVar), derivSimvar, derivativeVars); - algVars = addSimvarIfTrue( + algVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarAlg(dlowVar), simvar, algVars); - intAlgVars = addSimvarIfTrue( + intAlgVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarIntAlg(dlowVar), simvar, intAlgVars); - boolAlgVars = addSimvarIfTrue( + boolAlgVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarBoolAlg(dlowVar), simvar, boolAlgVars); - inputVars = addSimvarIfTrue( + inputVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarOnTopLevelAndInput(dlowVar), simvar, inputVars); - outputVars = addSimvarIfTrue( + outputVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarOnTopLevelAndOutput(dlowVar), simvar, outputVars); - paramVars = addSimvarIfTrue( + paramVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarParam(dlowVar), simvar, paramVars); - intParamVars = addSimvarIfTrue( + intParamVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarIntParam(dlowVar), simvar, intParamVars); - boolParamVars = addSimvarIfTrue( + boolParamVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarBoolParam(dlowVar), simvar, boolParamVars); - stringAlgVars = addSimvarIfTrue( + stringAlgVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarStringAlg(dlowVar), simvar, stringAlgVars); - stringParamVars = addSimvarIfTrue( + stringParamVars = addSimvarIfTrue((not isalias) and BackendVariable.isVarStringParam(dlowVar), simvar, stringParamVars); - extObjVars = addSimvarIfTrue( + extObjVars = addSimvarIfTrue((not isalias) and BackendVariable.isExtObj(dlowVar), simvar, extObjVars); + aliasVars = addSimvarIfTrue( isalias and + BackendVariable.isVarAlg(dlowVar), simvar, aliasVars); + intAliasVars = addSimvarIfTrue( isalias and + BackendVariable.isVarIntAlg(dlowVar), simvar, intAliasVars); + boolAliasVars = addSimvarIfTrue( isalias and + BackendVariable.isVarBoolAlg(dlowVar), simvar, boolAliasVars); + stringAliasVars = addSimvarIfTrue( isalias and + BackendVariable.isVarStringAlg(dlowVar), simvar, stringAliasVars); then SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, outputVars, - paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, extObjVars,{}); + aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,{}); end match; end extractVarFromVar; @@ -5783,6 +5856,19 @@ algorithm end match; end addSimvarIfTrue; +protected function isAliasVar + input SimVar var; + output Boolean res; +algorithm + res := + match (var) + case (SIMVAR(aliasvar=NOALIAS())) + then false; + else + then true; + end match; +end isAliasVar; + protected function mergeVars input SimVars vars1; input SimVars vars2; @@ -5799,6 +5885,9 @@ algorithm list inputVars, inputVars1, inputVars2; list outputVars, outputVars1, outputVars2; list paramVars, paramVars1, paramVars2; + list aliasVars, intAliasVars, boolAliasVars, stringAliasVars; + list aliasVars1, intAliasVars1, boolAliasVars1, stringAliasVars1; + list aliasVars2, intAliasVars2, boolAliasVars2, stringAliasVars2; list intParamVars, intParamVars1, intParamVars2; list boolParamVars, boolParamVars1, boolParamVars2; list stringAlgVars, stringAlgVars1, stringAlgVars2; @@ -5806,11 +5895,11 @@ algorithm list extObjVars, extObjVars1, extObjVars2; list jacVars, jacVars1, jacVars2; case (SIMVARS(stateVars1, derivativeVars1, algVars1, intAlgVars1, boolAlgVars1, inputVars1, - outputVars1, paramVars1, intParamVars1, boolParamVars1, stringAlgVars1, stringParamVars1, - extObjVars1,jacVars1), + outputVars1, aliasVars1, intAliasVars1, boolAliasVars1, paramVars1, intParamVars1, boolParamVars1, + stringAlgVars1, stringParamVars1, stringAliasVars1, extObjVars1,jacVars1), SIMVARS(stateVars2, derivativeVars2, algVars2, intAlgVars2, boolAlgVars2, inputVars2, - outputVars2, paramVars2, intParamVars2, boolParamVars2, stringAlgVars2, stringParamVars2, - extObjVars2,jacVars2)) + outputVars2, aliasVars2, intAliasVars2, boolAliasVars2, paramVars2, intParamVars2, boolParamVars2, + stringAlgVars2, stringParamVars2,stringAliasVars2,extObjVars2,jacVars2)) equation stateVars = listAppend(stateVars1, stateVars2); derivativeVars = listAppend(derivativeVars1, derivativeVars2); @@ -5819,16 +5908,21 @@ algorithm boolAlgVars = listAppend(boolAlgVars1, boolAlgVars2); inputVars = listAppend(inputVars1, inputVars2); outputVars = listAppend(outputVars1, outputVars2); + aliasVars = listAppend(aliasVars1, aliasVars2); + intAliasVars = listAppend(intAliasVars1, intAliasVars2); + boolAliasVars = listAppend(boolAliasVars1, boolAliasVars2); paramVars = listAppend(paramVars1, paramVars2); intParamVars = listAppend(intParamVars1, intParamVars2); boolParamVars = listAppend(boolParamVars1, boolParamVars2); stringAlgVars = listAppend(stringAlgVars1, stringAlgVars2); stringParamVars = listAppend(stringParamVars1, stringParamVars2); + stringAliasVars = listAppend(stringAliasVars1, stringAliasVars2); extObjVars = listAppend(extObjVars1, extObjVars2); jacVars = listAppend(jacVars1, jacVars2); then SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, outputVars, - paramVars,intParamVars,boolParamVars, stringAlgVars, stringParamVars, extObjVars,jacVars); + aliasVars,intAliasVars,boolAliasVars,paramVars,intParamVars,boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars); case (_,_) equation Error.addMessage(Error.INTERNAL_ERROR, {"mergeVars failed"}); @@ -5851,16 +5945,20 @@ algorithm list boolAlgVars; list inputVars; list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; list paramVars; list intParamVars; list boolParamVars; list stringAlgVars; list stringParamVars; + list stringAliasVars; list extObjVars; list jacVars; case (SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, - outputVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, - extObjVars,jacVars)) + outputVars, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars)) equation stateVars = Util.sort(stateVars, varIndexComparer); derivativeVars = Util.sort(derivativeVars, varIndexComparer); @@ -5869,16 +5967,20 @@ algorithm boolAlgVars = Util.sort(boolAlgVars, varIndexComparer); inputVars = Util.sort(inputVars, varIndexComparer); outputVars = Util.sort(outputVars, varIndexComparer); + aliasVars = Util.sort(aliasVars, varIndexComparer); + intAliasVars = Util.sort(intAliasVars, varIndexComparer); + boolAliasVars = Util.sort(boolAliasVars, varIndexComparer); paramVars = Util.sort(paramVars, varIndexComparer); intParamVars = Util.sort(intParamVars, varIndexComparer); boolParamVars = Util.sort(boolParamVars, varIndexComparer); stringAlgVars = Util.sort(stringAlgVars, varIndexComparer); stringParamVars = Util.sort(stringParamVars, varIndexComparer); + stringAliasVars = Util.sort(stringAliasVars, varIndexComparer); extObjVars = Util.sort(extObjVars, varIndexComparer); jacVars = Util.sort(jacVars, varIndexComparer); then SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, - outputVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, - extObjVars,jacVars); + outputVars, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars); end match; end sortSimvarsOnIndex; @@ -5895,16 +5997,20 @@ algorithm list boolAlgVars; list inputVars; list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; list paramVars; list intParamVars; list boolParamVars; list stringAlgVars; list stringParamVars; + list stringAliasVars; list extObjVars; list jacVars; case (SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, - outputVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, - extObjVars,jacVars)) + outputVars, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars)) equation algVars = rewriteIndex(algVars, 0); intAlgVars = rewriteIndex(intAlgVars,0); @@ -5912,12 +6018,16 @@ algorithm paramVars = rewriteIndex(paramVars, 0); intParamVars = rewriteIndex(intParamVars, 0); boolParamVars = rewriteIndex(boolParamVars, 0); + aliasVars = rewriteIndex(aliasVars, 0); + intAliasVars = rewriteIndex(intAliasVars, 0); + boolAliasVars = rewriteIndex(boolAliasVars, 0); stringAlgVars = rewriteIndex(stringAlgVars, 0); stringParamVars = rewriteIndex(stringParamVars, 0); + stringAliasVars = rewriteIndex(stringAliasVars, 0); jacVars = rewriteIndex(jacVars, 0); then SIMVARS(stateVars, derivativeVars, algVars,intAlgVars, boolAlgVars, inputVars, - outputVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, - extObjVars,jacVars); + outputVars, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars); end match; end fixIndex; @@ -5980,24 +6090,28 @@ algorithm list boolAlgVars; list inputVars; list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; list paramVars; list intParamVars; list boolParamVars; list stringAlgVars; list stringParamVars; + list stringAliasVars; list extObjVars; list jacVars; /* no initial equations so nothing to do */ case (_, {}) then simvarsIn; case (SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, - outputVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, - extObjVars,jacVars), initCrefs) + outputVars, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars), initCrefs) equation true = Util.listMapAllValue(stateVars, simvarFixed,true); stateVars = Util.listMap1(stateVars, nonFixifyIfHasInit, initCrefs); then SIMVARS(stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, inputVars, - outputVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, - extObjVars,jacVars); + outputVars, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,jacVars); /* not all were fixed so nothing to do */ else simvarsIn; end matchcontinue; @@ -6053,11 +6167,11 @@ algorithm outHT := matchcontinue (modelInfo) local HashTableCrefToSimVar ht; - list stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, extObjVars; + list stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, aliasVars, intAliasVars, boolAliasVars, stringAliasVars, paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, extObjVars; case (MODELINFO(vars = SIMVARS( stateVars, derivativeVars, algVars, intAlgVars, boolAlgVars, - _/*inputVars*/, _/*outputVars*/, paramVars, intParamVars, boolParamVars, - stringAlgVars, stringParamVars, extObjVars,_))) + _/*inputVars*/, _/*outputVars*/, aliasVars, intAliasVars, boolAliasVars, paramVars, intParamVars, boolParamVars, + stringAlgVars, stringParamVars, stringAliasVars, extObjVars,_))) equation ht = emptyHashTable(); ht = Util.listFold(stateVars, addSimVarToHashTable, ht); @@ -6068,8 +6182,12 @@ algorithm ht = Util.listFold(paramVars, addSimVarToHashTable, ht); ht = Util.listFold(intParamVars, addSimVarToHashTable, ht); ht = Util.listFold(boolParamVars, addSimVarToHashTable, ht); + ht = Util.listFold(aliasVars, addSimVarToHashTable, ht); + ht = Util.listFold(intAliasVars, addSimVarToHashTable, ht); + ht = Util.listFold(boolAliasVars, addSimVarToHashTable, ht); ht = Util.listFold(stringAlgVars, addSimVarToHashTable, ht); ht = Util.listFold(stringParamVars, addSimVarToHashTable, ht); + ht = Util.listFold(stringAliasVars, addSimVarToHashTable, ht); ht = Util.listFold(extObjVars, addSimVarToHashTable, ht); then ht; @@ -6464,8 +6582,8 @@ protected function generateInitialEquationsFromStart "function: generateInitialE attributes of variables. Only variables with a start value and fixed set to true is converted by this function. Fixed set to false means an initial guess, and is not considered here." - input tuple> inTpl; - output tuple> outTpl; + input tuple,BackendDAE.AliasVariables>> inTpl; + output tuple,BackendDAE.AliasVariables>> outTpl; algorithm outTpl:= matchcontinue (inTpl) @@ -6478,9 +6596,11 @@ algorithm DAE.ExpType tp; Option attr; DAE.ElementSource source; + BackendDAE.AliasVariables av; - case (((v as BackendDAE.VAR(varName = cr,varKind = kind,values = attr,source=source)),eqns)) /* add equations for variables with fixed = true */ + case (((v as BackendDAE.VAR(varName = cr,varKind = kind,values = attr,source=source)),(eqns,av))) /* add equations for variables with fixed = true */ equation + NOALIAS() = getAliasVar(v,SOME(av)); BackendVariable.isVarKindVariable(kind); true = BackendVariable.varFixed(v); true = DAEUtil.hasStartAttr(attr); @@ -6489,9 +6609,10 @@ algorithm tp = Expression.typeof(e); startv = DAE.CALL(Absyn.IDENT("pre"), {e}, false, true, tp,DAE.NO_INLINE()); then - ((v,BackendDAE.EQUATION(e,startv,source)::eqns)); - case (((v as BackendDAE.VAR(varName = cr,varKind = BackendDAE.DUMMY_STATE(),values = attr,source=source)),eqns)) /* add equations for variables with fixed = true */ + ((v,(BackendDAE.EQUATION(e,startv,source)::eqns,av))); + case (((v as BackendDAE.VAR(varName = cr,varKind = BackendDAE.DUMMY_STATE(),values = attr,source=source)),(eqns,av))) /* add equations for variables with fixed = true */ equation + NOALIAS() = getAliasVar(v,SOME(av)); true = BackendVariable.varFixed(v); true = DAEUtil.hasStartAttr(attr); //startv = DAEUtil.getStartAttr(attr); @@ -6499,7 +6620,7 @@ algorithm tp = Expression.typeof(e); startv = DAE.CALL(Absyn.IDENT("pre"), {e}, false, true, tp,DAE.NO_INLINE()); then - ((v,BackendDAE.EQUATION(e,startv,source)::eqns)); + ((v,(BackendDAE.EQUATION(e,startv,source)::eqns,av))); case ((inTpl)) then inTpl; end matchcontinue; end generateInitialEquationsFromStart; diff --git a/Compiler/Main/Main.mo b/Compiler/Main/Main.mo index ef51ac2bc7f..9dc88ce9582 100644 --- a/Compiler/Main/Main.mo +++ b/Compiler/Main/Main.mo @@ -779,7 +779,8 @@ algorithm dlow = BackendDAECreate.lower(dae,funcs,true); preOptModules = {"removeSimpleEquations","removeParameterEqns","expandDerOperator"}; pastOptModules = Util.listConsOnTrue(RTOpts.debugFlag("dumpcompgraph"),"dumpComponentsGraphStr",{}); - pastOptModules = "removeSimpleEquations"::("lateInline"::pastOptModules); + pastOptModules = Util.listConsOnTrue(RTOpts.debugFlag("removeAliasEquations"),"removeAliasEquations",pastOptModules); + pastOptModules = "lateInline"::("removeSimpleEquations"::pastOptModules); (dlow_1,m,mT,v1,v2,comps) = BackendDAEUtil.getSolvedSystem(cache,env,dlow,funcs,preOptModules,BackendDAETransform.dummyDerivative,pastOptModules); modpar(dlow_1,v1,v2,comps); simcodegen(dlow_1,funcs,classname,p,ap,daeimpl,m,mT,v1,v2,comps); diff --git a/Compiler/Script/CevalScript.mo b/Compiler/Script/CevalScript.mo index 186ba2ce486..ec8c736b6d8 100644 --- a/Compiler/Script/CevalScript.mo +++ b/Compiler/Script/CevalScript.mo @@ -825,7 +825,7 @@ algorithm lstVarVal = iv, compiledFunctions = cf)),msg) equation - (cache,ret_val,st_1,_,_,_,_) = translateModelFMU(cache,env, className, st, filenameprefix, true, NONE()); + (cache,ret_val,st_1) = translateModelFMU(cache,env, className, st, filenameprefix, true, NONE()); then (cache,ret_val,st_1); @@ -1864,12 +1864,8 @@ protected function translateModelFMU "function translateModelFMU output Env.Cache outCache; output Values.Value outValue; output Interactive.InteractiveSymbolTable outInteractiveSymbolTable; - output BackendDAE.BackendDAE outBackendDAE; - output list outStringLst; - output String outFileDir; - output list> resultValues; algorithm - (outCache,outValue,outInteractiveSymbolTable,outBackendDAE,outStringLst,outFileDir,resultValues):= + (outCache,outValue,outInteractiveSymbolTable):= match (inCache,inEnv,className,inInteractiveSymbolTable,inFileNamePrefix,addDummy,inSimSettingsOpt) local Env.Cache cache; @@ -1878,10 +1874,10 @@ algorithm Interactive.InteractiveSymbolTable st; list libs; Values.Value outValMsg; - String file_dir, fileNamePrefix; + String file_dir, fileNamePrefix, str; case (cache,env,className,st,fileNamePrefix,addDummy,inSimSettingsOpt) /* mo file directory */ equation - (cache, outValMsg, st, indexed_dlow, libs, file_dir, resultValues) = + (cache, outValMsg, st, indexed_dlow, libs, file_dir, _) = SimCode.translateModelFMU(cache,env,className,st,fileNamePrefix,addDummy,inSimSettingsOpt); // compile @@ -1889,7 +1885,12 @@ algorithm compileModel(fileNamePrefix , libs, file_dir, "", ""); then - (cache,outValMsg,st,indexed_dlow,libs,file_dir,resultValues); + (cache,outValMsg,st); + case (cache,env,className,st,fileNamePrefix,addDummy,inSimSettingsOpt) /* mo file directory */ + equation + str = Error.printMessagesStr(); + then + (cache,ValuesUtil.makeArray({Values.STRING("translateModelFMU error."),Values.STRING(str)}),st); end match; end translateModelFMU; diff --git a/Compiler/susan_codegen/SimCode/SimCodeC.tpl b/Compiler/susan_codegen/SimCode/SimCodeC.tpl index f815e368f79..4cf8e160cd6 100644 --- a/Compiler/susan_codegen/SimCode/SimCodeC.tpl +++ b/Compiler/susan_codegen/SimCode/SimCodeC.tpl @@ -183,7 +183,7 @@ case MODELINFO(varInfo=VARINFO(__), vars=SIMVARS(__)) then #define NG_SAM <%varInfo.numTimeEvents%> // number of zero crossings that are samples #define NX <%varInfo.numStateVars%> // number of states #define NY <%varInfo.numAlgVars%> // number of real variables - #define NA <%varInfo.numAliasAlgVars%> // number of alias variables + #define NA <%varInfo.numAlgAliasVars%> // number of alias variables #define NP <%varInfo.numParams%> // number of parameters #define NO <%varInfo.numOutVars%> // number of outputvar on topmodel #define NI <%varInfo.numInVars%> // number of inputvar on topmodel @@ -192,12 +192,13 @@ case MODELINFO(varInfo=VARINFO(__), vars=SIMVARS(__)) then #define NFUNC <%listLength(functions)%> // number of functions used by the simulation #define MAXORD 5 #define NYSTR <%varInfo.numStringAlgVars%> // number of alg. string variables + #define NASTR <%varInfo.numStringAliasVars%> // number of alias string variables #define NPSTR <%varInfo.numStringParamVars%> // number of alg. string variables #define NYINT <%varInfo.numIntAlgVars%> // number of alg. int variables - #define NAINT <%varInfo.numAliasIntAlgVars%> // number of alias int variables + #define NAINT <%varInfo.numIntAliasVars%> // number of alias int variables #define NPINT <%varInfo.numIntParams%> // number of alg. int variables #define NYBOOL <%varInfo.numBoolAlgVars%> // number of alg. bool variables - #define NABOOL <%varInfo.numAliasBoolAlgVars%> // number of alias bool variables + #define NABOOL <%varInfo.numBoolAliasVars%> // number of alias bool variables #define NPBOOL <%varInfo.numBoolParams%> // number of alg. bool variables #define NJACVARS <%varInfo.numJacobianVars%> // number of jacobian variables @@ -221,12 +222,16 @@ case MODELINFO(varInfo=VARINFO(__), vars=SIMVARS(__)) then <%globalDataVarInfoArray("derivative_names", vars.derivativeVars)%> <%globalDataVarInfoArray("algvars_names", vars.algVars)%> <%globalDataVarInfoArray("param_names", vars.paramVars)%> + <%globalDataVarInfoArray("alias_names", vars.aliasVars)%> <%globalDataVarInfoArray("int_alg_names", vars.intAlgVars)%> <%globalDataVarInfoArray("int_param_names", vars.intParamVars)%> + <%globalDataVarInfoArray("int_alias_names", vars.intAliasVars)%> <%globalDataVarInfoArray("bool_alg_names", vars.boolAlgVars)%> <%globalDataVarInfoArray("bool_param_names", vars.boolParamVars)%> + <%globalDataVarInfoArray("bool_alias_names", vars.boolAliasVars)%> <%globalDataVarInfoArray("string_alg_names", vars.stringAlgVars)%> <%globalDataVarInfoArray("string_param_names", vars.stringParamVars)%> + <%globalDataVarInfoArray("string_alias_names", vars.stringAliasVars)%> <%globalDataVarInfoArray("jacobian_names", vars.jacobianVars)%> <%globalDataFunctionInfoArray("function_names", functions)%> @@ -268,6 +273,14 @@ case MODELINFO(varInfo=VARINFO(__), vars=SIMVARS(__)) then ;separator="\n"%> <%functions |> fn hasindex i0 => '#define <%functionName(fn,false)%>_index <%i0%>'; separator="\n"%> + void init_Alias(DATA* data) + { + <%globalDataAliasVarArray("DATA_REAL_ALIAS","omc__realAlias", vars.aliasVars)%> + <%globalDataAliasVarArray("DATA_INT_ALIAS","omc__intAlias", vars.intAliasVars)%> + <%globalDataAliasVarArray("DATA_BOOL_ALIAS","omc__boolAlias", vars.boolAliasVars)%> + <%globalDataAliasVarArray("DATA_STRING_ALIAS","omc__stringAlias", vars.stringAliasVars)%> + }; + static char init_fixed[NX+NX+NY+NYINT+NYBOOL+NYSTR+NP+NPINT+NPBOOL+NPSTR] = { <%{(vars.stateVars |> SIMVAR(__) => '<%globalDataFixedInt(isFixed)%> /* <%crefStr(name)%> */' @@ -369,28 +382,61 @@ template globalDataVarDefine(SimVar simVar, String arrayName) match arrayName case "jacobianVars" then match simVar - case SIMVAR(__) then + case SIMVAR(aliasvar=NOALIAS()) then << #define <%cref(name)%> localData-><%arrayName%>[<%index%>] >> end match case _ then match simVar - case SIMVAR(arrayCref=SOME(c)) then + case SIMVAR(arrayCref=SOME(c),aliasvar=NOALIAS()) then << #define <%cref(c)%> localData-><%arrayName%>[<%index%>] #define <%cref(name)%> localData-><%arrayName%>[<%index%>] #define $P$old<%cref(name)%> localData-><%arrayName%>_old[<%index%>] #define $P$old2<%cref(name)%> localData-><%arrayName%>_old2[<%index%>] >> - case SIMVAR(__) then + case SIMVAR(aliasvar=NOALIAS()) then << #define <%cref(name)%> localData-><%arrayName%>[<%index%>] #define $P$old<%cref(name)%> localData-><%arrayName%>_old[<%index%>] #define $P$old2<%cref(name)%> localData-><%arrayName%>_old2[<%index%>] - >> + >> end globalDataVarDefine; +template globalDataAliasVarArray(String type, String _name, list items) + "Generates array with variable names in global data section." +::= + match items + case {} then + << + <%type%> <%_name%>[1] = {{0,false}}; + >> + case items then + << + <%type%> <%_name%>[<%listLength(items)%>] = { + <%items |> var as SIMVAR(__) => '{<%aliasVarNameType(aliasvar)%>,<%index%>}'; separator=",\n"%> + }; + >> +end globalDataAliasVarArray; + +template aliasVarNameType(AliasVariable var) + "Generates type of alias." +::= + match var + case NOALIAS() then + << + 0,0 + >> + case ALIAS(__) then + << + &<%cref(varName)%>,false + >> + case NEGATEDALIAS(__) then + << + &<%cref(varName)%>,true + >> +end aliasVarNameType; template globalDataFixedInt(Boolean isFixed) "Generates integer for use in arrays in global data section." @@ -488,6 +534,7 @@ template functionSetLocalData() void setLocalData(DATA* data) { localData = data; + init_Alias(data); } >> end functionSetLocalData; @@ -520,6 +567,7 @@ template functionInitializeDataStruc() returnData->nHelpVars = NHELP; returnData->stringVariables.nParameters = NPSTR; returnData->stringVariables.nAlgebraic = NYSTR; + returnData->stringVariables.nAlias = NASTR; returnData->intVariables.nParameters = NPINT; returnData->intVariables.nAlgebraic = NYINT; returnData->intVariables.nAlias = NAINT; @@ -683,28 +731,48 @@ template functionInitializeDataStruc() if (returnData->nAlias) { returnData->realAlias = (DATA_REAL_ALIAS*) malloc(sizeof(DATA_REAL_ALIAS)*returnData->nAlias); assert(returnData->realAlias); + returnData->aliasFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->nAlias); + assert(returnData->aliasFilterOutput); memset(returnData->realAlias,0,sizeof(DATA_REAL_ALIAS)*returnData->nAlias); + memset(returnData->aliasFilterOutput,0,sizeof(modelica_boolean)*returnData->nAlias); } else { returnData->realAlias = 0; - } - + returnData->aliasFilterOutput = 0; + } + if (returnData->intVariables.nAlias) { - returnData->intVariables.alias = (DATA_INT_ALIAS*) malloc(sizeof(DATA_INT_ALIAS)*returnData->intVariables.nAlias); + returnData->intVariables.alias = (sim_DATA_INT_ALIAS*) malloc(sizeof(sim_DATA_INT_ALIAS)*returnData->intVariables.nAlias); assert(returnData->intVariables.alias); - memset(returnData->intVariables.alias,0,sizeof(DATA_INT_ALIAS)*returnData->intVariables.nAlias); + returnData->intVariables.aliasFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->intVariables.nAlias); + assert(returnData->intVariables.aliasFilterOutput); + memset(returnData->intVariables.alias,0,sizeof(sim_DATA_INT_ALIAS)*returnData->intVariables.nAlias); + memset(returnData->intVariables.aliasFilterOutput,0,sizeof(modelica_boolean)*returnData->intVariables.nAlias); } else { returnData->intVariables.alias = 0; - } - + returnData->intVariables.aliasFilterOutput=0; + } + if (returnData->boolVariables.nAlias) { returnData->boolVariables.alias = (DATA_BOOL_ALIAS*) malloc(sizeof(DATA_BOOL_ALIAS)*returnData->boolVariables.nAlias); assert(returnData->boolVariables.alias); + returnData->boolVariables.aliasFilterOutput = (modelica_boolean*) malloc(sizeof(modelica_boolean)*returnData->boolVariables.nAlias); + assert(returnData->boolVariables.aliasFilterOutput); memset(returnData->boolVariables.alias,0,sizeof(DATA_BOOL_ALIAS)*returnData->boolVariables.nAlias); + memset(returnData->boolVariables.aliasFilterOutput,0,sizeof(modelica_boolean)*returnData->boolVariables.nAlias); } else { returnData->boolVariables.alias = 0; + returnData->boolVariables.aliasFilterOutput=0; + } + + if (returnData->stringVariables.nAlias) { + returnData->stringVariables.alias = (DATA_STRING_ALIAS*) malloc(sizeof(DATA_STRING_ALIAS)*returnData->stringVariables.nAlias); + assert(returnData->stringVariables.alias); + memset(returnData->stringVariables.alias,0,sizeof(DATA_STRING_ALIAS)*returnData->stringVariables.nAlias); + } else { + returnData->stringVariables.alias = 0; } - if (returnData->nJacobianvars) { + if (returnData->nJacobianvars) { returnData->jacobianVars = (double*) malloc(sizeof(double)*returnData->nJacobianvars); assert(returnData->jacobianVars); memset(returnData->jacobianVars,0,sizeof(double)*returnData->nJacobianvars); @@ -733,6 +801,10 @@ template functionInitializeDataStruc() returnData->int_param_names = int_param_names; returnData->bool_param_names = bool_param_names; returnData->string_param_names = string_param_names; + returnData->alias_names = alias_names; + returnData->int_alias_names = int_alias_names; + returnData->bool_alias_names = bool_alias_names; + returnData->string_alias_names = string_alias_names; returnData->jacobian_names = jacobian_names; returnData->functionNames = function_names; returnData->equationInfo = equation_info; @@ -903,8 +975,13 @@ case EXTOBJINFO(__) then if (data->boolVariables.alias) { free(data->boolVariables.alias); data->boolVariables.alias = 0; - } - + } + + if (data->stringVariables.alias) { + free(data->stringVariables.alias); + data->stringVariables.alias = 0; + } + if (data->jacobianVars) { free(data->jacobianVars); data->jacobianVars = 0; @@ -1909,7 +1986,7 @@ case eqn as SES_ARRAY_CALL_ASSIGN(__) then >> case "integer" then let tvar = tempDecl("integer_array", &varDecls /*BUFD*/) - let &preExp += 'cast_integer_array_to_real(&<%expPart%>, &<%tvar%>);<%\n%>' + //let &preExp += 'cast_integer_array_to_real(&<%expPart%>, &<%tvar%>);<%\n%>' << <%preExp%> copy_integer_array_data_mem(&<%expPart%>, &<%cref(eqn.componentRef)%>);<%inlineArray(context,tvar,eqn.componentRef)%> diff --git a/Compiler/susan_codegen/SimCode/SimCodeFMU.tpl b/Compiler/susan_codegen/SimCode/SimCodeFMU.tpl index 1fd1e8d85e8..0827a0e0ace 100644 --- a/Compiler/susan_codegen/SimCode/SimCodeFMU.tpl +++ b/Compiler/susan_codegen/SimCode/SimCodeFMU.tpl @@ -204,6 +204,9 @@ case MODELINFO(vars=SIMVARS(__)) then <%vars.paramVars |> var => ScalarVariable(var) ;separator="\n"%> + <%vars.aliasVars |> var => + ScalarVariable(var) + ;separator="\n"%> <%System.tmpTickReset(0)%> <%vars.intAlgVars |> var => ScalarVariable(var) @@ -211,6 +214,9 @@ case MODELINFO(vars=SIMVARS(__)) then <%vars.intParamVars |> var => ScalarVariable(var) ;separator="\n"%> + <%vars.intAliasVars |> var => + ScalarVariable(var) + ;separator="\n"%> <%System.tmpTickReset(0)%> <%vars.boolAlgVars |> var => ScalarVariable(var) @@ -218,6 +224,9 @@ case MODELINFO(vars=SIMVARS(__)) then <%vars.boolParamVars |> var => ScalarVariable(var) ;separator="\n"%> + <%vars.boolAliasVars |> var => + ScalarVariable(var) + ;separator="\n"%> <%System.tmpTickReset(0)%> <%vars.stringAlgVars |> var => ScalarVariable(var) @@ -225,6 +234,9 @@ case MODELINFO(vars=SIMVARS(__)) then <%vars.stringParamVars |> var => ScalarVariable(var) ;separator="\n"%> + <%vars.stringAliasVars |> var => + ScalarVariable(var) + ;separator="\n"%> >> end ModelVariables; @@ -377,10 +389,10 @@ template ModelDefineData(ModelInfo modelInfo) ::= match modelInfo case MODELINFO(varInfo=VARINFO(__), vars=SIMVARS(__)) then -let numberOfReals = intAdd(varInfo.numStateVars,intAdd(varInfo.numAlgVars,varInfo.numParams)) -let numberOfIntegers = intAdd(varInfo.numIntAlgVars,varInfo.numIntParams) -let numberOfStrings = intAdd(varInfo.numStringAlgVars,varInfo.numStringParamVars) -let numberOfBooleans = intAdd(varInfo.numBoolAlgVars,varInfo.numBoolParams) +let numberOfReals = intAdd(varInfo.numStateVars,intAdd(varInfo.numAlgVars,intAdd(varInfo.numParams,varInfo.numAlgAliasVars))) +let numberOfIntegers = intAdd(varInfo.numIntAlgVars,intAdd(varInfo.numIntParams,varInfo.numIntAliasVars)) +let numberOfStrings = intAdd(varInfo.numStringAlgVars,intAdd(varInfo.numStringParamVars,varInfo.numStringAliasVars)) +let numberOfBooleans = intAdd(varInfo.numBoolAlgVars,intAdd(varInfo.numBoolParams,varInfo.numBoolAliasVars)) << // define model size #define NUMBER_OF_STATES <%varInfo.numStateVars%> @@ -397,15 +409,20 @@ let numberOfBooleans = intAdd(varInfo.numBoolAlgVars,varInfo.numBoolParams) <%vars.derivativeVars |> var => DefineVariables(var) ;separator="\n"%> <%vars.algVars |> var => DefineVariables(var) ;separator="\n"%> <%vars.paramVars |> var => DefineVariables(var) ;separator="\n"%> + <%vars.aliasVars |> var => DefineVariables(var) ;separator="\n"%> <%System.tmpTickReset(0)%> <%vars.intAlgVars |> var => DefineVariables(var) ;separator="\n"%> <%vars.intParamVars |> var => DefineVariables(var) ;separator="\n"%> + <%vars.intAliasVars |> var => DefineVariables(var) ;separator="\n"%> <%System.tmpTickReset(0)%> <%vars.boolAlgVars |> var => DefineVariables(var) ;separator="\n"%> <%vars.boolParamVars |> var => DefineVariables(var) ;separator="\n"%> + <%vars.boolAliasVars |> var => DefineVariables(var) ;separator="\n"%> <%System.tmpTickReset(0)%> <%vars.stringAlgVars |> var => DefineVariables(var) ;separator="\n"%> <%vars.stringParamVars |> var => DefineVariables(var) ;separator="\n"%> + <%vars.stringAliasVars |> var => DefineVariables(var) ;separator="\n"%> + // define initial state vector as vector of value references #define STATES { <%vars.stateVars |> SIMVAR(__) => '<%cref(name)%>_' ;separator=", "%> } @@ -549,7 +566,6 @@ case SIMCODE(__) then fmiReal getEventIndicator(ModelInstance* comp, int i) { switch(i) { - <%zeroCrossingsCode%> default: return 0.0; } @@ -616,6 +632,7 @@ case MODELINFO(vars=SIMVARS(__)) then <%vars.derivativeVars |> var => SwitchVars(var,"statesDerivatives") ;separator="\n"%> <%vars.algVars |> var => SwitchVars(var,"algebraics") ;separator="\n"%> <%vars.paramVars |> var => SwitchVars(var,"parameters") ;separator="\n"%> + <%vars.aliasVars |> var => SwitchAliasVars(var,"realAlias","-") ;separator="\n"%> default: return 0.0; } @@ -636,6 +653,7 @@ case MODELINFO(vars=SIMVARS(__)) then <%vars.derivativeVars |> var => SwitchVarsSet(var,"statesDerivatives") ;separator="\n"%> <%vars.algVars |> var => SwitchVarsSet(var,"algebraics") ;separator="\n"%> <%vars.paramVars |> var => SwitchVarsSet(var,"parameters") ;separator="\n"%> + <%vars.aliasVars |> var => SwitchAliasVarsSet(var,"realAlias") ;separator="\n"%> default: return fmiError; } @@ -655,6 +673,7 @@ case MODELINFO(vars=SIMVARS(__)) then switch (vr) { <%vars.intAlgVars |> var => SwitchVars(var,"intVariables.algebraics") ;separator="\n"%> <%vars.intParamVars |> var => SwitchVars(var,"intVariables.parameters") ;separator="\n"%> + <%vars.intAliasVars |> var => SwitchAliasVars(var,"intVariables.alias","-") ;separator="\n"%> default: return 0; } @@ -673,6 +692,7 @@ case MODELINFO(vars=SIMVARS(__)) then switch (vr) { <%vars.intAlgVars |> var => SwitchVarsSet(var,"intVariables.algebraics") ;separator="\n"%> <%vars.intParamVars |> var => SwitchVarsSet(var,"intVariables.parameters") ;separator="\n"%> + <%vars.intAliasVars |> var => SwitchAliasVarsSet(var,"intVariables.alias") ;separator="\n"%> default: return fmiError; } @@ -692,6 +712,7 @@ case MODELINFO(vars=SIMVARS(__)) then switch (vr) { <%vars.boolAlgVars |> var => SwitchVars(var,"boolVariables.algebraics") ;separator="\n"%> <%vars.boolParamVars |> var => SwitchVars(var,"boolVariables.parameters") ;separator="\n"%> + <%vars.boolAliasVars |> var => SwitchAliasVars(var,"boolVariables.alias","!") ;separator="\n"%> default: return 0; } @@ -710,6 +731,7 @@ case MODELINFO(vars=SIMVARS(__)) then switch (vr) { <%vars.boolAlgVars |> var => SwitchVarsSet(var,"boolVariables.algebraics") ;separator="\n"%> <%vars.boolParamVars |> var => SwitchVarsSet(var,"boolVariables.parameters") ;separator="\n"%> + <%vars.boolAliasVars |> var => SwitchAliasVarsSet(var,"boolVariables.alias") ;separator="\n"%> default: return fmiError; } @@ -729,6 +751,7 @@ case MODELINFO(vars=SIMVARS(__)) then switch (vr) { <%vars.stringAlgVars |> var => SwitchVars(var,"stringVariables.algebraics") ;separator="\n"%> <%vars.stringParamVars |> var => SwitchVars(var,"stringVariables.parameters") ;separator="\n"%> + <%vars.stringAliasVars |> var => SwitchAliasVars(var,"stringVariables.alias","") ;separator="\n"%> default: return 0; } @@ -747,6 +770,7 @@ case MODELINFO(vars=SIMVARS(__)) then switch (vr) { <%vars.stringAlgVars |> var => SwitchVarsSet(var,"stringVariables.algebraics") ;separator="\n"%> <%vars.stringParamVars |> var => SwitchVarsSet(var,"stringVariables.parameters") ;separator="\n"%> + <%vars.stringAliasVars |> var => SwitchAliasVarsSet(var,"stringVariables.alias") ;separator="\n"%> default: return fmiError; } @@ -784,6 +808,17 @@ match simVar >> end SwitchVars; +template SwitchAliasVars(SimVar simVar, String arrayName, String negator) + "Generates code for defining variables in c file for FMU target. " +::= +match simVar + case SIMVAR(__) then + let description = if comment then '// "<%comment%>"' + << + case <%cref(name)%>_ : return (globalData-><%arrayName%>[<%index%>].negate?*(globalData-><%arrayName%>[<%index%>].alias):<%negator%>*(globalData-><%arrayName%>[<%index%>].alias)); break; + >> +end SwitchAliasVars; + template SwitchVarsSet(SimVar simVar, String arrayName) "Generates code for defining variables in c file for FMU target. " ::= @@ -795,6 +830,17 @@ match simVar >> end SwitchVarsSet; +template SwitchAliasVarsSet(SimVar simVar, String arrayName) + "Generates code for defining variables in c file for FMU target. " +::= +match simVar + case SIMVAR(__) then + let description = if comment then '// "<%comment%>"' + << + case <%cref(name)%>_ : *(globalData-><%arrayName%>[<%index%>].alias)=value; break; + >> +end SwitchAliasVarsSet; + template fmuMakefile(SimCode simCode) "Generates the contents of the makefile for the simulation case." ::= diff --git a/Compiler/susan_codegen/SimCode/SimCodeTV.mo b/Compiler/susan_codegen/SimCode/SimCodeTV.mo index fb2642b342b..b3589470a93 100644 --- a/Compiler/susan_codegen/SimCode/SimCodeTV.mo +++ b/Compiler/susan_codegen/SimCode/SimCodeTV.mo @@ -232,9 +232,9 @@ package SimCode Integer numAlgVars; Integer numIntAlgVars; Integer numBoolAlgVars; - Integer numAliasAlgVars; - Integer numAliasIntAlgVars; - Integer numAliasBoolAlgVars; + Integer numAlgAliasVars; + Integer numIntAliasVars; + Integer numBoolAliasVars; Integer numParams; Integer numIntParams; Integer numBoolParams; @@ -244,6 +244,7 @@ package SimCode Integer numExternalObjects; Integer numStringAlgVars; Integer numStringParamVars; + Integer numStringAliasVars; Integer numJacobianVars; end VARINFO; end VarInfo; @@ -257,11 +258,15 @@ package SimCode list boolAlgVars; list inputVars; list outputVars; + list aliasVars; + list intAliasVars; + list boolAliasVars; list paramVars; list intParamVars; list boolParamVars; list stringAlgVars; list stringParamVars; + list stringAliasVars; list extObjVars; list jacobianVars; //all vars for the matrices A,B,C,D end SIMVARS; diff --git a/c_runtime/fmu_model_interface.c b/c_runtime/fmu_model_interface.c index a586c55d3b9..9dabb4c924c 100644 --- a/c_runtime/fmu_model_interface.c +++ b/c_runtime/fmu_model_interface.c @@ -4,7 +4,7 @@ extern "C" { // array of value references of states -#if NUMBER_OF_REALS>0 +#if NUMBER_OF_STATES>0 fmiValueReference vrStates[NUMBER_OF_STATES] = STATES; fmiValueReference vrStatesDerivatives[NUMBER_OF_STATES] = STATESDERIVATIVES; #endif @@ -289,7 +289,7 @@ fmiStatus fmiSetContinuousStates(fmiComponent c, const fmiReal x[], size_t nx){ return fmiError; if (nullPointer(comp, "fmiSetContinuousStates", "x[]", x)) return fmiError; -#if NUMBER_OF_REALS>0 +#if NUMBER_OF_STATES>0 comp->eventInfo.stateValuesChanged = fmiTrue; comp->outputsvalid = fmiFalse; for (i=0; ieventInfo.stateValuesChanged == fmiTrue) { - functionODE(); + int needToIterate = 0; + functionDAE(&needToIterate); comp->eventInfo.stateValuesChanged == fmiFalse; } if (comp->outputsvalid == fmiFalse) { - functionAlgebraics(); + functionAliasEquations(); comp->outputsvalid = fmiTrue; } for (i=0; ieventInfo.stateValuesChanged == fmiTrue) { - functionODE(); + int needToIterate = 0; + functionDAE(&needToIterate); comp->eventInfo.stateValuesChanged == fmiFalse; } if (comp->outputsvalid == fmiFalse) { - functionAlgebraics(); + functionAliasEquations(); comp->outputsvalid = fmiTrue; } for (i=0; ieventInfo.stateValuesChanged == fmiTrue) { - functionODE(); + int needToIterate = 0; + functionDAE(&needToIterate); comp->eventInfo.stateValuesChanged == fmiFalse; } if (comp->outputsvalid == fmiFalse) { - functionAlgebraics(); + functionAliasEquations(); comp->outputsvalid = fmiTrue; } for (i=0; ioutputsvalid == fmiFalse) { functionAlgebraics(); + functionAliasEquations(); comp->outputsvalid = fmiTrue; } for (i=0; i0 +#if NUMBER_OF_STATES>0 for (i=0; iloggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", @@ -472,7 +476,7 @@ fmiStatus fmiGetContinuousStates(fmiComponent c, fmiReal states[], size_t nx){ return fmiError; if (nullPointer(comp, "fmiGetContinuousStates", "states[]", states)) return fmiError; -#if NUMBER_OF_REALS>0 +#if NUMBER_OF_STATES>0 for (i=0; ieventInfo.stateValuesChanged == fmiTrue) { // calculate new values - functionODE(); + int needToIterate = 0; + functionDAE(&needToIterate); for (i=0; i IterationMax) return fmiError; } functionAliasEquations(); - SaveZeroCrossings(); + SaveZeroCrossings(); if (sampleEvent_actived) { deactivateSampleEventsandEquations(); diff --git a/c_runtime/simulation_runtime.cpp b/c_runtime/simulation_runtime.cpp index 80e25d224aa..e71c6cf897c 100644 --- a/c_runtime/simulation_runtime.cpp +++ b/c_runtime/simulation_runtime.cpp @@ -296,10 +296,16 @@ void initializeOutputFilter(DATA* data, string variableFilter) data->statesDerivativesFilterOutput[i] = regexec(&myregex, data->stateDerivativesNames[i].name, 0, NULL, 0) != 0; for (int i = 0; i < data->nAlgebraic; i++) if (!data->algebraicsFilterOutput[i]) data->algebraicsFilterOutput[i] = regexec(&myregex, data->algebraicsNames[i].name, 0, NULL, 0) != 0; + for (int i = 0; i < data->nAlias; i++) if (!data->aliasFilterOutput[i]) + data->aliasFilterOutput[i] = regexec(&myregex, data->alias_names[i].name, 0, NULL, 0) != 0; for (int i = 0; i < data->intVariables.nAlgebraic; i++) if (!data->intVariables.algebraicsFilterOutput[i]) data->intVariables.algebraicsFilterOutput[i] = regexec(&myregex, data->int_alg_names[i].name, 0, NULL, 0) != 0; + for (int i = 0; i < data->intVariables.nAlias; i++) if (!data->intVariables.aliasFilterOutput[i]) + data->intVariables.aliasFilterOutput[i] = regexec(&myregex, data->int_alias_names[i].name, 0, NULL, 0) != 0; for (int i = 0; i < data->boolVariables.nAlgebraic; i++) if (!data->boolVariables.algebraicsFilterOutput[i]) data->boolVariables.algebraicsFilterOutput[i] = regexec(&myregex, data->bool_alg_names[i].name, 0, NULL, 0) != 0; + for (int i = 0; i < data->boolVariables.nAlias; i++) if (!data->boolVariables.aliasFilterOutput[i]) + data->boolVariables.aliasFilterOutput[i] = regexec(&myregex, data->bool_alias_names[i].name, 0, NULL, 0) != 0; regfree(&myregex); #endif return; diff --git a/c_runtime/simulation_runtime.h b/c_runtime/simulation_runtime.h index 133f973ac4a..b81522d3605 100644 --- a/c_runtime/simulation_runtime.h +++ b/c_runtime/simulation_runtime.h @@ -110,34 +110,42 @@ extern const int LOG_DEBUG; extern const int ERROR_NONLINSYS; extern const int ERROR_LINSYS; -typedef struct sim_DATA_STRING { - const char** algebraics; - const char** parameters; - const char** inputVars; - const char** outputVars; - - long nAlgebraic,nParameters; - long nInputVars,nOutputVars; -} DATA_STRING; - typedef struct sim_DATA_REAL_ALIAS { modelica_real* alias; modelica_boolean negate; - long nVars; + int nameID; } DATA_REAL_ALIAS; typedef struct sim_DATA_INT_ALIAS { modelica_integer* alias; modelica_boolean negate; - long nVars; + int nameID; } DATA_INT_ALIAS; typedef struct sim_DATA_BOOL_ALIAS { modelica_boolean* alias; modelica_boolean negate; - long nVars; + int nameID; } DATA_BOOL_ALIAS; +typedef struct sim_DATA_STRING_ALIAS { + char** alias; + modelica_boolean negate; + int nameID; +} DATA_STRING_ALIAS; + +typedef struct sim_DATA_STRING { + const char** algebraics; + const char** parameters; + const char** inputVars; + const char** outputVars; + DATA_STRING_ALIAS* alias; + + long nAlgebraic,nParameters; + long nInputVars,nOutputVars; + long nAlias; +} DATA_STRING; + typedef struct sim_DATA_INT { modelica_integer* algebraics; modelica_integer* parameters; @@ -146,6 +154,7 @@ typedef struct sim_DATA_INT { modelica_integer* algebraics_old, *algebraics_old2; DATA_INT_ALIAS* alias; modelica_boolean* algebraicsFilterOutput; /* True if this variable should be filtered */ + modelica_boolean* aliasFilterOutput; /* True if this variable should be filtered */ long nAlgebraic,nParameters; long nInputVars,nOutputVars; @@ -160,6 +169,7 @@ typedef struct sim_DATA_BOOL { modelica_boolean* algebraics_old, *algebraics_old2; DATA_BOOL_ALIAS* alias; modelica_boolean* algebraicsFilterOutput; /* True if this variable should be filtered */ + modelica_boolean* aliasFilterOutput; /* True if this variable should be filtered */ long nAlgebraic,nParameters; long nInputVars,nOutputVars; @@ -197,6 +207,7 @@ typedef struct sim_DATA { modelica_boolean* statesFilterOutput; modelica_boolean* statesDerivativesFilterOutput; modelica_boolean* algebraicsFilterOutput; + modelica_boolean* aliasFilterOutput; /* Old values used for extrapolation */ double* states_old,*states_old2; @@ -234,12 +245,16 @@ typedef struct sim_DATA { const struct omc_varInfo* stateDerivativesNames; const struct omc_varInfo* algebraicsNames; const struct omc_varInfo* parametersNames; + const struct omc_varInfo* alias_names; const struct omc_varInfo* int_alg_names; const struct omc_varInfo* int_param_names; + const struct omc_varInfo* int_alias_names; const struct omc_varInfo* bool_alg_names; const struct omc_varInfo* bool_param_names; + const struct omc_varInfo* bool_alias_names; const struct omc_varInfo* string_alg_names; const struct omc_varInfo* string_param_names; + const struct omc_varInfo* string_alias_names; const struct omc_varInfo* inputNames; const struct omc_varInfo* outputNames; const struct omc_varInfo* jacobian_names;