Skip to content

Commit

Permalink
- revert r17809
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@17813 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
@lochel
lochel committed Oct 22, 2013
1 parent 971d825 commit 1a10117
Show file tree
Hide file tree
Showing 3 changed files with 236 additions and 238 deletions.
235 changes: 235 additions & 0 deletions Compiler/BackEnd/BackendDAECreate.mo
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3244,6 +3244,241 @@ algorithm
end match;
end expInt;



public function expandDerOperator "
Expands der(expr) using Derive.differentiteExpTime.
This can not be done in Static, since we need all time-
dependent variables, which is only available in BackendDAE."
input BackendDAE.BackendDAE dae;
output BackendDAE.BackendDAE odae;
algorithm
odae := BackendDAEUtil.mapEqSystem(dae, expandDerOperatorWork);
end expandDerOperator;

protected function expandDerOperatorWork
"expands der(expr) using Derive.differentiteExpTime.
This can not be done in Static, since we need all time-
dependent variables, which is only available in BackendDAE."
input BackendDAE.EqSystem syst;
input BackendDAE.Shared shared;
output BackendDAE.EqSystem osyst;
output BackendDAE.Shared oshared;
algorithm
(osyst, oshared) := match (syst, shared)
local
Option<BackendDAE.IncidenceMatrix> m, mT;
BackendDAE.Variables vars, knvars, exobj, vars1, vars2, av;
BackendDAE.EquationArray eqns, remeqns, inieqns, eqns1, inieqns1;
list<DAE.Constraint> constrs;
list<DAE.ClassAttributes> clsAttrs;
BackendDAE.EventInfo einfo;
BackendDAE.ExternalObjectClasses eoc;
BackendDAE.BackendDAEType btp;
BackendDAE.Matching matching;
DAE.FunctionTree funcs;
BackendDAE.SymbolicJacobians symjacs;
Env.Cache cache;
Env.Env env;
BackendDAE.StateSets stateSets;
BackendDAE.ExtraInfo ei;
case (BackendDAE.EQSYSTEM(vars, eqns, m, mT, matching, stateSets), BackendDAE.SHARED(knvars, exobj, av, inieqns, remeqns, constrs, clsAttrs, cache, env, funcs, einfo, eoc, btp, symjacs,ei))
equation
(eqns1, (vars1, _)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(eqns, traverserexpandDerEquation, (vars, shared));
(inieqns1, (vars2, _)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(inieqns, traverserexpandDerEquation, (vars1, shared));
then
(BackendDAE.EQSYSTEM(vars2, eqns1, m, mT, matching, stateSets), BackendDAE.SHARED(knvars, exobj, av, inieqns1, remeqns, constrs, clsAttrs, cache, env, funcs, einfo, eoc, btp, symjacs,ei));
end match;
end expandDerOperatorWork;

protected function traverserexpandDerEquation
"Help function to e.g. traverserexpandDerEquation"
input tuple<BackendDAE.Equation, tuple<BackendDAE.Variables, BackendDAE.Shared>> tpl;
output tuple<BackendDAE.Equation, tuple<BackendDAE.Variables, BackendDAE.Shared>> outTpl;
protected
BackendDAE.Equation e, e1;
tuple<BackendDAE.Variables, DAE.FunctionTree> ext_arg, ext_art1;
BackendDAE.Variables vars;
DAE.FunctionTree funcs;
Boolean b;
list<DAE.SymbolicOperation> ops;
BackendDAE.Shared shared;
algorithm
(e, (vars, shared)) := tpl;
(e1, (vars, shared, ops)) := BackendEquation.traverseBackendDAEExpsEqn(e, traverserexpandDerExp, (vars, shared, {}));
e1 := List.foldr(ops, BackendEquation.addOperation, e1);
outTpl := ((e1, (vars, shared)));
end traverserexpandDerEquation;

protected function traverserexpandDerExp
"Help function to e.g. traverserexpandDerExp"
input tuple<DAE.Exp, tuple<BackendDAE.Variables, BackendDAE.Shared, list<DAE.SymbolicOperation>>> tpl;
output tuple<DAE.Exp, tuple<BackendDAE.Variables, BackendDAE.Shared, list<DAE.SymbolicOperation>>> outTpl;
protected
DAE.Exp e, e1;
tuple<BackendDAE.Variables, BackendDAE.Shared, Boolean> ext_arg;
BackendDAE.Variables vars;
list<DAE.SymbolicOperation> ops;
DAE.FunctionTree funcs;
Boolean b;
BackendDAE.Shared shared;
algorithm
(e, (vars, shared, ops)) := tpl;
ext_arg := (vars, shared, false);
((e1, ext_arg)) := Expression.traverseExp(e, expandDerExp, ext_arg);
(vars, shared, b) := ext_arg;
ops := List.consOnTrue(b, DAE.OP_DIFFERENTIATE(DAE.crefTime, e, e1), ops);
outTpl := (e1, (vars, shared, ops));
end traverserexpandDerExp;

protected function expandDerExp
"Help function to e.g. expandDerOperatorEqn"
input tuple<DAE.Exp, tuple<BackendDAE.Variables, BackendDAE.Shared, Boolean>> tpl;
output tuple<DAE.Exp, tuple<BackendDAE.Variables, BackendDAE.Shared, Boolean>> outTpl;
algorithm
outTpl := matchcontinue(tpl)
local
BackendDAE.Variables vars;
DAE.Exp e1, e2;
DAE.ComponentRef cr;
String str;
BackendDAE.Shared shared;
list<BackendDAE.Var> varlst;
BackendDAE.Var v;
Boolean b;
DAE.FunctionTree funcs;
case((DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={e1 as DAE.CREF(componentRef=cr)})}), (vars, _, _)))
equation
str = ComponentReference.crefStr(cr);
str = stringAppendList({"The model includes derivatives of order > 1 for: ", str, ". That is not supported. Real d", str, " = der(", str, ") *might* result in a solvable model"});
Error.addMessage(Error.INTERNAL_ERROR, {str});
then fail();
// case for arrays
case((e1 as DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={DAE.CREF(componentRef=cr, ty = DAE.T_ARRAY(dims=_))}), (vars, shared as BackendDAE.SHARED(functionTree=funcs), b)))
equation
((e1, (_, true))) = BackendDAEUtil.extendArrExp((e1, (SOME(funcs), false)));
then Expression.traverseExp(e1, expandDerExp, (vars, shared, b));
// case for records
case((e1 as DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={DAE.CREF(componentRef=cr, ty = DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(_)))}), (vars, shared as BackendDAE.SHARED(functionTree=funcs), b)))
equation
((e1, (_, true))) = BackendDAEUtil.extendArrExp((e1, (SOME(funcs), false)));
then Expression.traverseExp(e1, expandDerExp, (vars, shared, b));
case((e1 as DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={DAE.CREF(componentRef=cr)}), (vars, shared, _)))
equation
({v}, _) = BackendVariable.getVar(cr, vars);
(vars, e1) = updateStatesVar(vars, v, e1);
then ((e1, (vars, shared, true)));
case((e1 as DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={DAE.CREF(componentRef=cr)}), (vars, shared, _)))
equation
(varlst, _) = BackendVariable.getVar(cr, vars);
vars = updateStatesVars(vars, varlst, false);
then ((e1, (vars, shared, true)));
case((DAE.CALL(path=Absyn.IDENT(name = "der"), expLst={e1}), (vars, shared, _)))
equation
e2 = Derive.differentiateExpTime(e1, (vars, shared));
(e2, _) = ExpressionSimplify.simplify(e2);
((_, vars)) = Expression.traverseExp(e2, derCrefsExp, vars);
then ((e2, (vars, shared, true)));
case _ then tpl;
end matchcontinue;
end expandDerExp;

