Implement H5 Fanin (rather ineffeciently) (and untested)

analysis/FaultTree/AbstractFaultTreeVisitor.java

 package FaultTree;
 
 public abstract class AbstractFaultTreeVisitor {
-    public void visit(FaultTree tree) {
+    public final void visit(FaultTree tree) {
+        visitAny(tree);
         if (tree instanceof IntermediateEvent)
             visitIntermediateEvent((IntermediateEvent)tree);
         else if (tree instanceof BasicEvent)
             visitBasicEvent((BasicEvent)tree);
     }
-    public abstract void visitIntermediateEvent(IntermediateEvent event);
-    public abstract void visitBasicEvent(BasicEvent event);
+
+    public void visitAny(FaultTree event) {
+
+    }
+
+    public void visitIntermediateEvent(IntermediateEvent event) {
+        visit(event.left);
+        visit(event.right);
+    }
+
+    public void visitBasicEvent(BasicEvent event) {
+
+    }
 }

analysis/Heuristics/ByWeightHeuristic.java

@@ -3,6 +3,7 @@ package Heuristics;
 import java.util.HashMap;
 import java.util.Map;
 import FaultTree.*;
+import Heuristics.Helpers.DepthFirstByWeightOrderer;
 
 public class ByWeightHeuristic implements Heuristic {
     private class FaultTreeScale extends AbstractFaultTreeVisitor {
@@ -25,36 +26,6 @@ public class ByWeightHeuristic implements Heuristic {
         }
     }
 
-    private class DepthFirstByWeightOrderer extends AbstractFaultTreeVisitor {
-        private Map<FaultTree, Integer> weights;
-        private int counter = 0;
-        private Map<BasicEvent, Integer> order = new HashMap<>();
-
-        public DepthFirstByWeightOrderer(Map<FaultTree, Integer> weights) {
-            this.weights = weights;
-        }
-        
-        @Override
-        public void visitIntermediateEvent(IntermediateEvent event) {
-            if (weights.get(event.left) >= weights.get(event.right)) {
-                visit(event.left);
-                visit(event.right);
-            } else {
-                visit(event.right);
-                visit(event.left);
-            }
-        }
-
-        @Override
-        public void visitBasicEvent(BasicEvent event) {
-            order.put(event, counter++);
-        }
-        
-        public Map<BasicEvent, Integer> getOrder() {
-            return order;
-        }
-    }
-
     @Override
     public Map<BasicEvent, Integer> getOrder(FaultTree tree) {
         var scale = new FaultTreeScale();

analysis/Heuristics/FaninHeuristic.java

+package Heuristics;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import FaultTree.*;
+import Heuristics.Helpers.DepthFirstByWeightOrderer;
+
+public class FaninHeuristic implements Heuristic {
+    private class FaultTreeAltometer extends AbstractFaultTreeVisitor {
+        private Map<FaultTree, Integer> depths = new HashMap<>();
+        @Override
+        public void visitIntermediateEvent(IntermediateEvent event) {
+            visit(event.left);
+            visit(event.right);
+            var ld = depths.get(event.left);
+            var rd = depths.get(event.right);
+            depths.put(event, Math.max(ld, rd) + 1);
+        }
+        @Override
+        public void visitBasicEvent(BasicEvent event) {
+            depths.put(event, 0);
+        }
+        public int getDepth(FaultTree tree) {
+            return depths.get(tree);
+        }
+    }
+
+    private class FaultTreeDepthSurvey extends AbstractFaultTreeVisitor {
+        private Map<FaultTree, Integer> depths = new HashMap<>();
+        @Override
+        public void visitAny(FaultTree event) {
+            var altometer = new FaultTreeAltometer();
+            altometer.visit(event);
+            depths.put(event, altometer.getDepth(event));
+        }
+        public Map<FaultTree, Integer> getDepths() {
+            return depths;
+        }
+    }
+
+    @Override
+    public Map<BasicEvent, Integer> getOrder(FaultTree tree) {
+        var survey = new FaultTreeDepthSurvey();
+        survey.visit(tree);
+        var weights = survey.getDepths();
+        var orderer = new DepthFirstByWeightOrderer(weights);
+        orderer.visit(tree);
+        return orderer.getOrder();
+    }
+    
+}

analysis/Heuristics/Helpers/DepthFirstByWeightOrderer.java

+package Heuristics.Helpers;
+
+import FaultTree.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DepthFirstByWeightOrderer extends AbstractFaultTreeVisitor {
+    private Map<FaultTree, Integer> weights;
+    private int counter = 0;
+    private Map<BasicEvent, Integer> order = new HashMap<>();
+
+    public DepthFirstByWeightOrderer(Map<FaultTree, Integer> weights) {
+        this.weights = weights;
+    }
+    
+    @Override
+    public void visitIntermediateEvent(IntermediateEvent event) {
+        if (weights.get(event.left) >= weights.get(event.right)) {
+            visit(event.left);
+            visit(event.right);
+        } else {
+            visit(event.right);
+            visit(event.left);
+        }
+    }
+
+    @Override
+    public void visitBasicEvent(BasicEvent event) {
+        order.put(event, counter++);
+    }
+    
+    public Map<BasicEvent, Integer> getOrder() {
+        return order;
+    }
+}
\ No newline at end of file

analysis/Main/Main.java

@@ -3,6 +3,7 @@ package Main;
 import java.util.Map;
 import FaultTree.*;
 import Heuristics.ByWeightHeuristic;
+import Heuristics.FaninHeuristic;
 import Heuristics.Heuristic;
 
 public class Main {
@@ -19,6 +20,10 @@ public class Main {
             case "by-weight":
                 heuristic = new ByWeightHeuristic();
                 break;
+            case "h5":
+            case "fanin":
+                heuristic = new FaninHeuristic();
+                break;
             default:
                 throw new Exception("You have to specify a valid heuristic.");
         }