Skip to content

Commit

Permalink
Support for previous operator in SimCode
Browse files Browse the repository at this point in the history
  • Loading branch information
@OpenModelica-Hudson
gossen authored and OpenModelica-Hudson committed Aug 31, 2015
1 parent e090c54 commit 9fa1b91
Show file tree
Hide file tree
Showing 6 changed files with 79 additions and 44 deletions.
1 change: 1 addition & 0 deletions Compiler/BackEnd/BackendDAE.mo
View file
Expand Up @@ -143,6 +143,7 @@ uniontype SubPartition
record SUB_PARTITION
SubClock clock;
Boolean holdEvents;
list<.DAE.ComponentRef> prevVars;
end SUB_PARTITION;
end SubPartition;

Expand Down
2 changes: 1 addition & 1 deletion Compiler/BackEnd/BackendDAEUtil.mo
View file
Expand Up @@ -7867,7 +7867,7 @@ protected
array<BackendDAE.SubPartition> subPartitions;
algorithm
basePartitions := arrayCreate(0, BackendDAE.BASE_PARTITION(DAE.INFERRED_CLOCK(), 0));
subPartitions := arrayCreate(0, BackendDAE.SUB_PARTITION(BackendDAE.DEFAULT_SUBCLOCK, false));
subPartitions := arrayCreate(0, BackendDAE.SUB_PARTITION(BackendDAE.DEFAULT_SUBCLOCK, false, {}));
partitionsInfo := BackendDAE.PARTITIONS_INFO(basePartitions, subPartitions);
end emptyPartitionsInfo;

Expand Down
93 changes: 52 additions & 41 deletions Compiler/BackEnd/SynchronousFeatures.mo
View file
Expand Up @@ -96,7 +96,6 @@ protected
array<BackendDAE.BasePartition> basePartitions;
array<BackendDAE.SubPartition> subPartitions;
BackendDAE.Shared shared = inShared;
BackendDAE.PartitionsInfo partitionsInfo;
list<BackendDAE.EqSystem> systs;
BackendDAE.Variables vars;
BackendDAE.EquationArray eqs;
Expand All @@ -107,66 +106,72 @@ protected
algorithm
syst := substituteParitionOpExps(inSyst);

(contSysts, clockedSysts, unpartRemEqs) := baseClockPartitioning(syst, inShared);
(contSysts, clockedSysts, unpartRemEqs) := baseClockPartitioning(syst, shared);

(contSysts, holdComps) := removeHoldExpsSyst(contSysts);

shared.removedEqs := BackendEquation.addEquations(unpartRemEqs, shared.removedEqs);

(clockedSysts, basePartitions, subPartitions) := subClockPartitioning1(clockedSysts, inShared, holdComps);
(clockedSysts, shared) := subClockPartitioning1(clockedSysts, shared, holdComps);
shared := List.fold(clockedSysts, makePreviousFixed, shared);

partitionsInfo := shared.partitionsInfo;
partitionsInfo.basePartitions := basePartitions;
partitionsInfo.subPartitions := subPartitions;
shared.partitionsInfo := partitionsInfo;

clockedSysts := List.map1(clockedSysts, makePreviousFixed, shared);
systs := listAppend(contSysts, clockedSysts);

outDAE := BackendDAE.DAE(systs, shared);

if Flags.isSet(Flags.DUMP_SYNCHRONOUS) then
BackendDump.dumpEqSystems(systs, "clock partitioning");
BackendDump.dumpBasePartitions(partitionsInfo.basePartitions, "Base clocks");
BackendDump.dumpSubPartitions(partitionsInfo.subPartitions, "Sub clocks");
BackendDump.dumpBasePartitions(shared.partitionsInfo.basePartitions, "Base clocks");
BackendDump.dumpSubPartitions(shared.partitionsInfo.subPartitions, "Sub clocks");
end if;
end clockPartitioning1;

protected function makePreviousFixed
input BackendDAE.EqSystem inSyst;
input BackendDAE.Shared inShared;
output BackendDAE.EqSystem outSyst = inSyst;
output BackendDAE.Shared outShared = inShared;
protected
BackendDAE.Equation eq;
list<DAE.ComponentRef> fixedComps = {};
array<Boolean> prevVars;
Option<String> solverMethod;
list<DAE.ComponentRef> prevVars = {};
BackendDAE.EqSystem syst;
array<Boolean> isPrevVarArr;
list<Integer> varIxs;
BackendDAE.Var var;
Integer idx;
BackendDAE.SubPartition subPartition;
algorithm
SOME(BackendDAE.SUBCLOCK(solver=solverMethod)) := BackendDAEUtil.getSubClock(inSyst, inShared);
if isNone(solverMethod) then
prevVars := arrayCreate(BackendVariable.varsSize(outSyst.orderedVars), false);
for i in 1:BackendDAEUtil.equationArraySize(outSyst.orderedEqs) loop
eq := BackendEquation.equationNth1(outSyst.orderedEqs, i);
(_, fixedComps) := BackendEquation.traverseExpsOfEquation(eq, collectPrevVars, fixedComps);
BackendDAE.CLOCKED_PARTITION(idx) := inSyst.partitionKind;
subPartition := outShared.partitionsInfo.subPartitions[idx];