protected function derCrefsExp "
helper for statesExp
"
input tuple<DAE.Exp, BackendDAE.Variables > inExp;
output tuple<DAE.Exp, BackendDAE.Variables > outExp;
algorithm outExp := matchcontinue(inExp)
local
DAE.ComponentRef cr;
BackendDAE.Variables vars;
list<BackendDAE.Var> varlst;
BackendDAE.Var v;
DAE.Exp e;
case ((e as DAE.CALL(path = Absyn.IDENT(name = "der"), expLst = {DAE.CREF(componentRef = cr)}), vars))
equation
({v}, _) = BackendVariable.getVar(cr, vars);
(vars, e) = updateStatesVar(vars, v, e);
then
((e, vars));
case ((e as DAE.CALL(path = Absyn.IDENT(name = "der"), expLst = {DAE.CREF(componentRef = cr)}), vars))
equation
(varlst, _) = BackendVariable.getVar(cr, vars);
vars = updateStatesVars(vars, varlst, false);
then
((e, vars));
case _ then inExp;
end matchcontinue;
end derCrefsExp;

protected function updateStatesVar
"Help function to expandDerExp"
input BackendDAE.Variables inVars;
input BackendDAE.Var var;
input DAE.Exp iExp;
output BackendDAE.Variables outVars;
output DAE.Exp oExp;
algorithm
(outVars, oExp) := matchcontinue(inVars, var, iExp)
local
BackendDAE.Variables vars;
BackendDAE.Var var1;
case(_, _, _)
equation
true = BackendVariable.isVarDiscrete(var) "do not change discrete vars to states, because they have no derivative" ;
then (inVars, DAE.RCONST(0.0));
case(_, _, _)
equation
false = BackendVariable.isVarDiscrete(var) "do not change discrete vars to states, because they have no derivative" ;
false = BackendVariable.isStateVar(var);
var1 = BackendVariable.setVarKind(var, BackendDAE.STATE(1,NONE()));
vars = BackendVariable.addVar(var1, inVars);
then (vars, iExp);
case(_, _, _)
equation
/* Might be part of a different equation-system...
str = "BackendDAECreate.updateStatesVars failed for: " +& ComponentReference.printComponentRefStr(cr);
Error.addMessage(Error.INTERNAL_ERROR, {str});
*/
then (inVars, iExp);
end matchcontinue;
end updateStatesVar;

