diff --git a/AlgebraicDataflowArchitectureModel/src/models/dependencyModel/DependencyGraph.java b/AlgebraicDataflowArchitectureModel/src/models/dependencyModel/DependencyGraph.java
index 2108c73..fa40d9d 100644
--- a/AlgebraicDataflowArchitectureModel/src/models/dependencyModel/DependencyGraph.java
+++ b/AlgebraicDataflowArchitectureModel/src/models/dependencyModel/DependencyGraph.java
@@ -77,62 +77,49 @@
         }
     }
 
-//    private void initStatefulObjectNodes(DataFlowGraph dfGraph) {
-//        statefulObjectNodes = new HashSet<>();
-//        for (ResourceNode resNode : dfGraph.getResourceNodes()) {
-//            StatefulObjectNode found = null;
-//            StatefulObjectNode sNode = null;
-//
-//            for (Node node : getNodes()) {
-//                if (node instanceof StatefulObjectNode) {
-//                    sNode = (StatefulObjectNode) node;
-//                    if (sNode.getResource() == resNode) {
-//                        found = sNode;
-//                        statefulObjectNodes.add(sNode);
-//                        break;
-//                    }
-//                }
-//            }
-//
-//            if (found == null) {
-//                statefulObjectNodes.add((StatefulObjectNode) addNode(sNode));
-//            }
-//
-//        }
-//    }
-
     public ObjectNode addNode(ObjectNode node) {
         if (node instanceof EventChannelObjectNode) {
             EventChannelObjectNode ecoNode = (EventChannelObjectNode) node;
-            if (!objectNodeMap.containsKey(ecoNode)) {
-                ecoNode = new EventChannelObjectNode(((EventChannelObjectNode) node).getIOChannel());
-                objectNodeMap.put(node, ecoNode);
-                super.addNode(ecoNode);
-                return ecoNode;
+
+            for (Node n : getNodes()) {
+                if (n instanceof EventChannelObjectNode) {
+                    EventChannelObjectNode existing = (EventChannelObjectNode) n;
+                    if (existing.getIOChannel().equals(ecoNode.getIOChannel())) {
+                        objectNodeMap.put(node, existing);
+                        return existing;
+                    }
+                }
             }
+            objectNodeMap.put(node, node);
+            super.addNode(node);
+            return node;
+
         } else if (node instanceof StatefulObjectNode) {
             StatefulObjectNode sNode = (StatefulObjectNode) node;
-            if (!objectNodeMap.containsKey(sNode)) {
-                sNode = new StatefulObjectNode(((StatefulObjectNode) node).getResource());
-                objectNodeMap.put(node, sNode);
-                super.addNode(sNode);
-                return sNode;
+
+            for (Node n : getNodes()) {
+                if (n instanceof StatefulObjectNode) {
+                    StatefulObjectNode existing = (StatefulObjectNode) n;
+                    if (existing.getResource().equals(sNode.getResource())) {
+                        objectNodeMap.put(node, existing);
+                        return existing;
+                    }
+                }
             }
-        } else {
+            objectNodeMap.put(node, node);
             super.addNode(node);
+            return node;
         }
+
+        super.addNode(node);
         return node;
     }
 
     public void addEdge(Node srcNode, Node dstNode){
-        addNode((ObjectNode) srcNode);
-        addNode((ObjectNode) dstNode);
-        addEdge(new DependencyEdge(getOrCreateObjectNode((ObjectNode)
-                srcNode), getOrCreateObjectNode((ObjectNode) dstNode), DependencyEdge.EdgeType.DEPENDENCY));
-    }
+        ObjectNode normalizedSrc = addNode((ObjectNode) srcNode);
+        ObjectNode normalizedDst = addNode((ObjectNode) dstNode);
 
-    private ObjectNode getOrCreateObjectNode(ObjectNode node) {
-        return objectNodeMap.get(node);
+        super.addEdge(new DependencyEdge(normalizedSrc, normalizedDst, DependencyEdge.EdgeType.DEPENDENCY));
     }
 
     public DataFlowGraph getDataFlowGraph(){