diff --git a/AlgebraicDataflowArchitectureModel/src/application/editor/stages/DependencyModelingStage.java b/AlgebraicDataflowArchitectureModel/src/application/editor/stages/DependencyModelingStage.java
index c12ff85..5465aec 100644
--- a/AlgebraicDataflowArchitectureModel/src/application/editor/stages/DependencyModelingStage.java
+++ b/AlgebraicDataflowArchitectureModel/src/application/editor/stages/DependencyModelingStage.java
@@ -37,7 +37,6 @@
     private DependencyGraph dependencyGraph = null;
 
     private HashMap<ResourceNode, mxCell> resNodeToCell;
-    private HashMap<DataTransferChannel, mxCell> eventChannelToCell;
     private HashMap<EventChannelObjectNode, mxCell> eventChannelObjNodeToCell;
     private HashMap<mxCell, InterfaceNode> cellToInterfaceNode = new HashMap<>();
 
@@ -78,8 +77,7 @@
             dependencyGraph = new DependencyGraph(controlFlowGraph, model);
 
             resNodeToCell = ((PushPullSelectionStage) prevStage).getResNodeToCell();
-            eventChannelToCell = ((PushPullSelectionStage) prevStage).getEventChannelToCell();
-            buildEventChannelObjNodeMap(prevStage);
+            eventChannelObjNodeToCell =  buildEventChannelObjNodeMap(prevStage);
 
             mxCell parent = (mxCell) graph.getDefaultParent();
             mxCell layer = (mxCell) parent.getChildAt(DEPENDENCY_LAYER);
@@ -116,16 +114,18 @@
     //　private
     //--------------------------------------------------
 
