Skip to content

Commit

Permalink
- setup sparsty pattern calculation as postOptModule
Browse files Browse the repository at this point in the history 
   (not activated yet by defalt due to some issue with tearing module)



git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@13323 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
Willi Braun committed Oct 11, 2012
1 parent 4e6debd commit 0138cbc
Show file tree
Hide file tree
Showing 22 changed files with 1,411 additions and 602 deletions.
22 changes: 19 additions & 3 deletions Compiler/BackEnd/BackendDAE.mo
View file
Expand Up @@ -45,13 +45,21 @@ public import Values;
public import HashTable3;
public import HashTableCG;

public constant String partialDerivativeNamePrefix="$pDER";
public constant Integer RT_PROFILER0=6;
public constant Integer RT_PROFILER1=7;
public constant Integer RT_PROFILER2=8;
public constant Integer RT_CLOCK_EXECSTAT_BACKEND_MODULES=12;
public constant Integer RT_CLOCK_EXECSTAT_JACOBIANS=16;


public constant Integer SymbolicJacobianAIndex = 1;
public constant Integer SymbolicJacobianBIndex = 2;
public constant Integer SymbolicJacobianCIndex = 3;
public constant Integer SymbolicJacobianDIndex = 4;
public constant Integer SymbolicJacobianGIndex = 5;
public constant String partialDerivativeNamePrefix="$pDER";


public type Type = .DAE.Type
"Once we are in BackendDAE, the Type can be only basic types or enumeration.
We cannot do this in DAE because functions may contain many more types.
Expand Down Expand Up @@ -527,6 +535,8 @@ uniontype DivZeroExpReplace "- Should the division operator replaced by a operat
record ONLY_VARIABLES " for expressions with variable variables(no parameters)" end ONLY_VARIABLES;
end DivZeroExpReplace;

public
type SymbolicJacobians = list<tuple<Option<SymbolicJacobian>, SparsePattern, SparseColoring>>;

public
type SymbolicJacobian = tuple< BackendDAE, // symbolic equation system
Expand All @@ -536,7 +546,13 @@ type SymbolicJacobian = tuple< BackendDAE, // symbolic equation sys
list<Var> // all diffed equation
>;

public
type SymbolicJacobians = list<SymbolicJacobian>;
public
type SparsePattern = tuple<list<tuple< .DAE.ComponentRef,list< .DAE.ComponentRef>>>, // column-wise sparse pattern
tuple<list<Var>, // diff vars
list<Var>>>; // diffed vars

public
type SparseColoring = list<list< .DAE.ComponentRef>>; // coloring


end BackendDAE;
3 changes: 2 additions & 1 deletion Compiler/BackEnd/BackendDAECreate.mo
View file
Expand Up @@ -122,7 +122,8 @@ algorithm
constrarra := listArray(constrs);
clsattrsarra := listArray(clsAttrs);
einfo := BackendDAE.EVENT_INFO(whenclauses_1,{});
outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqnarr,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},BackendDAE.SHARED(knvars,extVars,aliasVars,ieqnarr,reqnarr,constrarra,clsattrsarra,inCache,inEnv,functionTree,einfo,extObjCls,BackendDAE.SIMULATION(),{}));
symjacs := {(NONE(),({},({},{})),{}),(NONE(),({},({},{})),{}),(NONE(),({},({},{})),{}),(NONE(),({},({},{})),{})};
outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqnarr,NONE(),NONE(),BackendDAE.NO_MATCHING())::{},BackendDAE.SHARED(knvars,extVars,aliasVars,ieqnarr,reqnarr,constrarra,clsattrsarra,inCache,inEnv,functionTree,einfo,extObjCls,BackendDAE.SIMULATION(),symjacs));
BackendDAEUtil.checkBackendDAEWithErrorMsg(outBackendDAE);
Debug.fcall(Flags.DUMP_BACKENDDAE_INFO,print,"No. of Equations: " +& intString(BackendDAEUtil.equationSize(eqnarr)) +& "\nNo. of Variables: " +& intString(BackendVariable.varsSize(vars_1)) +& "\n");
Debug.execStat("generate Backend Data Structure",BackendDAE.RT_CLOCK_EXECSTAT_BACKEND_MODULES);
Expand Down
482 changes: 334 additions & 148 deletions Compiler/BackEnd/BackendDAEOptimize.mo
View file

Large diffs are not rendered by default.