protected function updateStatesVars
"Help function to expandDerExp"
input BackendDAE.Variables inVars;
input list<BackendDAE.Var> inNewStates;
input Boolean noStateFound;
output BackendDAE.Variables outVars;
algorithm
outVars := matchcontinue(inVars, inNewStates, noStateFound)
local
BackendDAE.Var var;
list<BackendDAE.Var> newStates;
BackendDAE.Variables vars;
//DAE.ComponentRef cr;
//String str;

case(_, {}, true) then inVars;
case(_, var::newStates, _)
equation
false = BackendVariable.isVarDiscrete(var) "do not change discrete vars to states, because they have no derivative" ;
false = BackendVariable.isStateVar(var);
var = BackendVariable.setVarKind(var, BackendDAE.STATE(1,NONE()));
vars = BackendVariable.addVar(var, inVars);
vars = updateStatesVars(vars, newStates, true);
then vars;
case(_, _::newStates, _)
equation
/* Might be part of a different equation-system...
str = "BackendDAECreate.updateStatesVars failed for: " +& ComponentReference.printComponentRefStr(cr);
Error.addMessage(Error.INTERNAL_ERROR, {str});
*/
vars = updateStatesVars(inVars, newStates, noStateFound);
then vars;
end matchcontinue;
end updateStatesVars;

// =============================================================================
// section for zero crossings
//
Expand Down

0 comments on commit 1a10117

Please sign in to comment.