-    private void buildEventChannelObjNodeMap(Stage prevStage) {
-        eventChannelObjNodeToCell = new HashMap<>();
+    private HashMap<EventChannelObjectNode, mxCell> buildEventChannelObjNodeMap(Stage prevStage) {
+        HashMap<EventChannelObjectNode, mxCell> result = new HashMap<>();
 
-        for (Map.Entry<DataTransferChannel, mxCell> entry : ((PushPullSelectionStage) prevStage).getEventChannelToCell().entrySet()) {
-            DataTransferChannel channel = entry.getKey();
-            mxCell cell = entry.getValue();
-
-            EventChannelObjectNode objNode = new EventChannelObjectNode(channel);
-            eventChannelObjNodeToCell.put(objNode, cell);
+        for (EventChannelObjectNode node : dependencyGraph.getEventChannelObjectNodes()) {
+            DataTransferChannel channel = node.getIOChannel();
+            mxCell cell =  ((PushPullSelectionStage) prevStage).getEventChannelToCell().get(channel);
+            if (cell != null) {
+                result.put(node, cell);
+            }
         }
+
+        return result;
     }
 
     private void clearDependencyGraphCells(mxGraph graph) {
@@ -152,12 +152,9 @@
         try {
 
             Map<ResourceNode, mxCell> dependencyResNodeCells = createCellsOfResourceMap();
-            Map<DataTransferChannel, mxCell> dependencyEventNodeCells = createEventChannelCells();
+            Map<EventChannelObjectNode, mxCell> dependencyEventNodeCells = createEventChannelCells();
 
             graph = insertDependencyEdges(dependencyResNodeCells, dependencyEventNodeCells);
-
-            dependencyGraph.getEdges().forEach(e ->
-                    System.out.println(e.getSource() + " -> " + e.getDestination()));
         } finally {
             graph.getModel().endUpdate();
         }
@@ -240,20 +237,19 @@
         dependencyGraph.addEdge(new DependencyEdge(parentNode, childNode));
     }
 
-    private Map<DataTransferChannel, mxCell> createEventChannelCells() {
-        Map<DataTransferChannel, mxCell> eventChannelCells = new HashMap<>();
+    private Map<EventChannelObjectNode, mxCell> createEventChannelCells() {
+        Map<EventChannelObjectNode, mxCell> eventChannelCells = new HashMap<>();
 
         mxCell root = (mxCell) graph.getDefaultParent();
         mxCell dependencyLayer = (mxCell) root.getChildAt(DEPENDENCY_LAYER);
 
         // Recursively copy the EventChannel hierarchy
         for (EventChannelObjectNode eventChannelNode : dependencyGraph.getEventChannelObjectNodes()) {
-            DataTransferChannel channel = eventChannelNode.getIOChannel();
-            if (channel.getInputResources().isEmpty()) {
-                mxCell oldCell = eventChannelToCell.get(channel);
-                if (oldCell != null && !eventChannelCells.containsKey(channel)) {
-                    mxCell newCell = cloneEventChannelHierarchy(oldCell, dependencyLayer, eventChannelCells, channel);
-                    eventChannelCells.put(channel, newCell);
+            if (eventChannelNode.getIOChannel().getInputResources().isEmpty()) {
+                mxCell oldCell = eventChannelObjNodeToCell.get(eventChannelNode);
+                if (oldCell != null && !eventChannelCells.containsKey(eventChannelNode)) {
+                    mxCell newCell = cloneEventChannelHierarchy(oldCell, dependencyLayer, eventChannelCells, eventChannelNode);
+                    eventChannelCells.put(eventChannelNode, newCell);
                 }
             }
         }
@@ -262,7 +258,7 @@
     }
 
     private mxCell cloneEventChannelHierarchy(mxCell oldCell, mxCell newParent,
-                                              Map<DataTransferChannel, mxCell> eventChannelCells, DataTransferChannel rootChannel) {
+                                              Map<EventChannelObjectNode, mxCell> eventChannelCells, EventChannelObjectNode rootNode) {
         mxGeometry geo = (mxGeometry) oldCell.getGeometry();
         if (geo != null) geo = (mxGeometry) geo.clone();
 
@@ -299,15 +295,15 @@
         }
 
         // Associate the channel cell (only if it's a root channel)
-        if (oldCell == eventChannelToCell.get(rootChannel)) {
-            eventChannelCells.put(rootChannel, newCell);
+        if (oldCell == eventChannelObjNodeToCell.get(rootNode)) {
+            eventChannelCells.put(rootNode, newCell);
         }
 
         // Recursively process all child cells
         int childCount = oldCell.getChildCount();
         for (int i = 0; i < childCount; i++) {
             mxCell oldChild = (mxCell) oldCell.getChildAt(i);
-            cloneEventChannelHierarchy(oldChild, newCell, eventChannelCells, rootChannel);
+            cloneEventChannelHierarchy(oldChild, newCell, eventChannelCells, rootNode);
         }
 
         return newCell;
@@ -321,7 +317,7 @@
 
     private mxGraph insertDependencyEdges(
             final Map<ResourceNode, mxCell> resNodeCells,
-            final Map<DataTransferChannel, mxCell> eventChNodeCells
+            final Map<EventChannelObjectNode, mxCell> eventChNodeCells
     ) {
         mxCell root = (mxCell) graph.getDefaultParent();
         mxCell layerCell = (mxCell) root.getChildAt(DEPENDENCY_LAYER);
@@ -340,7 +336,7 @@
 
             // Determine if the source is an EventChannel or a Resource
             if(srcNode instanceof EventChannelObjectNode){
-                srcCell = eventChNodeCells.get(((EventChannelObjectNode) srcNode).getIOChannel());
+                srcCell = eventChNodeCells.get(srcNode);
             } else if (srcNode instanceof StatefulObjectNode){
                 srcCell = resNodeCells.get(((StatefulObjectNode) srcNode).getResource());
                 srcIsRes = true;
@@ -348,7 +344,7 @@
 
             // Determine if the destination is an EventChannel or a Resource
             if(dstNode instanceof EventChannelObjectNode){
-                dstCell = eventChNodeCells.get(((EventChannelObjectNode) dstNode).getIOChannel());
+                dstCell = eventChNodeCells.get(dstNode);
             } else if (dstNode instanceof StatefulObjectNode){
                 dstCell = resNodeCells.get(((StatefulObjectNode) dstNode).getResource());
                 dstIsRes = true;