137 changes: 129 additions & 8 deletions Compiler/BackEnd/BackendDAEUtil.mo
View file
Expand Up @@ -718,11 +718,13 @@ public function addBackendDAESharedJacobian
" function: addBackendDAESharedJacobian
autor: wbraun"
input BackendDAE.SymbolicJacobian inSymJac;
input BackendDAE.SparsePattern inSparsePattern;
input BackendDAE.SparseColoring inSparseColoring;
input BackendDAE.Shared inShared;
output BackendDAE.Shared outShared;
algorithm
outShared:=
match (inSymJac, inShared)
match (inSymJac, inSparsePattern, inSparseColoring, inShared)
local
BackendDAE.Variables knvars,exobj,av;
EquationArray remeqns,inieqns;
Expand All @@ -735,9 +737,9 @@ algorithm
ExternalObjectClasses eoc;
BackendDAEType btp;
BackendDAE.SymbolicJacobians symjacs;
case (_,BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs))
case (_,_,_,BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs))
equation
symjacs = listAppend(symjacs,{inSymJac});
symjacs = {(SOME(inSymJac),inSparsePattern,inSparseColoring),(NONE(),({},({},{})),{}),(NONE(),({},({},{})),{}),(NONE(),({},({},{})),{})};
then
BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs);
end match;
Expand All @@ -746,12 +748,12 @@ end addBackendDAESharedJacobian;
public function addBackendDAESharedJacobians
" function: addBackendDAESharedJacobians
autor: wbraun"
input BackendDAE.SymbolicJacobians inSymJac;
input BackendDAE.SymbolicJacobians inSymJac;
input BackendDAE.Shared inShared;
output BackendDAE.Shared outShared;
algorithm
outShared:=
match (inSymJac,inShared)
match (inSymJac, inShared)
local
BackendDAE.Variables knvars,exobj,av;
EquationArray remeqns,inieqns;
Expand All @@ -765,12 +767,43 @@ algorithm
BackendDAEType btp;
BackendDAE.SymbolicJacobians symjacs;
case (_,BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs))
then
BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,inSymJac);
end match;
end addBackendDAESharedJacobians;

public function addBackendDAESharedJacobianSparsePattern
" function: addBackendDAESharedJacobianSparsePattern
autor: wbraun"
input BackendDAE.SparsePattern inSparsePattern;
input BackendDAE.SparseColoring inSparseColoring;
input Integer inIndex;
input BackendDAE.Shared inShared;
output BackendDAE.Shared outShared;
algorithm
outShared:=
match (inSparsePattern, inSparseColoring, inIndex, inShared)
local
BackendDAE.Variables knvars,exobj,av;
EquationArray remeqns,inieqns;
array<DAE.Constraint> constrs;
array<DAE.ClassAttributes> clsAttrs;
Env.Cache cache;
Env.Env env;
DAE.FunctionTree funcTree;
BackendDAE.EventInfo einfo;
ExternalObjectClasses eoc;
BackendDAEType btp;
BackendDAE.SymbolicJacobians symjacs;
Option<BackendDAE.SymbolicJacobian> symJac;
case (_, _, _, BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs))
equation
symjacs = listAppend(symjacs,inSymJac);
((symJac,_,_)) = listGet(symjacs, inIndex);
symjacs = List.set(symjacs, inIndex, ((symJac, inSparsePattern, inSparseColoring)));
then
BackendDAE.SHARED(knvars,exobj,av,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs);
end match;
end addBackendDAESharedJacobians;
end addBackendDAESharedJacobianSparsePattern;

public function addBackendDAEKnVars
" function: addBackendDAEKnVars
Expand Down Expand Up @@ -866,6 +899,93 @@ algorithm
end match;
end addVarsToEqSystem;

public function addDummyStateIfNeeded
"function addDummyStateIfNeeded
author: Frenkel TUD 2012-09
adds a dummy state if dae contains no states"
input BackendDAE.BackendDAE inBackendDAE;
output BackendDAE.BackendDAE outBackendDAE;
protected
BackendDAE.EqSystems systs;
BackendDAE.Shared shared;
Boolean daeContainsNoStates;
algorithm
BackendDAE.DAE(eqs=systs,shared=shared) := inBackendDAE;
// check if the DAE has states
daeContainsNoStates := addDummyStateIfNeeded1(systs);
// adrpo: add the dummy derivative state ONLY IF the DAE contains no states
systs := Debug.bcallret1(daeContainsNoStates,addDummyState,systs,systs);
outBackendDAE := Util.if_(daeContainsNoStates,BackendDAE.DAE(systs,shared),inBackendDAE);
end addDummyStateIfNeeded;

protected function addDummyStateIfNeeded1
input BackendDAE.EqSystems iSysts;
output Boolean oContainsNoStates;
algorithm
oContainsNoStates := match(iSysts)
local
BackendDAE.EqSystems systs;
BackendDAE.Variables vars;
Boolean containsNoStates;
case ({}) then true;
case (BackendDAE.EQSYSTEM(orderedVars = vars)::systs)
equation
containsNoStates = BackendVariable.traverseBackendDAEVarsWithStop(vars, traverserVaraddDummyStateIfNeeded, true);
containsNoStates = Debug.bcallret1(containsNoStates,addDummyStateIfNeeded1,systs,containsNoStates);
then
containsNoStates;
end match;
end addDummyStateIfNeeded1;

