Skip to content

Commit

Permalink
- remove obsolete optimization module "optimizeInitialSystem"
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@24425 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
@lochel
lochel committed Feb 5, 2015
1 parent e9dfd65 commit 3628240
Show file tree
Hide file tree
Showing 3 changed files with 0 additions and 178 deletions.
1 change: 0 additions & 1 deletion Compiler/BackEnd/BackendDAEUtil.mo
View file
Expand Up @@ -7614,7 +7614,6 @@ algorithm
(BackendDAEOptimize.simplifysemiLinear, "simplifysemiLinear", false),
(BackendDAEOptimize.removeConstants, "removeConstants", false),
(ExpressionSolve.solveSimpleEquations, "solveSimpleEquations", false),
(Initialization.optimizeInitialSystem, "optimizeInitialSystem", false),
(SymbolicJacobian.detectSparsePatternODE, "detectJacobianSparsePattern", false),
(Tearing.tearingSystem, "tearingSystem", false),
(HpcOmEqSystems.partitionLinearTornSystem, "partlintornsystem", false),
Expand Down
176 changes: 0 additions & 176 deletions Compiler/BackEnd/Initialization.mo
View file
Expand Up @@ -2566,181 +2566,5 @@ algorithm
end match;
end collectInitialBindings;

// =============================================================================
// optimize inital system
//
// =============================================================================
public function optimizeInitialSystem "author Frenkel TUD 2012-08"
input BackendDAE.BackendDAE inDAE;
output BackendDAE.BackendDAE outDAE;
algorithm
outDAE := matchcontinue(inDAE)
local
BackendDAE.EqSystems systs;
BackendDAE.Variables knvars;
BackendDAE.EquationArray inieqns;
HashTable2.HashTable initalAliases;
list<BackendDAE.Equation> eqnlst;
Boolean optimizationfound;

case (BackendDAE.DAE(_, BackendDAE.SHARED(knownVars=knvars, initialEqs=inieqns))) equation
// search
initalAliases = HashTable2.emptyHashTable();
eqnlst = BackendEquation.equationList(inieqns);
(eqnlst, initalAliases, optimizationfound) = optimizeInitialSystem1(eqnlst, knvars, initalAliases, {}, false);
// do optimization
then optimizeInitialSystemWork(optimizationfound, inDAE, eqnlst, initalAliases);

else inDAE;
end matchcontinue;
end optimizeInitialSystem;

protected function optimizeInitialSystemWork "author: Frenkel TUD 2012-08"
input Boolean optimizationfound;
input BackendDAE.BackendDAE inDAE;
input list<BackendDAE.Equation> eqnlst;
input HashTable2.HashTable initalAliases;
output BackendDAE.BackendDAE outDAE;
algorithm
outDAE := match(optimizationfound, inDAE, eqnlst, initalAliases)
local
BackendDAE.EqSystems systs;
BackendDAE.Variables knvars, knvars1, exobj, av;
BackendDAE.EquationArray remeqns, inieqns;
list<DAE.Constraint> constrs;
list<DAE.ClassAttributes> clsAttrs;
FCore.Cache cache;
FCore.Graph graph;
DAE.FunctionTree funcs;
BackendDAE.EventInfo einfo;
BackendDAE.ExternalObjectClasses eoc;
BackendDAE.SymbolicJacobians symjacs;
BackendDAE.BackendDAEType btp;
BackendDAE.ExtraInfo ei;

case (true, BackendDAE.DAE(systs, BackendDAE.SHARED(knvars, exobj, av, inieqns, remeqns, constrs, clsAttrs, cache, graph, funcs, einfo, eoc, btp, symjacs, ei)), _, _) equation
(knvars1, (_, _)) = BackendVariable.traverseBackendDAEVarsWithUpdate(knvars, optimizeInitialAliasesFinder, (initalAliases, false));
inieqns = BackendEquation.listEquation(eqnlst);
systs= List.map1(systs, optimizeInitialAliases, initalAliases);
then BackendDAE.DAE(systs, BackendDAE.SHARED(knvars1, exobj, av, inieqns, remeqns, constrs, clsAttrs, cache, graph, funcs, einfo, eoc, btp, symjacs, ei));

case (false, _, _, _)
then inDAE;
end match;
end optimizeInitialSystemWork;

protected function optimizeInitialSystem1 "author: Frenkel TUD 2012-06"
input list<BackendDAE.Equation> iEqns;
input BackendDAE.Variables knvars;
input HashTable2.HashTable iInitalAliases;
input list<BackendDAE.Equation> iAcc;
input Boolean iOptimizationfound;
output list<BackendDAE.Equation> outEqsLst;
output HashTable2.HashTable oInitalAliases;
output Boolean oOptimizationfound;
algorithm
(outEqsLst, oInitalAliases, oOptimizationfound) := matchcontinue(iEqns, knvars, iInitalAliases, iAcc, iOptimizationfound)
local
list<BackendDAE.Equation> eqnslst, eqnslst1;
BackendDAE.Equation eqn;
HashTable2.HashTable initalAliases;
Boolean optimizationfound, negate;
DAE.ComponentRef cr1, cr2;
DAE.Exp e1, e2;

case ({}, _, _, _, _)
then (listReverse(iAcc), iInitalAliases, iOptimizationfound);

