Skip to content

Commit

Permalink
Merge branch 'master' of https://github.com/OpenModelica/OMCompiler
Browse files Browse the repository at this point in the history
  • Loading branch information
@niklwors
niklwors committed Oct 14, 2015
2 parents 3370770 + 748021d commit 6bec458
Show file tree
Hide file tree
Showing 9 changed files with 235 additions and 120 deletions.
20 changes: 15 additions & 5 deletions Compiler/BackEnd/BackendVariable.mo
View file
Expand Up @@ -818,12 +818,12 @@ algorithm
list<BackendDAE.VarKind> kind_lst;

/* Real non discrete variable */
case (BackendDAE.VAR(varKind = BackendDAE.CLOCKED_STATE(_)))
then true;
case (BackendDAE.VAR(varKind = BackendDAE.CLOCKED_STATE(_), varType = DAE.T_REAL(_,_)))
then true;

case (BackendDAE.VAR(varKind = kind, varType = DAE.T_REAL(_,_))) equation
kind_lst = {BackendDAE.VARIABLE(), BackendDAE.DUMMY_DER(), BackendDAE.DUMMY_STATE(), BackendDAE.OPT_INPUT_WITH_DER(), BackendDAE.OPT_INPUT_DER()};
then listMember(kind, kind_lst) or isOptLoopInput(kind);
then listMember(kind, kind_lst) or isOptLoopInput(kind);

else false;
end match;
Expand All @@ -850,7 +850,7 @@ algorithm

/* Real discrete variable */
case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE(), varType = DAE.T_REAL(_,_)))
then true;
then true;

else false;
end match;
Expand All @@ -868,9 +868,12 @@ algorithm
list<BackendDAE.VarKind> kind_lst;

/* string variable */
case (BackendDAE.VAR(varKind = BackendDAE.CLOCKED_STATE(_), varType = DAE.T_STRING()))
then true;

case (BackendDAE.VAR(varKind = kind, varType = DAE.T_STRING())) equation
kind_lst = {BackendDAE.VARIABLE(), BackendDAE.DISCRETE(), BackendDAE.DUMMY_DER(), BackendDAE.DUMMY_STATE()};
then listMember(kind, kind_lst);
then listMember(kind, kind_lst);

else false;
end match;
Expand All @@ -886,6 +889,9 @@ algorithm
BackendDAE.Type typeVar;
list<BackendDAE.VarKind> kind_lst;
/* int variable */
case (BackendDAE.VAR(varKind = BackendDAE.CLOCKED_STATE(_), varType = DAE.T_INTEGER()))
then true;

case (BackendDAE.VAR(varKind = kind,
varType = DAE.T_INTEGER()))
equation
Expand Down Expand Up @@ -916,12 +922,16 @@ algorithm
BackendDAE.Type typeVar;
list<BackendDAE.VarKind> kind_lst;
/* int variable */
case (BackendDAE.VAR(varKind = BackendDAE.CLOCKED_STATE(_), varType = DAE.T_BOOL()))
then true;

case (BackendDAE.VAR(varKind = kind,
varType = DAE.T_BOOL()))
equation
kind_lst = {BackendDAE.VARIABLE(), BackendDAE.DISCRETE(), BackendDAE.DUMMY_DER(),
BackendDAE.DUMMY_STATE()};
then listMember(kind, kind_lst);

else false;
end matchcontinue;
end isVarBoolAlg;
Expand Down
122 changes: 84 additions & 38 deletions Compiler/BackEnd/Initialization.mo
View file
Expand Up @@ -127,7 +127,7 @@ algorithm
reeqns := BackendEquation.emptyEqns();

((vars, fixvars, eqns, _)) := BackendVariable.traverseBackendDAEVars(dae.shared.aliasVars, introducePreVarsForAliasVariables, (vars, fixvars, eqns, hs));
((vars, fixvars, eqns, _, _)) := BackendVariable.traverseBackendDAEVars(dae.shared.knownVars, collectInitialVars, (vars, fixvars, eqns, hs, clkHS));
((vars, fixvars, eqns, _)) := BackendVariable.traverseBackendDAEVars(dae.shared.knownVars, collectInitialVars, (vars, fixvars, eqns, hs));
((eqns, reeqns)) := BackendEquation.traverseEquationArray(dae.shared.initialEqs, collectInitialEqns, (eqns, reeqns));
//if Flags.isSet(Flags.DUMP_INITIAL_SYSTEM) then
// BackendDump.dumpEquationArray(eqns, "initial equations");
Expand Down Expand Up @@ -1962,20 +1962,26 @@ protected
algorithm
(vars, fixvars, eqns, reqns, hs, clkHS) := inTpl;

