Skip to content

Commit

Permalink
- Compiler/BackEnd/
Browse files Browse the repository at this point in the history 
  - solve dependencies for parameters during initialization
  - fix for equations from bindings
- Compiler/Template/
  - print error message, if symbolic initialization is selected but not generated
- SimulationRuntime/c
  - always dump error messages
- testsuite/
  - activate case for ticket #1964


git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@14225 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
@lochel
lochel committed Dec 4, 2012
1 parent 2ffd4e0 commit 2e1aa11
Show file tree
Hide file tree
Showing 4 changed files with 128 additions and 56 deletions.
175 changes: 124 additions & 51 deletions Compiler/BackEnd/BackendDAEUtil.mo
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9087,14 +9087,16 @@ algorithm
env=env,
functionTree=functionTree))) equation
true = Flags.isSet(Flags.SOLVE_INITIAL_SYSTEM);
// collect vars for initial system

// collect vars and eqns for initial system
vars = emptyVars();
fixvars = emptyVars();
eqns = listEquation({});
reeqns = listEquation({});
((vars, fixvars)) = BackendVariable.traverseBackendDAEVars(knvars, collectInitialVars, (vars, fixvars));

// collect eqns for initial system
((eqns, reeqns)) = BackendEquation.traverseBackendDAEEqns(inieqns, collectInitialEqns, (listEquation({}), listEquation({})));
((eqns, reeqns)) = BackendEquation.traverseBackendDAEEqns(inieqns, collectInitialEqns, (eqns, reeqns));
((vars, fixvars, eqns, reeqns)) = List.fold(systs, collectInitialVarsEqnsSystem, ((vars, fixvars, eqns, reeqns)));
((eqns, reeqns)) = BackendVariable.traverseBackendDAEVars(vars, collectInitialBindings, (eqns, reeqns));

// collect pre(var) from alias
//((_, vars, fixvars)) = traverseBackendDAEExpsEqns(eqns, collectAliasPreVars, (avars, vars, fixvars));
Expand Down Expand Up @@ -9180,7 +9182,7 @@ algorithm
isyst = transformBackendDAE(inInitDAE, SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())), NONE(), NONE());

// simplify system
(isyst,Util.SUCCESS()) = pastoptimiseDAE(isyst, pastOptModules, matchingAlgorithm, daeHandler);
(isyst, Util.SUCCESS()) = pastoptimiseDAE(isyst, pastOptModules, matchingAlgorithm, daeHandler);

Debug.fcall(Flags.DUMP_INITIAL_SYSTEM, print, "\n#########################\n# solved initial system #\n#########################\n\n");
Debug.fcall(Flags.DUMP_INITIAL_SYSTEM, BackendDump.dump, isyst);
Expand Down Expand Up @@ -9208,8 +9210,8 @@ protected
BackendDAE.IncidenceMatrix m, mt;
algorithm
(system, m, mt) := getIncidenceMatrix(inSystem, BackendDAE.NORMAL());
system := analyzeInitialSystem1(system, mt, 1); // fix discrete vars to get rid of unneeded pre-vars
system := analyzeInitialSystem2(system, inDAE); // fix unbalanced initial system if it is definite
system := analyzeInitialSystem1(system, mt, 1); // fix discrete vars to get rid of unneeded pre-vars
system := analyzeInitialSystem2(system, inDAE); // fix unbalanced initial system if it is definite
(outSystem, _, _) := getIncidenceMatrix(system, BackendDAE.NORMAL());
end analyzeInitialSystem;

Expand Down Expand Up @@ -9561,25 +9563,23 @@ algorithm
end matchcontinue;
end collectAliasPreVarsExp;