if isNone(subPartition.clock.solver) then
isPrevVarArr := arrayCreate(BackendVariable.varsSize(inSyst.orderedVars), false);

for i in 1:BackendDAEUtil.equationArraySize(inSyst.orderedEqs) loop
eq := BackendEquation.equationNth1(inSyst.orderedEqs, i);
(_, prevVars) := BackendEquation.traverseExpsOfEquation(eq, collectPrevVars, prevVars);
end for;
for i in 1:BackendDAEUtil.equationArraySize(outSyst.removedEqs) loop
eq := BackendEquation.equationNth1(outSyst.removedEqs, i);
(_, fixedComps) := BackendEquation.traverseExpsOfEquation(eq, collectPrevVars, fixedComps);
for i in 1:BackendDAEUtil.equationArraySize(inSyst.removedEqs) loop
eq := BackendEquation.equationNth1(inSyst.removedEqs, i);
(_, prevVars) := BackendEquation.traverseExpsOfEquation(eq, collectPrevVars, prevVars);
end for;
for cr in fixedComps loop
varIxs := getVarIxs(cr, outSyst.orderedVars);
for cr in prevVars loop
varIxs := getVarIxs(cr, inSyst.orderedVars);
for idx in varIxs loop
arrayUpdate(prevVars, idx, true);
arrayUpdate(isPrevVarArr, idx, true);
end for;
end for;
for i in 1:arrayLength(prevVars) loop
if prevVars[i] then
var := BackendVariable.setVarFixed(BackendVariable.getVarAt(outSyst.orderedVars, i), true);
BackendVariable.setVarAt(outSyst.orderedVars, i, var);
prevVars := {};
for i in 1:arrayLength(isPrevVarArr) loop
if isPrevVarArr[i] then
var := BackendVariable.setVarFixed(BackendVariable.getVarAt(inSyst.orderedVars, i), true);
BackendVariable.setVarAt(inSyst.orderedVars, i, var);
prevVars := var.varName::prevVars;
end if;
end for;

subPartition.prevVars := prevVars;
arrayUpdate(outShared.partitionsInfo.subPartitions, idx, subPartition);
end if;

end makePreviousFixed;

protected function collectPrevVars
Expand Down Expand Up @@ -199,30 +204,31 @@ protected function subClockPartitioning1
input BackendDAE.Shared inShared;
input list<DAE.ComponentRef> inHoldComps;
output list<BackendDAE.EqSystem> outSysts = {};
output array<BackendDAE.BasePartition> outBasePartitions;
output array<BackendDAE.SubPartition> outSubPartitions;
output BackendDAE.Shared outShared = inShared;
protected
DAE.ClockKind baseClock;
BackendDAE.Variables vars;
BackendDAE.EquationArray eqs;
BackendDAE.SubClock subclock;
HashTable.HashTable varsPartition;
Integer i, j, n, nBaseClocks;
DAE.ComponentRef cr;
array<Boolean> hasHoldOperator;
BackendDAE.BaseClockPartitionKind partitionKind;
list<BackendDAE.EqSystem> systs;
list<BackendDAE.SubClock> lstSubClocks1, lstSubClocks = {};
BackendDAE.PartitionsInfo partitionsInfo;
array<BackendDAE.BasePartition> basePartitions;
array<BackendDAE.SubPartition> subPartitions;
algorithm
nBaseClocks := listLength(inSysts);
outBasePartitions := arrayCreate(nBaseClocks, BackendDAE.BASE_PARTITION(DAE.INFERRED_CLOCK(), 0));
basePartitions := arrayCreate(nBaseClocks, BackendDAE.BASE_PARTITION(DAE.INFERRED_CLOCK(), 0));
varsPartition := HashTable.emptyHashTable();

i := 0; j := 1;
for syst in inSysts loop
(systs, baseClock, lstSubClocks1) := subClockPartitioning(syst, inShared, i);
(systs, baseClock, lstSubClocks1) := subClockPartitioning(syst, outShared, i);
n := listLength(systs);
arrayUpdate(outBasePartitions, j, BackendDAE.BASE_PARTITION(baseClock, n));
arrayUpdate(basePartitions, j, BackendDAE.BASE_PARTITION(baseClock, n));
outSysts := listAppend(outSysts, systs);
lstSubClocks := listAppend(lstSubClocks, lstSubClocks1);
i := i + n;
Expand All @@ -246,12 +252,17 @@ algorithm
end for;