((vars, fixvars, eqns, hs, clkHS)) := BackendVariable.traverseBackendDAEVars(inEqSystem.orderedVars, collectInitialVars, (vars, fixvars, eqns, hs, clkHS));
((eqns, reqns)) := BackendEquation.traverseEquationArray(inEqSystem.orderedEqs, collectInitialEqns, (eqns, reqns));
//((fixvars, eqns)) := List.fold(inEqSystem.stateSets, collectInitialStateSetVars, (fixvars, eqns));
outTpl := match inEqSystem
case BackendDAE.EQSYSTEM(partitionKind = BackendDAE.CLOCKED_PARTITION(_)) equation
((vars, eqns, clkHS)) = BackendVariable.traverseBackendDAEVars(inEqSystem.orderedVars, collectInitialClockedVarsEqns, (vars, eqns, clkHS));
then (vars, fixvars, eqns, reqns, hs, clkHS);

outTpl := (vars, fixvars, eqns, reqns, hs, clkHS);
else equation
((vars, fixvars, eqns, hs)) = BackendVariable.traverseBackendDAEVars(inEqSystem.orderedVars, collectInitialVars, (vars, fixvars, eqns, hs));
((eqns, reqns)) = BackendEquation.traverseEquationArray(inEqSystem.orderedEqs, collectInitialEqns, (eqns, reqns));
//((fixvars, eqns)) = List.fold(inEqSystem.stateSets, collectInitialStateSetVars, (fixvars, eqns));
then (vars, fixvars, eqns, reqns, hs, clkHS);
end match;
end collectInitialVarsEqnsSystem;

protected function collectInitialVars "author: lochel
This function collects all the vars for the initial system.
TODO: return additional equations for pre-variables"
input BackendDAE.Var inVar;
input tuple<BackendDAE.Variables, BackendDAE.Variables, BackendDAE.EquationArray, HashSet.HashSet, HashSet.HashSet> inTpl;
input tuple<BackendDAE.Variables, BackendDAE.Variables, BackendDAE.EquationArray, HashSet.HashSet> inTpl;
output BackendDAE.Var outVar;
output tuple<BackendDAE.Variables, BackendDAE.Variables, BackendDAE.EquationArray, HashSet.HashSet, HashSet.HashSet> outTpl;
output tuple<BackendDAE.Variables, BackendDAE.Variables, BackendDAE.EquationArray, HashSet.HashSet> outTpl;
algorithm
(outVar, outTpl) := matchcontinue (inVar, inTpl)
local
Expand All @@ -1984,19 +1990,19 @@ algorithm
BackendDAE.EquationArray eqns;
BackendDAE.Equation eqn;
DAE.ComponentRef cr, preCR, derCR;
Boolean isFixed, isInput, b, preUsed, previousUsed;
Boolean isFixed, isInput, b, preUsed;
DAE.Type ty;
DAE.InstDims arryDim;
Option<DAE.Exp> startValue;
DAE.Exp startValue_;
DAE.Exp startExp, bindExp, crefExp, e;
BackendDAE.VarKind varKind;
HashSet.HashSet hs, clkHS;
HashSet.HashSet hs;
String s, str, sv;
SourceInfo info;

// state
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.STATE(), varType=ty), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.STATE(), varType=ty), (vars, fixvars, eqns, hs)) equation
isFixed = BackendVariable.varFixed(var);
_ = BackendVariable.varStartValueOption(var);
preUsed = BaseHashSet.has(cr, hs);
Expand Down Expand Up @@ -2031,10 +2037,10 @@ algorithm
vars = BackendVariable.addVar(var, vars);
vars = if preUsed then BackendVariable.addVar(preVar, vars) else vars;
eqns = if preUsed then BackendEquation.addEquation(eqn, eqns) else eqns;
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// discrete (preUsed=true)
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE(), varType=ty), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE(), varType=ty), (vars, fixvars, eqns, hs)) equation
true = BaseHashSet.has(cr, hs);
true = BackendVariable.varFixed(var);
startValue_ = BackendVariable.varStartValue(var);
Expand All @@ -2054,10 +2060,10 @@ algorithm
vars = BackendVariable.addVar(var, vars);
vars = BackendVariable.addVar(preVar, vars);
eqns = BackendEquation.addEquation(eqn, eqns);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// discrete
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE()), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE()), (vars, fixvars, eqns, hs)) equation
preUsed = BaseHashSet.has(cr, hs);
startValue = BackendVariable.varStartValueOption(var);