case ((eqn as BackendDAE.EQUATION(exp=e1, scalar=e2))::eqnslst, _, _, _, _) equation
((cr1, cr2, e1, e2, negate)::{}) = BackendEquation.aliasEquation(eqn);
initalAliases = addInitialAlias(cr1, cr2, e1, e2, negate, knvars, iInitalAliases);
(eqnslst1, initalAliases, optimizationfound) = optimizeInitialSystem1(eqnslst, knvars, initalAliases, iAcc, true);
then (eqnslst1, initalAliases, optimizationfound);

case (eqn::eqnslst, _, _, _, _) equation
(eqnslst1, initalAliases, optimizationfound) = optimizeInitialSystem1(eqnslst, knvars, iInitalAliases, eqn::iAcc, iOptimizationfound);
then (eqnslst1, initalAliases, optimizationfound);
end matchcontinue;
end optimizeInitialSystem1;

protected function addInitialAlias
input DAE.ComponentRef cr1;
input DAE.ComponentRef cr2;
input DAE.Exp e1;
input DAE.Exp e2;
input Boolean negate;
input BackendDAE.Variables knvars;
input HashTable2.HashTable iInitalAliases;
output HashTable2.HashTable oInitalAliases;
algorithm
oInitalAliases := matchcontinue(cr1, cr2, e1, e2, negate, knvars, iInitalAliases)
local
HashTable2.HashTable initalAliases;
DAE.Exp e;

case (_, _, _, _, _, _, _) equation
(_::_, _) = BackendVariable.getVar(cr2, knvars);
e = if negate then Expression.negate(e2) else e2;
initalAliases = BaseHashTable.add((cr1, e), iInitalAliases);
if Flags.isSet(Flags.DUMPOPTINIT) then
BackendDump.debugStrCrefStrExpStr("Found initial Alias ", cr1, " = ", e, "\n");
end if;
then initalAliases;

case (_, _, _, _, _, _, _) equation
(_::_, _) = BackendVariable.getVar(cr1, knvars);
e = if negate then Expression.negate(e1) else e1;
initalAliases = BaseHashTable.add((cr2, e), iInitalAliases);
if Flags.isSet(Flags.DUMPOPTINIT) then
BackendDump.debugStrCrefStrExpStr("Found initial Alias ", cr2, " = ", e, "\n");
end if;
then initalAliases;
end matchcontinue;
end addInitialAlias;

protected function optimizeInitialAliases "author: Frenkel TUD 2012-08"
input BackendDAE.EqSystem inSyst;
input HashTable2.HashTable initalAliases;
output BackendDAE.EqSystem outSyst;
protected
Option<BackendDAE.IncidenceMatrix> m, mT;
BackendDAE.Variables vars;
BackendDAE.EquationArray eqns;
BackendDAE.Matching matching;
Boolean b;
BackendDAE.StateSets stateSets;
BackendDAE.BaseClockPartitionKind partitionKind;
algorithm
BackendDAE.EQSYSTEM(vars, eqns, m, mT, matching, stateSets, partitionKind) := inSyst;
(vars, (_, b)) := BackendVariable.traverseBackendDAEVarsWithUpdate(vars, optimizeInitialAliasesFinder, (initalAliases, false));
outSyst := if b then BackendDAE.EQSYSTEM(vars, eqns, m, mT, matching, stateSets, partitionKind) else inSyst;
end optimizeInitialAliases;

protected function optimizeInitialAliasesFinder "author: Frenkel TUD 2011-03"
input BackendDAE.Var inVar;
input tuple<HashTable2.HashTable, Boolean> inTpl;
output BackendDAE.Var outVar;
output tuple<HashTable2.HashTable, Boolean> outTpl;
algorithm
(outVar,outTpl) := matchcontinue (inVar,inTpl)
local
BackendDAE.Var v;
HashTable2.HashTable initalAliases;
DAE.ComponentRef varName;
DAE.Exp exp;

case (v as BackendDAE.VAR(varName=varName), (initalAliases, _)) equation
exp = BaseHashTable.get(varName, initalAliases);
v = BackendVariable.setVarStartValue(v, exp);
v = BackendVariable.setVarFixed(v, true);
if Flags.isSet(Flags.DUMPOPTINIT) then
BackendDump.debugStrCrefStrExpStr("Set Var ", varName, " (start= ", exp, ", fixed=true)\n");
end if;
then (v, (initalAliases, true));

else (inVar,inTpl);
end matchcontinue;
end optimizeInitialAliasesFinder;

annotation(__OpenModelica_Interface="backend");
end Initialization;
1 change: 0 additions & 1 deletion Compiler/Util/Flags.mo
View file
Expand Up @@ -761,7 +761,6 @@ constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules",
("inputDerivativesUsed", Util.gettext("Checks if derivatives of inputs are need to calculate the model.")),
("simplifysemiLinear", Util.gettext("Simplifies calls to semiLinear.")),
("removeConstants", Util.gettext("Remove all constants in the system.")),
("optimizeInitialSystem", Util.gettext("Simplifies time initial system.")),
("detectJacobianSparsePattern", Util.gettext("Detects the sparse pattern for Jacobian A.")),
("calculateStrongComponentJacobians", Util.gettext("Generates analytical jacobian for non-linear strong components.")),
("calculateStateSetsJacobians", Util.gettext("Generates analytical jacobian for dynamic state selection sets.")),
Expand Down

0 comments on commit 3628240

Please sign in to comment.