protected function collectInitialVarsEqnsSystem "function collectInitialVarsEqnsSystem
author Frenkel TUD 2012-10"
author: lochel, Frenkel TUD 2012-10
This function collects variables and equations for the initial system out of an given EqSystem."
input BackendDAE.EqSystem isyst;
input tuple<BackendDAE.Variables, BackendDAE.Variables, BackendDAE.EquationArray, BackendDAE.EquationArray> iTpl;
output tuple<BackendDAE.Variables, BackendDAE.Variables, BackendDAE.EquationArray, BackendDAE.EquationArray> oTpl;
protected
BackendDAE.Variables orderedVars, vars, fixvars;
BackendDAE.EquationArray orderedEqs, eqns, reqns;
algorithm
oTpl := match(isyst, iTpl)
local
BackendDAE.Variables vars, ivars, fixvars;
BackendDAE.EquationArray eqns, ieqns, reqns;
case (BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=eqns), (ivars, fixvars, ieqns, reqns)) equation
// collect vars for initial system
((ivars, fixvars)) = BackendVariable.traverseBackendDAEVars(vars, collectInitialVars, (ivars, fixvars));

// collect eqns for initial system
((ieqns, reqns)) = BackendEquation.traverseBackendDAEEqns(eqns, collectInitialEqns, (ieqns, reqns));
then ((ivars, fixvars, ieqns, reqns));
end match;
BackendDAE.EQSYSTEM(orderedVars=orderedVars, orderedEqs=orderedEqs) := isyst;
(vars, fixvars, eqns, reqns) := iTpl;

((vars, fixvars)) := BackendVariable.traverseBackendDAEVars(orderedVars, collectInitialVars, (vars, fixvars));
((eqns, reqns)) := BackendEquation.traverseBackendDAEEqns(orderedEqs, collectInitialEqns, (eqns, reqns));

oTpl := (vars, fixvars, eqns, reqns);
end collectInitialVarsEqnsSystem;

protected function collectUnfixedStatesFromSystem
Expand Down Expand Up @@ -9618,7 +9618,7 @@ protected function collectInitialVars "protected function collectInitialVars
input tuple<BackendDAE.Var, tuple<BackendDAE.Variables, BackendDAE.Variables>> inTpl;
output tuple<BackendDAE.Var, tuple<BackendDAE.Variables, BackendDAE.Variables>> outTpl;
algorithm
outTpl := match(inTpl)
outTpl := matchcontinue(inTpl)
local
BackendDAE.Var var, preVar, derVar;
BackendDAE.Variables vars, fixvars;
Expand All @@ -9627,9 +9627,11 @@ algorithm
DAE.Type ty;
DAE.InstDims arryDim;
Option<DAE.Exp> startValue;
DAE.Exp startExp;
String errorMessage;

// state
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.STATE(), bindExp=NONE(), varType=ty, arryDim=arryDim), (vars, fixvars))) equation
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.STATE(), varType=ty, arryDim=arryDim), (vars, fixvars))) equation
isFixed = BackendVariable.varFixed(var);
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());

Expand All @@ -9641,15 +9643,8 @@ algorithm
fixvars = Debug.bcallret2(isFixed, BackendVariable.addVar, var, fixvars, fixvars);
then ((var, (vars, fixvars)));

// state with binding
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.STATE(), bindExp=NONE(), varType=ty, arryDim=arryDim), (vars, fixvars))) equation
derCR = ComponentReference.crefPrefixDer(cr); // cr => $DER.cr
derVar = BackendDAE.VAR(derCR, BackendDAE.VARIABLE(), DAE.BIDIR(), DAE.NON_PARALLEL(), ty, NONE(), NONE(), arryDim, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
vars = BackendVariable.addVar(derVar, vars);
then ((var, (vars, fixvars)));

// discrete
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE(), bindExp=NONE(), varType=ty, arryDim=arryDim), (vars, fixvars))) equation
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE(), varType=ty, arryDim=arryDim), (vars, fixvars))) equation
isFixed = BackendVariable.varFixed(var);
startValue = BackendVariable.varStartValueOption(var);

Expand All @@ -9665,41 +9660,119 @@ algorithm
fixvars = Debug.bcallret2(isFixed, BackendVariable.addVar, preVar, fixvars, fixvars);
then ((var, (vars, fixvars)));

// discrete with binding
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE(), bindExp=SOME(_), varType=ty, arryDim=arryDim), (vars, fixvars))) equation
isFixed = BackendVariable.varFixed(var);
startValue = BackendVariable.varStartValueOption(var);

