GroupBlock::GroupBlock(GroupBlock *_parent) throw(Exception) : AbstractBlock() {
// force topGroup to false if this group has a parent
- if (_parent != NULL) {
+ if (_parent != NULL) {
topGroup = false;
name = QString("sub_group")+"_"+QString::number(counter++);
}
if (p != NULL) params.removeAll(p);
}
-void GroupBlock::initInputPattern() {
+void GroupBlock::createInputPattern() {
foreach(AbstractInterface* iface, getControlInputs()) {
- iface->setOutputPattern(iface->getConnectedFrom()->getOutputPattern());
- }
+ ConnectedInterface* connIface = AI_TO_CON(iface);
+ QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
+ connIface->setOutputPattern(pattern);
+ }
+}
+
+void GroupBlock::computeAdmittanceDelays() throw(Exception) {
+ throw(Exception(INVALID_GROUPBLOCK_USE));
}
-bool GroupBlock::computeOutputPattern(int nbExec) {
+void GroupBlock::checkInputPatternCompatibility() throw(Exception){
+ throw(Exception(INVALID_GROUPBLOCK_USE));
+}
+
+
+void GroupBlock::computeOutputPattern(int nbExec) throw(Exception) {
+
+ static QString fctName = "GroupBlock::computeOutputPattern()";
+#ifdef DEBUG_FCTNAME
+ cout << "call to " << qPrintable(fctName) << endl;
+#endif
+
+ cout << "computing output pattern of group " << qPrintable(name) << endl;
- bool canCompute = true;
+ bool canCompute = false;
// get the input pattern on each inputs
- initInputPattern();
+ createInputPattern();
+ cout << "Input pattern OK" << endl;
// find blocks that are connected to that inputs and generators
QList<AbstractBlock*> fifo;
foreach(AbstractBlock* block, blocks) {
-
+
bool addIt = false;
// if a block is a generator and has control outputs, add it
if (block->isGeneratorBlock()) {
if (block->getControlOutputs().size() > 0) addIt = true;
}
else {
- // if the block has a control input connected from an intput of the group, add it too
+ // if the block has all its connected inputs that are connected to an intput of the group, add it too
+ addIt = true;
foreach(AbstractInterface* iface, block->getControlInputs()) {
- ConnectedInterface* conn = (ConnectedInterface*)iface;
- ConnectedInterface* groupIface = conn->getConnectionFromParentGroup();
- if (groupIface != NULL) {
- addIt = true;
+ //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
+ ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
+ //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
+
+ if (connFrom == NULL) {
+ addIt = false;
+ break;
+ }
+ else if (connFrom->getOwner() != this) {
+ addIt = false;
break;
}
}
}
- if (addIt) fifo.append(block);
+ if (addIt) {
+ cout << "adding " << qPrintable(block->getName()) << " to initialize the FIFO" << endl;
+ block->setTraversalLevel(0); // level 0 = first blocks to be evaluated
+ fifo.append(block);
+ }
}
+
while (!fifo.isEmpty()) {
AbstractBlock* block = fifo.takeFirst();
- cout << "computing pattern for " << qPrintable(block->getName()) << endl;
- canCompute = block->computeOutputPattern();
- if (!canCompute) {
+
+ if (block->getPatternComputed()) continue; // block has already been processed
+
+ cout << "computing compat and output for " << qPrintable(block->getName()) << endl;
+
+
+ try {
+ block->checkInputPatternCompatibility();
+ }
+ catch(Exception e) {
+ cout << qPrintable(block->getName()) << " is not compatible with its input pattern" << endl;
+ throw(e);
+ }
+
+ try {
+ block->computeOutputPattern();
+ }
+ catch(Exception e) {
cout << "cannot finalize output pattern computation of " << qPrintable(block->getName()) << endl;
- break;
+ throw(e);
}
+ canCompute = true;
block->setPatternComputed(true);
- // add other blocks connected from block to the fifo
+ /* add other blocks connected from block to the fifo but only if
+ all their connected inputs are connected to blocks that have
+ a traversalLevel >=0
+ */
foreach(AbstractInterface* iface, block->getControlOutputs()) {
ConnectedInterface* conn = (ConnectedInterface*)iface;
foreach(ConnectedInterface* connTo, conn->getConnectedTo()) {
- /* if connTo is owned by a functional block
- or by a group block that is within this, add the block to the fifo.
- */
- if (connTo->getOwner()->isFunctionalBlock()) {
- fifo.append(connTo->getOwner());
+
+ AbstractBlock* block1 = connTo->getOwner();
+ cout << "testing if " << qPrintable(block1->getName()) << " has all connected inputs connected to already processed blocks" << endl;
+ bool addIt = true;
+ int maxLevel = 0;
+
+ foreach(AbstractInterface* iface, block1->getControlInputs()) {
+ //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
+ ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
+ //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
+
+ if ((connFrom != NULL) && (connFrom->getOwner()->getPatternComputed() == false)) {
+ addIt = false;
+ break;
+ }
+ else {
+ if (connFrom->getOwner()->getTraversalLevel() > maxLevel) maxLevel = connFrom->getOwner()->getTraversalLevel();
+ }
+ }
+
+ if (addIt) {
+ cout << "adding " << qPrintable(block1->getName()) << " to the FIFO" << endl;
+ block1->setTraversalLevel(maxLevel+1); // level 0 = first blocks to be evaluated
+ fifo.append(block1);
}
- else if (connTo->getOwner() != this) {
- fifo.append(connTo->getOwner());
- }
}
}
}
-
+
if (canCompute) {
foreach(AbstractInterface* iface, getControlOutputs()) {
- iface->setOutputPattern(iface->getConnectedFrom()->getOutputPattern());
+ ConnectedInterface* connIface = AI_TO_CON(iface);
+ QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
+ connIface->setOutputPattern(pattern);
}
setPatternComputed(true);
}
- return canCompute;
+
}
