sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

DFTIsomorphism now runs in the presence of SEQs 

Former-commit-id: 2666490663
tempestpy_adaptions
sjunges 9 years ago
parent
f562a84316
commit
63d2faf1ed
1 changed files with 100 additions and 11 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 111
      src/storage/dft/DFTIsomorphism.h

111
src/storage/dft/DFTIsomorphism.h
View File

@ -14,7 +14,7 @@ namespace storage {
struct GateGroupToHash {
static constexpr uint_fast64_t fivebitmask = (1 << 6) - 1;
static constexpr uint_fast64_t eightbitmaks = (1 << 8) - 1;
static constexpr uint_fast64_t eightbitmask = (1 << 8) - 1;
/**
* Hash function, which ensures that the colours are sorted according to their rank.
@ -25,7 +25,7 @@ namespace storage {
//Assumes 5 bits for the rank,
groupHash |= (static_cast<uint_fast64_t>(rank) & fivebitmask) << (62 - 5);
// 8 bits for the nrChildren,
groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmaks) << (62 - 5 - 8);
groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmask) << (62 - 5 - 8);
// 5 bits for nrParents,
groupHash |= (static_cast<uint_fast64_t>(nrParents) & fivebitmask) << (62 - 5 - 8 - 5);
// 5 bits for nrPDEPs,
@ -37,6 +37,20 @@ namespace storage {
};
struct RestrictionGroupToHash {
static constexpr uint_fast64_t fivebitmask = (1 << 6) - 1;
static constexpr uint_fast64_t eightbitmask = (1 << 8) - 1;
uint_fast64_t operator()(DFTElementType type, size_t nrChildren, size_t rank) const {
uint_fast64_t groupHash = static_cast<uint_fast64_t>(0);
groupHash |= (static_cast<uint_fast64_t>(rank) & fivebitmask) << (62 - 5);
groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmask) << (62 - 5 - 8);
groupHash |= (static_cast<uint_fast64_t>(type) & fivebitmask) << (62 - 5 - 8 - 5);
return groupHash;
}
};
template<typename ValueType>
struct BEColourClass {
@ -53,8 +67,6 @@ namespace storage {
return lhs.hash == rhs.hash && lhs.aRate == rhs.aRate && lhs.pRate == rhs.pRate;
}
/**
*
*/
@ -63,13 +75,14 @@ namespace storage {
std::unordered_map<size_t, std::vector<size_t>> gateCandidates;
std::unordered_map<BEColourClass<ValueType>, std::vector<size_t>> beCandidates;
std::unordered_map<std::pair<ValueType, ValueType>, std::vector<size_t>> pdepCandidates;
std::unordered_map<size_t, std::vector<size_t>> restrictionCandidates;
size_t nrGroups() const {
return gateCandidates.size() + beCandidates.size() + pdepCandidates.size();
return gateCandidates.size() + beCandidates.size() + pdepCandidates.size() + restrictionCandidates.size();
}
size_t size() const {
return nrGates() + nrBEs() + nrDeps();
return nrGates() + nrBEs() + nrDeps() + nrRestrictions();
}
size_t nrGates() const {
@ -96,6 +109,14 @@ namespace storage {
return res;
}
size_t nrRestrictions() const {
size_t res = 0;
for(auto const& x : restrictionCandidates) {
res += x.second.size();
}
return res;
}
bool hasGate(size_t index) const {
for(auto const& x : gateCandidates) {
for( auto const& ind : x.second) {
@ -123,8 +144,18 @@ namespace storage {
return false;
}
bool hasRestriction(size_t index) const {
for(auto const& x : restrictionCandidates) {
for(auto const& ind : x.second) {
if(index == ind) return true;
}
}
return false;
}
bool has(size_t index) const {
return hasGate(index) || hasBE(index) || hasDep(index);
return hasGate(index) || hasBE(index) || hasDep(index) || hasRestriction(index);
}
@ -152,7 +183,9 @@ namespace storage {
std::unordered_map<size_t, size_t> gateColour;
std::unordered_map<size_t, BEColourClass<ValueType>> beColour;
std::unordered_map<size_t, std::pair<ValueType, ValueType>> depColour;
std::unordered_map<size_t, size_t> restrictionColour;
GateGroupToHash gateColourizer;
RestrictionGroupToHash restrColourizer;
public:
DFTColouring(DFT<ValueType> const& ft) : dft(ft) {
@ -161,9 +194,11 @@ namespace storage {
colourize(dft.getBasicElement(id));
} else if(dft.isGate(id)) {
colourize(dft.getGate(id));
} else {
assert(dft.isDependency(id));
} else if(dft.isDependency(id)) {
colourize(dft.getDependency(id));
} else {
assert(dft.isRestriction(id));
colourize(dft.getRestriction(id));
}
}
}
@ -186,14 +221,21 @@ namespace storage {
} else {
res.gateCandidates[gateColour.at(index)] = std::vector<size_t>({index});
}
} else {
assert(dft.isDependency(index));
} else if(dft.isDependency(index)) {
auto it = res.pdepCandidates.find(depColour.at(index));
if(it != res.pdepCandidates.end()) {
it->second.push_back(index);
} else {
res.pdepCandidates[depColour.at(index)] = std::vector<size_t>({index});
}
} else {
assert(dft.isRestriction(index));
auto it = res.restrictionCandidates.find(restrictionColour.at(index));
if(it != res.restrictionCandidates.end()) {
it->second.push_back(index);
} else {
res.restrictionCandidates[restrictionColour.at(index)] = std::vector<size_t>({index});
}
}
}
@ -214,6 +256,10 @@ namespace storage {
void colourize(std::shared_ptr<const DFTDependency<ValueType>> const& dep) {
depColour[dep->id()] = std::pair<ValueType, ValueType>(dep->probability(), dep->dependentEvent()->activeFailureRate());
}
void colourize(std::shared_ptr<const DFTRestriction<ValueType>> const& restr) {
restrictionColour[restr->id()] = restrColourizer(restr->type(), restr->nrChildren(), restr->rank());
}
};
@ -289,6 +335,7 @@ namespace storage {
initializePermutationsAndTreatTrivialGroups(bleft.beCandidates, bright.beCandidates, currentPermutations.beCandidates);
initializePermutationsAndTreatTrivialGroups(bleft.gateCandidates, bright.gateCandidates, currentPermutations.gateCandidates);
initializePermutationsAndTreatTrivialGroups(bleft.pdepCandidates, bright.pdepCandidates, currentPermutations.pdepCandidates);
initializePermutationsAndTreatTrivialGroups(bleft.restrictionCandidates, bright.restrictionCandidates, currentPermutations.restrictionCandidates);
std::cout << bijection.size() << " vs. " << bleft.size() << " vs. " << bright.size() << std::endl;
assert(bijection.size() == bleft.size());
@ -324,6 +371,15 @@ namespace storage {
}
}
if(!foundNext && !currentPermutations.restrictionCandidates.empty()) {
auto it = currentPermutations.restrictionCandidates.begin();
while(!foundNext && it != currentPermutations.restrictionCandidates.end()) {
foundNext = std::next_permutation(it->second.begin(), it->second.end());
++it;
}
}
if(foundNext) {
for(auto const& colour : bleft.beCandidates) {
zipVectorsIntoMap(colour.second, currentPermutations.beCandidates.find(colour.first)->second, bijection);
@ -336,6 +392,10 @@ namespace storage {
for(auto const& colour : bleft.pdepCandidates) {
zipVectorsIntoMap(colour.second, currentPermutations.pdepCandidates.find(colour.first)->second, bijection);
}
for(auto const& colour : bleft.restrictionCandidates) {
zipVectorsIntoMap(colour.second, currentPermutations.restrictionCandidates.find(colour.first)->second, bijection);
}
}
return foundNext;
@ -378,6 +438,23 @@ namespace storage {
if(bijection.at(lDep->dependentEvent()->id()) != rDep->dependentEvent()->id()) {
return false;
}
} else if(dft.isRestriction(indexpair.first)) {
assert(dft.isRestriction(indexpair.second));
auto const& lRestr = dft.getRestriction(indexpair.first);
std::set<size_t> childrenLeftMapped;
for(auto const& child : lRestr->children() ) {
assert(bleft.has(child->id()));
childrenLeftMapped.insert(bijection.at(child->id()));
}
auto const& rRestr = dft.getRestriction(indexpair.second);
std::set<size_t> childrenRight;
for(auto const& child : rRestr->children() ) {
assert(bright.has(child->id()));
childrenRight.insert(child->id());
}
if(childrenLeftMapped != childrenRight) {
return false;
}
}
else {
assert(dft.isBasicElement(indexpair.first));
@ -405,10 +482,15 @@ namespace storage {
candidatesCompatible = false;
return;
}
if(bleft.restrictionCandidates.size() != bright.restrictionCandidates.size()) {
candidatesCompatible = false;
return;
}
for (auto const &gc : bleft.gateCandidates) {
if (bright.gateCandidates.count(gc.first) == 0) {
candidatesCompatible = false;
return;
}
}
for(auto const& bc : bleft.beCandidates) {
@ -424,6 +506,13 @@ namespace storage {
return;
}
}
for(auto const& dc : bleft.restrictionCandidates) {
if(bright.restrictionCandidates.count(dc.first) == 0) {
candidatesCompatible = false;
return;
}
}
}
/**

Write Preview
Loading…
Cancel
Save