From 750179dfbd3edc1cdc3710d1bb83d689db2e16c3 Mon Sep 17 00:00:00 2001
From: Richard Roberts <richard.jw.roberts@gmail.com>
Date: Mon, 18 Nov 2013 19:48:37 +0000
Subject: [PATCH] Removed old clique-finding code

---
 gtsam/inference/JunctionTree-inst.h | 60 -----------------------------
 1 file changed, 60 deletions(-)

diff --git a/gtsam/inference/JunctionTree-inst.h b/gtsam/inference/JunctionTree-inst.h
index c88d8927c..35fa870fa 100644
--- a/gtsam/inference/JunctionTree-inst.h
+++ b/gtsam/inference/JunctionTree-inst.h
@@ -55,66 +55,6 @@ namespace gtsam {
       return myData;
     }
 
-    /* ************************************************************************* */
-    // Post-order visitor function
-    template<class BAYESTREE, class GRAPH, class ETREE_NODE>
-    void ConstructorTraversalVisitorPostAlg1(
-      const boost::shared_ptr<ETREE_NODE>& ETreeNode,
-      const ConstructorTraversalData<BAYESTREE,GRAPH>& myData)
-    {
-      // In this post-order visitor, we combine the symbolic elimination results from the
-      // elimination tree children and symbolically eliminate the current elimination tree node.  We
-      // then check whether each of our elimination tree child nodes should be merged with us.  The
-      // check for this is that our number of symbolic elimination parents is exactly 1 less than
-      // our child's symbolic elimination parents - this condition indicates that eliminating the
-      // current node did not introduce any parents beyond those already in the child.
-
-      // Do symbolic elimination for this node
-      SymbolicFactorGraph symbolicFactors;
-      symbolicFactors.reserve(ETreeNode->factors.size() + myData.childSymbolicFactors.size());
-      // Add symbolic versions of the ETree node factors
-      BOOST_FOREACH(const typename GRAPH::sharedFactor& factor, ETreeNode->factors) {
-        symbolicFactors.push_back(boost::make_shared<SymbolicFactor>(
-          SymbolicFactor::FromKeys(*factor))); }
-      // Add symbolic factors passed up from children
-      symbolicFactors.push_back(myData.childSymbolicFactors.begin(), myData.childSymbolicFactors.end());
-      Ordering keyAsOrdering; keyAsOrdering.push_back(ETreeNode->key);
-      std::pair<SymbolicConditional::shared_ptr, SymbolicFactor::shared_ptr> symbolicElimResult =
-        EliminateSymbolic(symbolicFactors, keyAsOrdering);
-
-      // Store symbolic elimination results in the parent
-      myData.parentData->childSymbolicConditionals.push_back(symbolicElimResult.first);
-      myData.parentData->childSymbolicFactors.push_back(symbolicElimResult.second);
-
-      // Merge our children if they are in our clique - if our conditional has exactly one fewer
-      // parent than our child's conditional.
-      const size_t myNrParents = symbolicElimResult.first->nrParents();
-      size_t nrMergedChildren = 0;
-      assert(myData.myJTNode->children.size() == myData.childSymbolicConditionals.size());
-      // Loop over children
-      int combinedProblemSize = (int)symbolicElimResult.first->size();
-      for(size_t child = 0; child < myData.childSymbolicConditionals.size(); ++child) {
-        // Check if we should merge the child
-        if(myNrParents + 1 == myData.childSymbolicConditionals[child]->nrParents()) {
-          // Get a reference to the child, adjusting the index to account for children previously
-          // merged and removed from the child list.
-          const typename JunctionTree<BAYESTREE,GRAPH>::Node& childToMerge =
-            *myData.myJTNode->children[child - nrMergedChildren];
-          // Merge keys, factors, and children.
-          myData.myJTNode->keys.insert(myData.myJTNode->keys.begin(), childToMerge.keys.begin(), childToMerge.keys.end());
-          myData.myJTNode->factors.insert(myData.myJTNode->factors.end(), childToMerge.factors.begin(), childToMerge.factors.end());
-          myData.myJTNode->children.insert(myData.myJTNode->children.end(), childToMerge.children.begin(), childToMerge.children.end());
-          // Increment problem size
-          combinedProblemSize = std::max(combinedProblemSize, childToMerge.problemSize_);
-          // Remove child from list.
-          myData.myJTNode->children.erase(myData.myJTNode->children.begin() + (child - nrMergedChildren));
-          // Increment number of merged children
-          ++ nrMergedChildren;
-        }
-      }
-      myData.myJTNode->problemSize_ = combinedProblemSize;
-    }
-
     /* ************************************************************************* */
     // Post-order visitor function
     template<class BAYESTREE, class GRAPH, class ETREE_NODE>