protected function traverserVaraddDummyStateIfNeeded
input tuple<BackendDAE.Var, Boolean> inTpl;
output tuple<BackendDAE.Var, Boolean, Boolean> outTpl;
algorithm
outTpl:= match (inTpl)
local
BackendDAE.Var v;
Boolean b;
case ((v as BackendDAE.VAR(varKind=BackendDAE.STATE()),_))
then ((v,false,false));
case ((v,b)) then ((v,b,b));
end match;
end traverserVaraddDummyStateIfNeeded;

protected function addDummyState
"function: addDummyState
In order for the solver to work correctly at least one state variable
must exist in the equation system. This function therefore adds a
dummy state variable and an equation for that variable."
input BackendDAE.EqSystems isysts;
output BackendDAE.EqSystems osysts;
protected
DAE.ComponentRef cr;
BackendDAE.Var v;
BackendDAE.Variables vars;
DAE.Exp exp;
BackendDAE.Equation eqn;
BackendDAE.EquationArray eqns;
array<Integer> ass;
BackendDAE.EqSystem syst;
algorithm
// generate dummy state
(v,cr) := BackendVariable.createDummyVar();

// generate vars
vars := listVar({v});
/*
* adrpo: after a bit of talk with Francesco Casella & Peter Aronsson we will add der($dummy) = 0;
*/
exp := Expression.crefExp(cr);
eqn := BackendDAE.EQUATION(DAE.CALL(Absyn.IDENT("der"),{exp},DAE.callAttrBuiltinReal),DAE.RCONST(0.0), DAE.emptyElementSource);
eqns := listEquation({eqn});
// generate equationsystem
ass := listArray({1});
syst := BackendDAE.EQSYSTEM(vars,eqns,NONE(),NONE(),BackendDAE.MATCHING(ass,ass,{BackendDAE.SINGLEEQUATION(1,1)}));
// add system to list of systems
osysts := syst::isysts;
end addDummyState;

public function calculateSizes "function: calculateSizes
author: PA
Calculates the number of state variables, nx,
Expand Down Expand Up @@ -8666,7 +8786,8 @@ algorithm
(BackendDAEOptimize.removeUnusedFunctions,"removeUnusedFunctions",false),
(BackendDAEOptimize.simplifyTimeIndepFuncCalls,"simplifyTimeIndepFuncCalls",false),
(BackendDAEOptimize.simplifysemiLinear,"simplifysemiLinear",false),
(BackendDAEOptimize.optimizeInitialSystem,"optimizeInitialSystem",false)
(BackendDAEOptimize.optimizeInitialSystem,"optimizeInitialSystem",false),
(BackendDAEOptimize.detectSparsePatternODE,"detectJacobianSparsePattern",false)
};
strPastOptModules := getPastOptModulesString();
strPastOptModules := Util.getOptionOrDefault(ostrPastOptModules,strPastOptModules);
Expand Down
13 changes: 13 additions & 0 deletions Compiler/BackEnd/BackendVariable.mo
View file
Expand Up @@ -1384,6 +1384,19 @@ algorithm
outVar := setVarKind(outVar,BackendDAE.JAC_DIFF_VAR());
end createpDerVar;

public function createDummyVar "function createDummyVar
author: wbraun
Creates variable with $dummy."
output BackendDAE.Var outVar;
output DAE.ComponentRef outCr;
algorithm
outCr := ComponentReference.makeCrefIdent("$dummy",DAE.T_REAL_DEFAULT,{});
outVar := BackendDAE.VAR(outCr, BackendDAE.STATE(),DAE.BIDIR(),DAE.NON_PARALLEL(),DAE.T_REAL_DEFAULT,NONE(),NONE(),{},
DAE.emptyElementSource,
SOME(DAE.VAR_ATTR_REAL(NONE(),NONE(),NONE(),(NONE(),NONE()),NONE(),SOME(DAE.BCONST(true)),NONE(),NONE(),NONE(),NONE(),NONE(),NONE(),NONE())),
NONE(),DAE.NON_CONNECTOR());
end createDummyVar;

public function copyVarNewName
"function copyVarNewName
author: Frenkel TUD 2012-5
Expand Down
4 changes: 2 additions & 2 deletions Compiler/BackEnd/SimCode.mo
View file
Expand Up @@ -67,8 +67,8 @@ type JacobianColumn = tuple<list<SimEqSystem>, list<SimVar>, String>; // column
type JacobianMatrix = tuple<list<JacobianColumn>, // column
list<SimVar>, // seed vars
String, // matrix name
list<list<Integer>>, // sparse pattern
list<Integer>, // colored cols
tuple<list<tuple<DAE.ComponentRef,list<DAE.ComponentRef>>>,tuple<list<SimVar>,list<SimVar>>>, // sparse pattern
list<list<DAE.ComponentRef>>, // colored cols
Integer>; // max color used


Expand Down

0 comments on commit 0138cbc

Please sign in to comment.