i := 1;
outSubPartitions := arrayCreate( listLength(lstSubClocks),
BackendDAE.SUB_PARTITION(BackendDAE.DEFAULT_SUBCLOCK, false) );
subPartitions := arrayCreate( listLength(lstSubClocks),
BackendDAE.SUB_PARTITION(BackendDAE.DEFAULT_SUBCLOCK, false, {}) );
for subclock in lstSubClocks loop
arrayUpdate(outSubPartitions, i, BackendDAE.SUB_PARTITION(subclock, hasHoldOperator[i]));
arrayUpdate(subPartitions, i, BackendDAE.SUB_PARTITION(subclock, hasHoldOperator[i], {}));
i := i + 1;
end for;

partitionsInfo := outShared.partitionsInfo;
partitionsInfo.basePartitions := basePartitions;
partitionsInfo.subPartitions := subPartitions;
outShared.partitionsInfo := partitionsInfo;
end subClockPartitioning1;

protected function removeHoldExpsSyst
Expand Down
1 change: 1 addition & 0 deletions Compiler/SimCode/SimCode.mo
View file
Expand Up @@ -138,6 +138,7 @@ end ClockedPartition;

public uniontype SubPartition
record SUBPARTITION
list<tuple<SimCodeVar.SimVar, Boolean /*previous*/>> vars;
list<SimEqSystem> equations;
list<SimEqSystem> removedEquations;
BackendDAE.SubClock subClock;
Expand Down
25 changes: 23 additions & 2 deletions Compiler/SimCode/SimCodeUtil.mo
View file
Expand Up @@ -564,9 +564,12 @@ protected
SimCodeVar.SimVar simVar;
DAE.ComponentRef cr;
list<SimCodeVar.SimVar> clockedVars;
list<tuple<SimCodeVar.SimVar, Boolean>> prevClockedVars;
array<Option<SimCode.SubPartition>> simSubPartitions;
BackendDAE.SubPartition subPartition;
BackendDAE.Var var;
array<Boolean> isPrevVar;
SimCode.SimEqSystem simEq;
algorithm
simSubPartitions := arrayCreate(arrayLength(inShared.partitionsInfo.subPartitions), NONE());
funcs := BackendDAEUtil.getFunctions(inShared);
Expand Down Expand Up @@ -594,13 +597,31 @@ algorithm
equations := List.map(equations, addDivExpErrorMsgtoSimEqSystem);
removedEquations := List.map(removedEquations, addDivExpErrorMsgtoSimEqSystem);

prevClockedVars := {};
isPrevVar := arrayCreate(BackendVariable.varsSize(syst.orderedVars), false);
for cr in subPartition.prevVars loop
(_, varIxs) := BackendVariable.getVar(cr, syst.orderedVars);
for i in varIxs loop
arrayUpdate(isPrevVar, i, true);
end for;
end for;
for i in 1:BackendVariable.varsSize(syst.orderedVars) loop
var := BackendVariable.getVarAt(syst.orderedVars, i);
clockedVars := dlowvarToSimvar(var, SOME(inShared.aliasVars), inShared.knownVars)::clockedVars;
simVar := dlowvarToSimvar(var, SOME(inShared.aliasVars), inShared.knownVars);
prevClockedVars := (simVar, isPrevVar[i])::prevClockedVars;
clockedVars := simVar::clockedVars;
if isPrevVar[i] then
cr := simVar.name;
simVar.name := ComponentReference.crefPrefixString("$CLKPRE", cr);
clockedVars := simVar::clockedVars;
simEq := SimCode.SES_SIMPLE_ASSIGN(ouniqueEqIndex, simVar.name, DAE.CREF(cr, simVar.type_), DAE.emptyElementSource);
equations := simEq::equations;
ouniqueEqIndex := ouniqueEqIndex + 1;
end if;
end for;

otempvars := listAppend(clockedVars, otempvars);
simSubPartition := SimCode.SUBPARTITION(equations, removedEquations, subPartition.clock, subPartition.holdEvents);
simSubPartition := SimCode.SUBPARTITION(prevClockedVars, equations, removedEquations, subPartition.clock, subPartition.holdEvents);

assert(isNone(simSubPartitions[subPartIdx]), "SimCodeUtil.translateClockedEquations failed");
arrayUpdate(simSubPartitions, subPartIdx, SOME(simSubPartition));
Expand Down
1 change: 1 addition & 0 deletions Compiler/Template/SimCodeTV.mo
View file
Expand Up @@ -314,6 +314,7 @@ package SimCode

uniontype SubPartition
record SUBPARTITION
list<tuple<SimCodeVar.SimVar, Boolean>> vars;
list<SimEqSystem> equations;
list<SimEqSystem> removedEquations;
BackendDAE.SubClock subClock;
Expand Down

0 comments on commit 9fa1b91

Please sign in to comment.