Angiogenesis

src/arcade/core/util/Graph.java

@@ -31,6 +31,9 @@ public enum Strategy {
     /** Collection of all {@code Edge} objects in a graph. */
     private final Bag allEdges;
 
+    /** Map of {@code Node} objects, for lookup. */
+    private final Map<String, Node> nodes;
+
     /** Map of {@code Node} OUT to bag of {@code Edge} objects. */
     private final Map<Node, Bag> nodeToOutBag;
 
@@ -42,6 +45,7 @@ public Graph() {
         allEdges = new Bag();
         nodeToOutBag = new HashMap<>();
         nodeToInBag = new HashMap<>();
+        nodes = new HashMap<>();
     }
 
     /**
@@ -91,6 +95,28 @@ public boolean contains(Edge edge) {
         return checkEdge(edge);
     }
 
+    /**
+     * Retrieve the node object for the given coordinates. Returns null if no node exists.
+     *
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param z the z coordinate
+     * @return the node object
+     */
+    public Node lookup(int x, int y, int z) {
+        return nodes.get("(" + x + "," + y + "," + z + ")");
+    }
+
+    /**
+     * Retrieve the node object for the given coordinates. Returns null if no node exists.
+     *
+     * @param node to lookup an original node
+     * @return the node object
+     */
+    public Node lookup(Node node) {
+        return nodes.get(node.toString());
+    }
+
     /**
      * Gets all edges in the graph.
      *
@@ -255,6 +281,8 @@ public void mergeNodes() {
                     e.setTo(join);
                 }
             }
+
+            nodes.put(join.toString(), join);
         }
     }
 
@@ -278,6 +306,27 @@ public void addEdge(Edge edge) {
         setOutMap(edge.getFrom(), edge);
         setInMap(edge.getTo(), edge);
         setLinks(edge);
+        addNodes(edge);
+    }
+
+    /**
+     * Helper function to adds the nodes from an edge to a graph.
+     *
+     * @param edge the edge to add
+     */
+    private void addNodes(Edge edge) {
+        Node from = edge.getFrom();
+        Node to = edge.getTo();
+        if (!nodes.containsKey(from.toString())) {
+            nodes.put(from.toString(), from);
+        } else {
+            from = nodes.get(from.toString());
+        }
+        if (!nodes.containsKey(to.toString())) {
+            nodes.put(to.toString(), to);
+        } else {
+            to = nodes.get(to.toString());
+        }
     }
 
     /**
@@ -353,6 +402,19 @@ public void removeEdge(Edge edge) {
         unsetOutMap(edge.getFrom(), edge);
         unsetInMap(edge.getTo(), edge);
         unsetLinks(edge);
+        removeNodeIfDetached(edge.getFrom());
+        removeNodeIfDetached(edge.getTo());
+    }
+
+    /**
+     * Remove a node if it is detached from the graph.
+     *
+     * @param node the node to check
+     */
+    private void removeNodeIfDetached(Node node) {
+        if (!nodeToInBag.containsKey(node) && !nodeToOutBag.containsKey(node)) {
+            nodes.remove(node.toString());
+        }
     }
 
     /**
@@ -730,7 +792,8 @@ public static class Edge {
         private final ArrayList<Edge> edgesOut;
 
         /**
-         * Creates an {@code Edge} between two {@link Node} objects.
+         * Creates an {@code Edge} between two {@link Node} objects. Default behavior is to
+         * duplicate nodes.
          *
          * @param from the node the edge is from
          * @param to the node the edge is to
@@ -742,6 +805,21 @@ public Edge(Node from, Node to) {
             edgesOut = new ArrayList<>();
         }
 
+        /**
+         * Creates an {@code Edge} object for graph sites. Used in cases where a new node object is
+         * not needed.
+         *
+         * @param from the node the edge is from
+         * @param to the node the edge is to
+         * @param duplicate {@code true} if nodes should be duplicated, {@code false} otherwise
+         */
+        public Edge(Node from, Node to, boolean duplicate) {
+            this.from = duplicate ? from.duplicate() : from;
+            this.to = duplicate ? to.duplicate() : to;
+            edgesIn = new ArrayList<>();
+            edgesOut = new ArrayList<>();
+        }
+
         /**
          * Gets the node the edge points to based on the calculation strategy (e.g. upstream or
          * downstream).
@@ -822,7 +900,7 @@ public ArrayList<Edge> getEdgesOut() {
          *
          * @return the reversed edge
          */
-        Edge reverse() {
+        public Edge reverse() {
             Node tempTo = to;
             Node tempFrom = from;
             to = tempFrom;

src/arcade/core/util/Solver.java

@@ -428,9 +428,11 @@ private static double[] sparseSOR(
      * @param a the lower bound on the interval
      * @param b the upper bound on the interval
      * @param maxIters the maximum number of iterations
+     * @param tolerance the error tolerance
      * @return the root of the function
      */
-    public static double bisection(Function func, double a, double b, int maxIters) {
+    public static double bisection(
+            Function func, double a, double b, int maxIters, double tolerance) {
         double c;
         double fc;
         int i = 0;
@@ -452,7 +454,7 @@ public static double bisection(Function func, double a, double b, int maxIters)
             fc = func.f(c);
 
             // Check for exit conditions.
-            if (fc == 0 || (b - a) / 2 < DELTA) {
+            if (fc == 0 || (b - a) / 2 < tolerance) {
                 return c;
             } else {
                 if (Math.signum(fc) == Math.signum(func.f(a))) {
@@ -469,7 +471,7 @@ public static double bisection(Function func, double a, double b, int maxIters)
     }
 
     /**
-     * Finds root using bisection method with default maximum iterations.
+     * Finds root using bisection method with default maximum iterations and tolerance.
      *
      * <p>Root is found by repeatedly bisecting the interval and selecting the interval in which the
      * function changes sign. If no root is found, the simulation will throw an ArithmeticException.
@@ -480,6 +482,38 @@ public static double bisection(Function func, double a, double b, int maxIters)
      * @return the root of the function
      */
     public static double bisection(Function func, double a, double b) {
-        return bisection(func, a, b, MAX_ITERS);
+        return bisection(func, a, b, MAX_ITERS, DELTA);
+    }
+
+    /**
+     * Finds root using bisection method with default maximum iterations.
+     *
+     * <p>Root is found by repeatedly bisecting the interval and selecting the interval in which the
+     * function changes sign. If no root is found, the simulation will throw an ArithmeticException.
+     *
+     * @param func the function
+     * @param a the lower bound on the interval
+     * @param b the upper bound on the interval
+     * @param tolerance the error tolerance
+     * @return the root of the function
+     */
+    public static double bisection(Function func, double a, double b, double tolerance) {
+        return bisection(func, a, b, MAX_ITERS, tolerance);
+    }
+
+    /**
+     * Finds root using bisection method with default tolerance.
+     *
+     * <p>Root is found by repeatedly bisecting the interval and selecting the interval in which the
+     * function changes sign. If no root is found, the simulation will throw an ArithmeticException.
+     *
+     * @param func the function
+     * @param a the lower bound on the interval
+     * @param b the upper bound on the interval
+     * @param maxIters the maximum number of iterations
+     * @return the root of the function
+     */
+    public static double bisection(Function func, double a, double b, int maxIters) {
+        return bisection(func, a, b, maxIters, TOLERANCE);
     }
 }

src/arcade/core/util/exceptions/IncompatibleFeatureException.java

@@ -0,0 +1,22 @@
+package arcade.core.util.exceptions;
+
+/** Exception thrown when incompatible features are given. */
+public class IncompatibleFeatureException extends RuntimeException {
+    /**
+     * Constructs an {@code IncompatibleFeatureException} with the specified detail message.
+     *
+     * @param feature the feature name
+     * @param given the given associated feature
+     * @param expected the expected associated feature
+     */
+    public IncompatibleFeatureException(String feature, String given, String expected) {
+        super(
+                String.format(
+                        feature
+                                + "is incompatible with "
+                                + given
+                                + ", must be associated with "
+                                + expected
+                                + "."));
+    }
+}

src/arcade/core/util/exceptions/MissingSpecificationException.java

@@ -0,0 +1,13 @@
+package arcade.core.util.exceptions;
+
+/** Exception thrown when a specification is missing. */
+public class MissingSpecificationException extends RuntimeException {
+    /**
+     * Constructs an {@code MissingSpecificationException} with the specified detail message.
+     *
+     * @param missing the expected specification
+     */
+    public MissingSpecificationException(String missing) {
+        super("The input file must contain the following specification: ");
+    }
+}