std::pair<bool, bool> RootedForest<T, U>::checkWithPreviouslyAddedStatement(const PhyloStatement &ps) const {
if (false && debuggingOutputEnabled) {
dbWriteOttSet(" RootedForest::conflictsWithPreviouslyAddedStatement incGroup ", ps.includeGroup);
dbWriteOttSet(" leafSet", ps.leafSet);
}
for (const auto sIt : addedSplitsByLeafSet) {
const auto & prevAddedLeafSet = sIt.first;
const auto relLeafSet = set_intersection_as_set(prevAddedLeafSet, ps.leafSet);
const bool exactLS = relLeafSet.size() == ps.leafSet.size();
if (relLeafSet.size() < 3) { // no conflict is possible if the intersection is so small that no phylostatements are made
continue;
}
const auto relIncGroup = set_intersection_as_set(ps.includeGroup, relLeafSet);
const auto & setPrevInc = sIt.second;
for (const auto & prevInc : setPrevInc) {
if (exactLS && prevInc == ps.includeGroup) {
return std::pair<bool, bool>(false, true);
}
if (culledAndCompleteIncompatWRTLeafSet(relIncGroup, prevInc, relLeafSet)) {
return std::pair<bool, bool>(true, false);
}
}
}
return std::pair<bool, bool>(false, false);
}
bool culledAndCompleteIncompatWRTLeafSet(const OttIdSet & culled,
const OttIdSet & complete,
const OttIdSet & leafSet) {
//TMP this could be more efficient. See areCompatibleDesIdSets
const OttIdSet inter = set_intersection_as_set(culled, complete);
if (inter.empty()) {
return false;
}
if (inter == culled) {
return false;
}
const OttIdSet compCulled = set_intersection_as_set(complete, leafSet);
return (inter != compCulled);
}
std::list<OverlapFTreePair<T, U> > RootedForest<T, U>::getSortedOverlappingTrees(const OttIdSet &inc) {
typedef OverlapFTreePair<T, U> MyOverlapFTreePair;
std::map<std::size_t, std::list<MyOverlapFTreePair> > byOverlapSize;
for (auto & tpIt : trees) {
tree_type * ftree = &(tpIt.second);
const OttIdSet & inTree = ftree->getIncludedOttIds();
const OttIdSet inter = set_intersection_as_set(inTree, inc);
if (!inter.empty()) {
const auto k = inter.size();
auto & tsList = byOverlapSize[k];
tsList.push_back(MyOverlapFTreePair(inter, ftree));
}
}
std::list<MyOverlapFTreePair> r;
consumeMapToList(byOverlapSize, r);
return r;
}
bool RootedForest<T, U>::checkCanAddIngroupOverlappingPhyloStatementToGraph(
const std::list<OverlapFTreePair<T, U> > & byIncCardinality,
const PhyloStatement &ps,
std::list<node_type * > & nonTrivMRCAs,
OttIdSet & attachedElsewhere,
std::vector<bool> & shouldResolveVec,
std::vector<bool> & shouldCreateDeeperVec) const {
for (const auto & incPair : byIncCardinality) {
const auto & incGroupIntersection = incPair.first;
attachedElsewhere.insert(incGroupIntersection.begin(), incGroupIntersection.end());
tree_type * f = incPair.second;
node_type * includeGroupA = nullptr;
includeGroupA = f->getMRCA(incGroupIntersection);
assert(includeGroupA != nullptr);
assert(getTreeForNode(includeGroupA) == f);
if (includeGroupA->isTip()) {
// this can happen if the overlap is one taxon.
includeGroupA = includeGroupA->getParent();
assert(includeGroupA != nullptr);
assert(getTreeForNode(includeGroupA) == f);
}
// If any of the ingroup are specifically excluded, then we have move deeper in the tree.
// TMP this could be more efficient and avoid the while loop.
while (f->anyExcludedAtNode(includeGroupA, ps.includeGroup)) {
if (f->anyIncludedAtNode(includeGroupA, ps.excludeGroup)) {
return false;
}
if (f->anyPhantomNodesAtNode(includeGroupA, ps.includeGroup)) {
return false;
}
includeGroupA = includeGroupA->getParent();
if (includeGroupA == nullptr) {
break;
}
assert(getTreeForNode(includeGroupA) == f);
}
OttIdSet excInc;
bool forceDeeperRoot = false;
if (includeGroupA == nullptr) {
includeGroupA = f->getRoot();
forceDeeperRoot = true;
assert(getTreeForNode(includeGroupA) == f);
} else {
excInc = set_intersection_as_set(includeGroupA->getData().desIds, ps.excludeGroup);
if (debuggingOutputEnabled) {
LOG(DEBUG) << " addPhyloStatementToGraph search for an ancestor of ...";
dbWriteOttSet(" addPhyloStatementToGraph search for an ancestor of: ", incGroupIntersection);
dbWriteOttSet(" wanted to avoid = ", ps.excludeGroup);
dbWriteOttSet(" found a node with desIds: ", includeGroupA->getData().desIds);
dbWriteOttSet(" which includes the excludegroup members: ", excInc);
}
if (!canBeResolvedToDisplayIncExcGroup(includeGroupA, ps.includeGroup, excInc)) {
return false; // the MRCA of the includeGroup had interdigitated members of the excludeGroup
}
}
shouldCreateDeeperVec.push_back(forceDeeperRoot);
shouldResolveVec.push_back(!excInc.empty());
nonTrivMRCAs.push_back(includeGroupA);
}
return true;
}