Expand All @@ -2073,10 +2079,10 @@ algorithm

vars = BackendVariable.addVar(var, vars);
vars = if preUsed then BackendVariable.addVar(preVar, vars) else vars;
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// parameter without binding and fixed=true
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=NONE()), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=NONE()), (vars, fixvars, eqns, hs)) equation
true = BackendVariable.varFixed(var);
startExp = BackendVariable.varStartValueType(var);

Expand All @@ -2095,10 +2101,10 @@ algorithm
Error.addSourceMessage(Error.UNBOUND_PARAMETER_WITH_START_VALUE_WARNING, {s, str}, info);

//vars = BackendVariable.addVar(var, vars);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// parameter with binding and fixed=false
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp), varType=ty), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp), varType=ty), (vars, fixvars, eqns, hs)) equation
true = intGt(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 31);
false = BackendVariable.varFixed(var);
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());
Expand All @@ -2113,12 +2119,12 @@ algorithm
eqns = BackendEquation.addEquation(eqn, eqns);

vars = BackendVariable.addVar(var, vars);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// *** MODELICA 3.1 COMPATIBLE ***
// parameter with binding and fixed=false and no start value
// use the binding as start value
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp)), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp)), (vars, fixvars, eqns, hs)) equation
true = intLe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 31);
false = BackendVariable.varFixed(var);
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());
Expand All @@ -2132,12 +2138,12 @@ algorithm
Error.addSourceMessage(Error.UNFIXED_PARAMETER_WITH_BINDING_31, {s, s, str}, info);

vars = BackendVariable.addVar(var, vars);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// *** MODELICA 3.1 COMPATIBLE ***
// parameter with binding and fixed=false and a start value
// ignore the binding and use the start value
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp)), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp)), (vars, fixvars, eqns, hs)) equation
true = intLe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 31);
false = BackendVariable.varFixed(var);
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());
Expand All @@ -2151,20 +2157,20 @@ algorithm
Error.addSourceMessage(Error.UNFIXED_PARAMETER_WITH_BINDING_AND_START_VALUE_31, {s, sv, s, str}, info);

vars = BackendVariable.addVar(var, vars);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// parameter with constant binding
// skip these parameters (#3050)
case (var as BackendDAE.VAR(varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp)), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp)), (vars, fixvars, eqns, hs)) equation
true = Expression.isConst(bindExp);
//fixvars = BackendVariable.addVar(var, fixvars);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// parameter
case (var as BackendDAE.VAR(varKind=BackendDAE.PARAM()), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varKind=BackendDAE.PARAM()), (vars, fixvars, eqns, hs)) equation
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());
vars = BackendVariable.addVar(var, vars);
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// skip constant
case (var as BackendDAE.VAR(varKind=BackendDAE.CONST()), _) // equation
Expand All @@ -2173,40 +2179,35 @@ algorithm

// VARIABLE (fixed=true)
// DUMMY_STATE
case (var as BackendDAE.VAR(varName=cr, varType=ty), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varType=ty), (vars, fixvars, eqns, hs)) equation
true = BackendVariable.varFixed(var);
isInput = BackendVariable.isVarOnTopLevelAndInput(var);
startValue_ = BackendVariable.varStartValue(var);
preUsed = BaseHashSet.has(cr, hs);
previousUsed = BaseHashSet.has(cr, clkHS);

var = BackendVariable.setVarFixed(var, false);

preCR = if previousUsed then ComponentReference.crefPrefixPrevious(cr) else ComponentReference.crefPrefixPre(cr); // cr => $PRE.cr
preCR = ComponentReference.crefPrefixPre(cr); // cr => $PRE.cr
preVar = BackendVariable.copyVarNewName(preCR, var);
preVar = BackendVariable.setVarDirection(preVar, DAE.BIDIR());
preVar = BackendVariable.setBindExp(preVar, NONE());
preVar = BackendVariable.setBindValue(preVar, NONE());
preVar = BackendVariable.setVarFixed(preVar, true);
preVar = BackendVariable.setVarStartValueOption(preVar, SOME(DAE.CREF(cr, ty)));