preCR = ComponentReference.crefPrefixPre(cr); // cr => $PRE.cr
preVar = BackendDAE.VAR(preCR, BackendDAE.DISCRETE(), DAE.BIDIR(), DAE.NON_PARALLEL(), ty, NONE(), NONE(), arryDim, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
preVar = BackendVariable.setVarFixed(preVar, isFixed);
preVar = BackendVariable.setVarStartValueOption(preVar, startValue);
// parameter (without binding)
case((var as BackendDAE.VAR(varKind=BackendDAE.PARAM(), bindExp=NONE()), (vars, fixvars))) equation
true = BackendVariable.varFixed(var);
startExp = BackendVariable.varStartValueType(var);
var = BackendVariable.setBindExp(var, startExp);

vars = Debug.bcallret2(not isFixed, BackendVariable.addVar, preVar, vars, vars);
fixvars = Debug.bcallret2(isFixed, BackendVariable.addVar, preVar, fixvars, fixvars);
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());
vars = BackendVariable.addVar(var, vars);
then ((var, (vars, fixvars)));

// parameter
case((var as BackendDAE.VAR(varKind=BackendDAE.PARAM(), bindExp=NONE()), (vars, fixvars))) equation
isFixed = BackendVariable.varFixed(var);
case((var as BackendDAE.VAR(varKind=BackendDAE.PARAM()), (vars, fixvars))) equation
var = BackendVariable.setVarKind(var, BackendDAE.VARIABLE());

vars = Debug.bcallret2(not isFixed, BackendVariable.addVar, var, vars, vars);
fixvars = Debug.bcallret2(isFixed, BackendVariable.addVar, var, fixvars, fixvars);
vars = BackendVariable.addVar(var, vars);
then ((var, (vars, fixvars)));


// constant
case((var as BackendDAE.VAR(varKind=BackendDAE.CONST()), (vars, fixvars))) // equation
// fixvars = BackendVariable.addVar(var, fixvars);
then ((var, (vars, fixvars)));

case((var as BackendDAE.VAR(bindExp=NONE()), (vars, fixvars))) equation
isFixed = BackendVariable.varFixed(var);

vars = Debug.bcallret2(not isFixed, BackendVariable.addVar, var, vars, vars);
fixvars = Debug.bcallret2(isFixed, BackendVariable.addVar, var, fixvars, fixvars);
then ((var, (vars, fixvars)));

else
then inTpl;
end match;
case((var as BackendDAE.VAR(bindExp=SOME(_)), (vars, fixvars))) equation
vars = BackendVariable.addVar(var, vars);
then ((var, (vars, fixvars)));

case ((var, _)) equation
errorMessage = "./Compiler/BackEnd/BackendDAEUtil.mo: function collectInitialVars failed for: " +& BackendDump.varString(var);
Error.addMessage(Error.INTERNAL_ERROR, {errorMessage});
then fail();

else equation
Error.addMessage(Error.INTERNAL_ERROR, {"./Compiler/BackEnd/BackendDAEUtil.mo: function collectInitialVars failed"});
then fail();
end matchcontinue;
end collectInitialVars;

protected function collectInitialBindings "protected function collectInitialBindings
This function collects all the vars for the initial system."
input tuple<BackendDAE.Var, tuple<BackendDAE.EquationArray,BackendDAE.EquationArray>> inTpl;
output tuple<BackendDAE.Var, tuple<BackendDAE.EquationArray,BackendDAE.EquationArray>> outTpl;
algorithm
outTpl := match(inTpl)
local
BackendDAE.Var var, preVar, derVar;
BackendDAE.Variables vars, fixvars;
DAE.ComponentRef cr, preCR, derCR;
Boolean isFixed;
DAE.Type ty;
DAE.InstDims arryDim;
Option<DAE.Exp> startValue;
String errorMessage;
BackendDAE.EquationArray eqns, reeqns;
.DAE.Exp bindExp, crefExp;
.DAE.ElementSource source;
BackendDAE.Equation eqn;

// no binding
case((var as BackendDAE.VAR(bindExp=NONE()), (eqns, reeqns)))
then ((var, (eqns, reeqns)));