if previousUsed then
var = BackendVariable.setVarKind(var, BackendDAE.CLOCKED_STATE(previousName = preCR));
end if;

eqn = BackendDAE.EQUATION(DAE.CREF(cr, ty), startValue_, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_INITIAL);

vars = if not isInput then BackendVariable.addVar(var, vars) else vars;
fixvars = if isInput then BackendVariable.addVar(var, fixvars) else fixvars;
vars = if preUsed or previousUsed then BackendVariable.addVar(preVar, vars) else vars;
vars = if preUsed then BackendVariable.addVar(preVar, vars) else vars;
eqns = BackendEquation.addEquation(eqn, eqns);

// Error.addCompilerNotification("VARIABLE (fixed=true): " + BackendDump.varString(var));
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

// VARIABLE (fixed=false)
// DUMMY_STATE
case (var as BackendDAE.VAR(varName=cr, varType=ty), (vars, fixvars, eqns, hs, clkHS)) equation
case (var as BackendDAE.VAR(varName=cr, varType=ty), (vars, fixvars, eqns, hs)) equation
false = BackendVariable.varFixed(var);
isInput = BackendVariable.isVarOnTopLevelAndInput(var);
preUsed = BaseHashSet.has(cr, hs);
Expand All @@ -2227,14 +2228,59 @@ algorithm
eqns = if preUsed then BackendEquation.addEquation(eqn, eqns) else eqns;

// Error.addCompilerNotification("VARIABLE (fixed=false); " + BackendDump.varString(var));
then (var, (vars, fixvars, eqns, hs, clkHS));
then (var, (vars, fixvars, eqns, hs));

else equation
Error.addInternalError("function collectInitialVars failed for: " + BackendDump.varString(inVar), sourceInfo());
then fail();
end matchcontinue;
end collectInitialVars;

protected function collectInitialClockedVarsEqns "author: rfranke
This function creates initial equations for a clocked partition.
Previous states are initialized with the states. All other variables are initialized with start values."
input BackendDAE.Var inVar;
input tuple<BackendDAE.Variables, BackendDAE.EquationArray, HashSet.HashSet> inTpl;
output BackendDAE.Var outVar;
output tuple<BackendDAE.Variables, BackendDAE.EquationArray, HashSet.HashSet> outTpl;
protected
BackendDAE.Variables vars;
BackendDAE.EquationArray eqns;
HashSet.HashSet clkHS;
algorithm
(vars, eqns, clkHS) := inTpl;
(outVar, outTpl) := match inVar
local
BackendDAE.Var var, previousVar;
DAE.ComponentRef cr, previousCR;
DAE.Type ty;
DAE.Exp crExp, previousExp, startExp;
Boolean previousUsed;
case (var as BackendDAE.VAR(varName=cr, varType=ty)) equation
previousUsed = BaseHashSet.has(cr, clkHS);
previousCR = ComponentReference.crefPrefixPrevious(cr); // cr => $CLKPRRE.cr
previousVar = BackendVariable.copyVarNewName(previousCR, var);
crExp = Expression.crefExp(cr);
previousExp = Expression.crefExp(previousCR);
startExp = BackendVariable.varStartValue(var);
if previousUsed then
// create previous variable and initial equation
previousVar = BackendVariable.setVarDirection(previousVar, DAE.BIDIR());
previousVar = BackendVariable.setBindExp(previousVar, NONE());
previousVar = BackendVariable.setBindValue(previousVar, NONE());
previousVar = BackendVariable.setVarFixed(previousVar, true);
previousVar = BackendVariable.setVarStartValueOption(previousVar, SOME(DAE.CREF(cr, ty)));
vars = BackendVariable.addVar(previousVar, vars);
eqns = BackendEquation.addEquation(BackendDAE.EQUATION(previousExp, crExp, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_INITIAL), eqns);
var = BackendVariable.setVarKind(var, BackendDAE.CLOCKED_STATE(previousName = previousCR));
end if;
// add clocked variable and initial equation
vars = BackendVariable.addVar(var, vars);
eqns = BackendEquation.addEquation(BackendDAE.EQUATION(crExp, startExp, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_INITIAL), eqns);
then (var, (vars, eqns, clkHS));
end match;
end collectInitialClockedVarsEqns;

protected function collectInitialEqns "author: lochel"
input BackendDAE.Equation inEq;
input tuple<BackendDAE.EquationArray, BackendDAE.EquationArray> inTpl;
Expand Down

0 comments on commit 6bec458

Please sign in to comment.