// discrete
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DISCRETE(), bindExp=SOME(bindExp), varType=ty, source=source), (eqns, reeqns))) equation
crefExp = DAE.CREF(cr, ty);
eqn = BackendDAE.EQUATION(crefExp, bindExp, source);
eqns = BackendEquation.equationAdd(eqn, eqns);
then ((var, (eqns, reeqns)));

// parameter
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.PARAM(), bindExp=SOME(bindExp), varType=ty, source=source), (eqns, reeqns))) equation
crefExp = DAE.CREF(cr, ty);
eqn = BackendDAE.EQUATION(crefExp, bindExp, source);
eqns = BackendEquation.equationAdd(eqn, eqns);
then ((var, (eqns, reeqns)));

// variable
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.VARIABLE(), bindExp=SOME(bindExp), varType=ty, source=source), (eqns, reeqns))) equation
crefExp = DAE.CREF(cr, ty);
eqn = BackendDAE.EQUATION(crefExp, bindExp, source);
eqns = BackendEquation.equationAdd(eqn, eqns);
then ((var, (eqns, reeqns)));

// dummy-der
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DUMMY_DER(), bindExp=SOME(bindExp), varType=ty, source=source), (eqns, reeqns))) equation
crefExp = DAE.CREF(cr, ty);
eqn = BackendDAE.EQUATION(crefExp, bindExp, source);
eqns = BackendEquation.equationAdd(eqn, eqns);
then ((var, (eqns, reeqns)));

// dummy-state
case((var as BackendDAE.VAR(varName=cr, varKind=BackendDAE.DUMMY_STATE(), bindExp=SOME(bindExp), varType=ty, source=source), (eqns, reeqns))) equation
crefExp = DAE.CREF(cr, ty);
eqn = BackendDAE.EQUATION(crefExp, bindExp, source);
eqns = BackendEquation.equationAdd(eqn, eqns);
then ((var, (eqns, reeqns)));

case ((var, _)) equation
errorMessage = "./Compiler/BackEnd/BackendDAEUtil.mo: function collectInitialBindings failed for: " +& BackendDump.varString(var);
Error.addMessage(Error.INTERNAL_ERROR, {errorMessage});
then fail();

else equation
Error.addMessage(Error.INTERNAL_ERROR, {"./Compiler/BackEnd/BackendDAEUtil.mo: function collectInitialBindings failed"});
then fail();
end match;
end collectInitialBindings;

protected function generateInactiveWhenEquationForInitialization "function generateInactiveWhenEquationForInitialization
author: lochel
This function ... I guess the function name says it all!"
Expand Down
3 changes: 1 addition & 2 deletions Compiler/BackEnd/BackendDump.mo
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1617,8 +1617,7 @@ algorithm
outVarNo := inVarNo + 1;
end dumpVar;

protected function varString
"function: varString
public function varString "function varString
Helper function to dumpVars."
input BackendDAE.Var inVar;
output String outStr;
Expand Down
4 changes: 2 additions & 2 deletions Compiler/Template/CodegenC.tpl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -989,9 +989,9 @@ template functionInitialEquations(Boolean useSymbolicInitialization, list<SimEqS
;separator="\n")
let info = match useSymbolicInitialization
case true then
'INFO(LOG_INIT, "symbolic initialization is generated");'
'INFO(LOG_INIT, "The symbolic initialization was generated.");'
else
'INFO(LOG_INIT, "symbolic initialization is not generated");'
'ERROR0(LOG_INIT, "The symbolic initialization was not generated.");'
let useSymbolicInitializationToInt = match useSymbolicInitialization
case true then
'1'
Expand Down
2 changes: 1 addition & 1 deletion SimulationRuntime/c/util/omc_error.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -130,7 +130,7 @@ void Message(int type, int stream, char *msg, int subline)
{
int i;

if(!useStream[stream])
if((type != LOG_TYPE_ERROR) && !useStream[stream])
return;

printf("%-13s | ", (subline || (lastStream == stream && level[stream] > 0)) ? "|" : LOG_STREAM_DESC[stream]);
Expand Down

0 comments on commit 2e1aa11

Please sign in to comment.