From 0ee79cfb94a5b65163c7e4bf1df3b2c9bec4952c Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Sun, 12 Jul 2020 00:02:24 +0200
Subject: [PATCH 01/14] node level implementation

---
 src/sneps/network/Network.java                | 35 +++++++
 src/sneps/network/Node.java                   | 96 ++++++++++++++++++-
 src/sneps/network/classes/term/Molecular.java |  3 +-
 3 files changed, 132 insertions(+), 2 deletions(-)

diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index b0a44757..74ec1304 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -10,9 +10,11 @@
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.LinkedList;
+import java.util.List;
 
 import sneps.exceptions.*;
 import sneps.network.cables.Cable;
@@ -36,6 +38,7 @@
 import sneps.network.classes.term.Closed;
 import sneps.network.classes.term.Molecular;
 import sneps.network.classes.term.Open;
+import sneps.network.classes.term.Term;
 import sneps.network.classes.term.Variable;
 import sneps.gui.Main;
 import sneps.network.paths.FUnitPath;
@@ -135,10 +138,16 @@ public class Network implements Serializable {
 	 */
 	private static LinkedList<Integer> userDefinedVarSuffix = new LinkedList<Integer>();
 
+	/**
+	 * A 2D ArrayList that has all the Nodes divided Level By Lebel (LBL) 
+	 */
+	private static  ArrayList<ArrayList<Node>> nodesLBL = new ArrayList<>();
+
 	/**
 	 *
 	 * @return the hash table that stores the nodes defined in the network.
 	 */
+	
 	public static Hashtable<String, Node> getNodes() {
 		return nodes;
 	}
@@ -2109,4 +2118,30 @@ public static void clearNetwork() {
 		userDefinedVarSuffix.clear();
 	}
 
+	/** This method adds a node to the nodesLBL whenever one has been created
+	 * @param node
+	 * @param level appropriate level of the node
+	 */
+	public static void addNodeLBL(Node node, int level) {
+		nodesLBL.get(level).add(node);
+	}
+	
+	/**
+	 * This method updates a node's position in nodesLBL whenever it changed its level
+	 * @param node that changed its level
+	 * @param oldLevel its old level in order to get it from its old position and remove it from the The nodesLBL 
+	 * @param newLevel to put it in its appropriate level
+	 */
+	public static void updateNodeLBL(Node node, int oldLevel, int newLevel) {
+		nodesLBL.get(oldLevel).remove(node);
+		nodesLBL.get(newLevel).add(node);
+	}
+	
+	/**
+	 * @return All the Nodes Divided Level By Level (LBL)
+	 */
+	public static ArrayList<ArrayList<Node>> getNodesLBL(){
+		return nodesLBL;
+	}
+
 }
diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 06a7a505..eb10385e 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -1,6 +1,7 @@
 package sneps.network;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 
 import sneps.network.cables.UpCable;
 import sneps.network.cables.UpCableSet;
@@ -11,6 +12,7 @@
 import sneps.snebr.Context;
 import sneps.snip.channels.Channel;
 import sneps.snip.matching.Substitutions;
+import sneps.network.Network;
 
 public class Node implements Serializable {
 
@@ -19,29 +21,47 @@ public class Node implements Serializable {
 	private static int count = 0;
 	private int id;
 
+	/**
+	 * Attribute level to determine the level of the node
+	 * The higher the node in the y-axis the higher the attribute level
+	 * Which means that the deepest nodes will always have level 0
+	 */
+	private int level;
+	private static int numberOfLevels = 0;
+
 	public Node() {
+		level=0;
 	}
 
 	public Node(Term trm) {
 		term = trm;
 		id = count++;
+		level=0;
 		if(this.getTerm() instanceof Molecular) {
 			this.updateUpCables();
 		}
+		updateParentsLevel();
+		Network.addNodeLBL(this,level);
 	}
 
 	public Node(Semantic sem) {
 		semanticType = sem;
 		id = count++;
+		level=0;
+		updateParentsLevel();
+		Network.addNodeLBL(this,level);
 	}
 
 	public Node(Semantic sem, Term trm) {
 		semanticType = sem;
 		term = trm;
 		id = count++;
+		level=0;
 		if(this.getTerm() instanceof Molecular) {
 			this.updateUpCables();
 		}
+		updateParentsLevel();
+		Network.addNodeLBL(this,level);
 	}
 
 	/**
@@ -264,7 +284,81 @@ public void setTemp(boolean temp) {
 	 * class and pass the current node as a parameter.
 	 */
 	public void updateUpCables() {
-		((Molecular) this.getTerm()).updateUpCables(this);
+		((Molecular) this.getTerm()).updateUpCables(this,level);
+	}
+	
+	
+	/**
+	 * @return the int level attribute of the Node
+	 */
+	public int getLevel() {
+		return level;
+	}
+	
+	/**
+	 * This method updates the node level if needed.
+	 * @param value of the proposed level updated
+	 * @returns boolean to check if level changed.
+	 */
+	public boolean updateLevel(int value) {
+		if(value>level) {
+			Network.updateNodeLBL(this,value,level);
+			level = value;
+			if (level>numberOfLevels)
+				numberOfLevels++;
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * This method updates parents' levels when needed
+	 */
+	public void updateParentsLevel() {
+		NodeSet parentNodes= getParentNodes();
+		for (int i=0; i<parentNodes.size();i++) {
+			Node n=parentNodes.getNode(i);
+			if(n.updateLevel(level+1))
+				n.updateParentsLevel();
+		}
+	}
+
+	public static int getNumberOfLevels() {
+		return numberOfLevels;
+	}
+	
+	/**
+	 * This method gets the parent nodes that are in the ABOVE adjacent level
+	 *
+	 */
+	public ArrayList<Node> getAdjacentParents() {
+		NodeSet parents = getParentNodes();
+		ArrayList<Node> result = new ArrayList<Node>();
+		for (int i=0;i<parents.size();i++) {
+			if(parents.getNode(i).getLevel()==(level+1))
+				result.add(parents.getNode(i));
+		}
+		return result;
+	}
+	
+	/**
+	 * This method gets the parent nodes that are in the BELOW adjacent level
+	 *
+	 */
+	public ArrayList<Node> getAdjacentChildren() {
+		if(getTerm() instanceof Molecular) {
+			ArrayList<Node> children = new ArrayList<Node>();
+			for(int c=0;c<Network.getNodesLBL().get(level-1).size();c++)
+				if(Network.getNodesLBL().get(level-1).get(c).getParentNodes().contains(this))
+					children.add(Network.getNodesLBL().get(level-1).get(c));
+			ArrayList<Node> result = new ArrayList<Node>();
+			for (int i=0;i<children.size();i++) {
+				if(children.get(i).getLevel()==(level-1))
+					result.add(children.get(i));
+			}
+		return result;
+		}
+		return new ArrayList<Node>();
 	}
 
 }
diff --git a/src/sneps/network/classes/term/Molecular.java b/src/sneps/network/classes/term/Molecular.java
index 5125c56c..c2b06f7d 100644
--- a/src/sneps/network/classes/term/Molecular.java
+++ b/src/sneps/network/classes/term/Molecular.java
@@ -51,7 +51,7 @@ public String toString(){
 	 * 			the node object having the current molecular object
 	 * 			as its syntactic object.
 	 */
-	public void updateUpCables(Node node) {
+	public void updateUpCables(Node node, int level) {
 		DownCableSet dCableSet = this.getDownCableSet();
 		Enumeration<DownCable> dCables = dCableSet.getDownCables().elements();
 		while(dCables.hasMoreElements()){
@@ -63,6 +63,7 @@ public void updateUpCables(Node node) {
 				if (!n.getUpCableSet().contains(r))
 					n.getUpCableSet().addUpCable(new UpCable(r));
 				n.getUpCableSet().getUpCable(r.getName()).addNode(node);
+				node.updateLevel(n.getLevel()+1);
 			}
 		}
 	}

From 240e4f45d204b4fed834d1b53654a4c2cb63b17c Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Sun, 12 Jul 2020 02:52:08 +0200
Subject: [PATCH 02/14] network class fix, needs check

---
 src/sneps/network/Network.java | 21 ---------------------
 1 file changed, 21 deletions(-)

diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index 74ec1304..f3b94dd9 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -1005,27 +1005,6 @@ private static boolean followingCaseFrame(Object[][] array, CaseFrame caseFrame)
 		return true;
 	}
 
-	private static boolean followingCaseFrame(Object[][] array, CaseFrame caseFrame) {
-		LinkedList<Relation> list = new LinkedList<Relation>();
-		list.addAll(caseFrame.getRelations());
-		for (int i = 0; i < array.length; i++) {
-			Relation r = (Relation) array[i][0];
-			if (list.contains(r)) {
-				if (((NodeSet) array[i][1]).size() >= r.getLimit()) {
-					list.remove(r);
-				} else {
-					return false;
-				}
-			} else {
-				return false;
-			}
-		}
-		if (!list.isEmpty()) {
-			return false;
-		}
-		return true;
-	}
-
 	/**
 	 * This method examines the down cable set of a certain molecular node to check
 	 * whether it dominate free variables or not. Pattern nodes dominate free

From 00639a4e73aaa6ed9c5ff5993e665ffec75772a0 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Wed, 22 Jul 2020 21:16:49 +0200
Subject: [PATCH 03/14] Network and Node Classes fix regarding nodesLBL

---
 src/sneps/network/Network.java | 10 ++++++++--
 src/sneps/network/Node.java    |  2 +-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index f3b94dd9..72aaf5f9 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -444,6 +444,8 @@ public static void removeNode(Node node) throws NodeCannotBeRemovedException, No
 
 		// if the node is isolated:
 
+		// remove node from nodesLBL
+		nodesLBL.get(node.getLevel()).remove(node);
 		// removing the node from the hash table
 		nodes.remove(node.getIdentifier());
 		// nullify entry of the removed node in the array list
@@ -2097,22 +2099,26 @@ public static void clearNetwork() {
 		userDefinedVarSuffix.clear();
 	}
 
-	/** This method adds a node to the nodesLBL whenever one has been created
+	/** This method adds a node to the nodesLBL whenever one has been created, and adds a new level to nodesLBL if level doesn't exist.
 	 * @param node
 	 * @param level appropriate level of the node
 	 */
 	public static void addNodeLBL(Node node, int level) {
+		if(!(level<nodesLBL.size()))
+			nodesLBL.add(new ArrayList<Node>());
 		nodesLBL.get(level).add(node);
 	}
 	
 	/**
-	 * This method updates a node's position in nodesLBL whenever it changed its level
+	 * This method updates a node's position in nodesLBL whenever it changed its level, and makes appropriate changes in the nodesLBL
 	 * @param node that changed its level
 	 * @param oldLevel its old level in order to get it from its old position and remove it from the The nodesLBL 
 	 * @param newLevel to put it in its appropriate level
 	 */
 	public static void updateNodeLBL(Node node, int oldLevel, int newLevel) {
 		nodesLBL.get(oldLevel).remove(node);
+		if(!(newLevel<nodesLBL.size()))
+			nodesLBL.add(new ArrayList<Node>());
 		nodesLBL.get(newLevel).add(node);
 	}
 	
diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index eb10385e..1834252b 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -342,7 +342,7 @@ public ArrayList<Node> getAdjacentParents() {
 	}
 	
 	/**
-	 * This method gets the parent nodes that are in the BELOW adjacent level
+	 * This method gets the child nodes that are in the BELOW adjacent level
 	 *
 	 */
 	public ArrayList<Node> getAdjacentChildren() {

From 776914007ab2b599e4892b8de3a9383427488248 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 28 Jul 2020 02:52:42 +0200
Subject: [PATCH 04/14] Level fixes

---
 src/sneps/network/Network.java                |  2 +-
 src/sneps/network/Node.java                   | 12 ++++++++++--
 src/sneps/network/VariableNode.java           |  9 +++++++++
 src/sneps/network/classes/term/Molecular.java |  8 ++++++++
 4 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index 72aaf5f9..bed14303 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -441,7 +441,7 @@ public static void removeNode(Node node) throws NodeCannotBeRemovedException, No
 			throw new NodeCannotBeRemovedException(
 					"Cannot remove the node named '" + node.getIdentifier() + "' because it is not isolated");
 		}
-
+ 
 		// if the node is isolated:
 
 		// remove node from nodesLBL
diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 1834252b..1a815cb1 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -48,7 +48,6 @@ public Node(Semantic sem) {
 		semanticType = sem;
 		id = count++;
 		level=0;
-		updateParentsLevel();
 		Network.addNodeLBL(this,level);
 	}
 
@@ -301,7 +300,16 @@ public int getLevel() {
 	 * @returns boolean to check if level changed.
 	 */
 	public boolean updateLevel(int value) {
-		if(value>level) {
+		if(!(this instanceof VariableNode)) {
+			if(value>level) {
+				Network.updateNodeLBL(this,value,level);
+				level = value;
+				if (level>numberOfLevels)
+					numberOfLevels++;
+				return true;
+			}
+		}
+		else {
 			Network.updateNodeLBL(this,value,level);
 			level = value;
 			if (level>numberOfLevels)
diff --git a/src/sneps/network/VariableNode.java b/src/sneps/network/VariableNode.java
index fb8475e5..263aeb8d 100644
--- a/src/sneps/network/VariableNode.java
+++ b/src/sneps/network/VariableNode.java
@@ -54,4 +54,13 @@ public void setSnepslogFlag(boolean snepslogFlag) {
 	public VariableSet getFreeVariables() {
 		return freeVariables;
 	}
+
+	public void updateLevel() {
+		int min=1;
+		for(int i=0; i<getParentNodes().size();i++) {
+			if(min>getParentNodes().getNode(i).getLevel())
+				min=getParentNodes().getNode(i).getLevel();
+		}
+		updateLevel(min-1);
+	}
 }
diff --git a/src/sneps/network/classes/term/Molecular.java b/src/sneps/network/classes/term/Molecular.java
index c2b06f7d..c79b625a 100644
--- a/src/sneps/network/classes/term/Molecular.java
+++ b/src/sneps/network/classes/term/Molecular.java
@@ -1,9 +1,11 @@
 package sneps.network.classes.term;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.Enumeration;
 
 import sneps.network.Node;
+import sneps.network.VariableNode;
 import sneps.network.cables.DownCable;
 import sneps.network.cables.DownCableSet;
 import sneps.network.cables.UpCable;
@@ -58,12 +60,18 @@ public void updateUpCables(Node node, int level) {
 			DownCable dCable = dCables.nextElement();
 			Relation r = dCable.getRelation();
 			NodeSet ns = dCable.getNodeSet();
+			ArrayList<Node> variableNodes= new ArrayList<Node>();
 			for (int j = 0; j < ns.size(); j++){
 				Node n = ns.getNode(j);
 				if (!n.getUpCableSet().contains(r))
 					n.getUpCableSet().addUpCable(new UpCable(r));
 				n.getUpCableSet().getUpCable(r.getName()).addNode(node);
 				node.updateLevel(n.getLevel()+1);
+				if(n.getTerm() instanceof Variable)
+					variableNodes.add(n);
+			}
+			for(int i=0;i<variableNodes.size();i++) {
+				((VariableNode)variableNodes.get(i)).updateLevel();
 			}
 		}
 	}

From 582a0f866fdd82acff1fad9dcf1950f634a41b56 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 28 Jul 2020 03:40:43 +0200
Subject: [PATCH 05/14] graph implementation

---
 src/sneps/graph/Edge.java         |  98 ++++++++++++++++++++++++
 src/sneps/graph/Graph.java        |  82 ++++++++++++++++++++
 src/sneps/graph/LongSpanEdge.java |  90 ++++++++++++++++++++++
 src/sneps/graph/Vertex.java       | 121 ++++++++++++++++++++++++++++++
 src/sneps/network/Dummy.java      |  59 +++++++++++++++
 src/sneps/network/Network.java    |  11 ++-
 src/sneps/network/Node.java       |  20 +++--
 7 files changed, 471 insertions(+), 10 deletions(-)
 create mode 100644 src/sneps/graph/Edge.java
 create mode 100644 src/sneps/graph/Graph.java
 create mode 100644 src/sneps/graph/LongSpanEdge.java
 create mode 100644 src/sneps/graph/Vertex.java
 create mode 100644 src/sneps/network/Dummy.java

diff --git a/src/sneps/graph/Edge.java b/src/sneps/graph/Edge.java
new file mode 100644
index 00000000..cc1df072
--- /dev/null
+++ b/src/sneps/graph/Edge.java
@@ -0,0 +1,98 @@
+package sneps.gragh;
+
+import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Hashtable;
+
+import sneps.network.Dummy;
+import sneps.network.Node;
+import sneps.network.cables.UpCable;
+import sneps.network.cables.UpCableSet;
+import sneps.network.classes.setClasses.NodeSet;
+
+public class Edge {
+	
+	private Node parentNode;
+	private Node childNode;
+	private String label;
+	private Line2D.Double line;
+	private Vertex parent;
+	private Vertex child;
+	
+	public Edge(Vertex pV, Vertex cV) {
+		parent=pV;
+		child=cV;
+		parentNode = parent.getNode();
+		childNode = child.getNode();
+		
+		if(!(childNode instanceof Dummy || parentNode instanceof Dummy)) {
+		//find the relation name to label the Edge.
+		Hashtable<String, UpCable> childUpCableSet=childNode.getUpCableSet().getUpCables();
+		for(String relation: childUpCableSet.keySet())
+			if(childUpCableSet.get(relation).getNodeSet().contains(parentNode))
+				label=relation;
+		}
+	}
+	
+	public void constructLine() {
+		line=new Line2D.Double(parent.getPosition(),child.getPosition());
+	}
+
+	/**
+	 * @return the line
+	 */
+	public Line2D.Double getLine() {
+		return line;
+	}
+	
+	
+	/**
+	 * @return the parent Vertex
+	 */
+	public Vertex getParent() {
+		return parent;
+	}
+
+	/**
+	 * @return the child Vertex
+	 */
+	public Vertex getChild() {
+		return child;
+	}
+	
+	/**
+	 * @return the label. The relation Name.
+	 */
+	public String getLabel() {
+		return label;
+	}
+	
+	public boolean intersects(Edge e) {
+		return line.intersectsLine((Line2D.Double)e.getLine());
+	}
+	
+	public static int countNumberOfCrossing (ArrayList<Edge> edges) {
+		int count=0;
+		for(int i=0; i<edges.size();i++)
+			for(int j=i+1;j<edges.size();j++)
+				if(edges.get(i).intersects(edges.get(j)))
+					count++;
+		return count; 
+	}
+
+	/**
+	 * @return the parent Vertex
+	 */
+	public double getParentX() {
+		return parent.getPosition().getX();
+	}
+
+	/**
+	 * @return the child Vertex
+	 */
+	public double getChildX() {
+		return child.getPosition().getX();
+	}
+	
+}
diff --git a/src/sneps/graph/Graph.java b/src/sneps/graph/Graph.java
new file mode 100644
index 00000000..5c48a0e9
--- /dev/null
+++ b/src/sneps/graph/Graph.java
@@ -0,0 +1,82 @@
+package sneps.graph;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Collections;
+
+import sneps.network.Dummy;
+
+//import com.mxgraph.util.*;
+
+import sneps.network.Network;
+import sneps.network.Node;
+public class Graph {
+	
+	private static ArrayList<ArrayList<Node>> nodesLBL;
+	private static ArrayList<ArrayList<Edge>> edges= new ArrayList<ArrayList<Edge>>();
+	private static ArrayList<ArrayList<Vertex>> verticesLBL;
+	private static ArrayList<ArrayList<Vertex>> dummyVerticesLBL; 
+	private static ArrayList<LongSpanEdge> longSpanEdges= new ArrayList<LongSpanEdge>();
+	private static int height;
+	
+	
+	public static void constructGraph() {
+		nodesLBL= Network.getNodesLBL();
+		height=nodesLBL.size();
+		Node node;
+		verticesLBL = new ArrayList<ArrayList<Vertex>>();
+		dummyVerticesLBL= new ArrayList<ArrayList<Vertex>>();
+		for(int i=0;i<nodesLBL.size();i++) {
+			verticesLBL.add(new ArrayList<Vertex>());
+			dummyVerticesLBL.add(new ArrayList<Vertex>());
+			for(int j=0; j<nodesLBL.get(i).size();j++) {
+				node=nodesLBL.get(i).get(j);
+				verticesLBL.get(i).add(new Vertex(node,new Point2D.Double(j+0.0,i+0.0),node.getAdjacentParents()));
+				if(node instanceof Dummy)
+					for (int c=0; c<longSpanEdges.size();c++) {
+						if(longSpanEdges.get(i).getDummySet().contains(node))
+							longSpanEdges.get(i).addDummyVertices(verticesLBL.get(i).get(j));
+					}
+			}
+		}
+		for(int i=0;i<(verticesLBL.size()-1);i++) {
+			edges.add(new ArrayList<Edge>());
+			for(int j=0;j<verticesLBL.get(i).size();j++) {
+				Vertex current= verticesLBL.get(i).get(j); 
+				 for(int k=0; k<verticesLBL.get(i).get(j).getParentIndices().size(); k++) {
+					 int v= verticesLBL.get(i).get(j).getParentIndices().get(k);
+					 Vertex parent= verticesLBL.get(i+1).get(v);
+					 edges.get(i).add(new Edge(parent,current));
+					 parent.addOutgoingEdge(edges.get(i).get(edges.size()-1));
+					 current.addIncomingEdge(edges.get(i).get(edges.size()-1));
+				 }
+			}
+		}
+		minimizeEdgeCrossings();
+		
+		//TODO handle remove dummy vertices with appropriate protocols
+		//TODO specify final x-coordinates and level separation
+		//TODO 
+		//TODO Construct edge lines
+		
+	}
+	
+	private static void minimizeEdgeCrossings() {
+		boolean hasChanged = true;
+		for (int c=0;hasChanged; c++) {
+			hasChanged=false;
+			for(int i=verticesLBL.size()-1;i>-1;i--) {
+				for(int j=0; j<verticesLBL.get(i).size();j++)
+					verticesLBL.get(i).get(j).computeBarycenterValue();
+				Collections.sort(verticesLBL.get(i));
+				for(int j=0; j<verticesLBL.get(i).size();j++)
+					hasChanged|=verticesLBL.get(i).get(j).setX(j+0.0);
+			}
+		}
+	}
+	
+	public static void addLongSpanEdge(LongSpanEdge longSpanEdge) {
+		longSpanEdges.add(longSpanEdge);
+	}
+	
+}
diff --git a/src/sneps/graph/LongSpanEdge.java b/src/sneps/graph/LongSpanEdge.java
new file mode 100644
index 00000000..fa203091
--- /dev/null
+++ b/src/sneps/graph/LongSpanEdge.java
@@ -0,0 +1,90 @@
+package sneps.graph;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Hashtable;
+
+import sneps.network.Dummy;
+import sneps.network.Node;
+import sneps.network.cables.UpCable;
+
+public class LongSpanEdge  {
+	
+	private Node parent;
+	private Node child;
+	private String label;
+	private ArrayList<Node> dummySet;
+	private ArrayList<Edge> edges;
+	private ArrayList<Vertex> dummyVertices;
+	
+	public LongSpanEdge(Node parent, Node child) {
+		this.parent = parent;
+		this.child = child;
+		
+		//find the relation name to label the Edge.
+		Hashtable<String, UpCable> childUpCableSet=child.getUpCableSet().getUpCables();
+		for(String relation: childUpCableSet.keySet())
+			if(childUpCableSet.get(relation).getNodeSet().contains(parent))
+				label=relation;
+		dummySet= new ArrayList<Node>();
+		dummySet.add(child);
+		int levelDifference= parent.getLevel()-child.getLevel();
+		Node previous;
+		for(int i=1;1<levelDifference;i++) {
+			previous = (Node)dummySet.get(i-1);
+			dummySet.add(new Dummy(null, previous, i));
+		}
+		dummySet.remove(0);
+		for(int i=0; i<(dummySet.size()-1);i++) {
+			((Dummy) dummySet.get(i)).setParent(dummySet.get(i+1)); 
+		}
+		((Dummy) dummySet.get(levelDifference-2)).setParent(parent);
+		dummyVertices= new ArrayList<Vertex>();
+		edges=new ArrayList<Edge>();
+		Graph.addLongSpanEdge(this);
+	}
+
+	/**
+	 * @return the dummies
+	 */
+	public Node getFirstDummy() {
+		return dummySet.get(0);
+	}
+
+	/**
+	 * @return the dummySet
+	 */
+	public ArrayList<Node> getDummySet() {
+		return dummySet;
+	}
+
+	/**
+	 * @param dummyVertices the dummyVertices to set
+	 */
+	public void addDummyVertices(Vertex dummyVertex) {
+		dummyVertices.add(dummyVertex);
+	}
+
+	/**
+	 * @return the dummyVertices
+	 */
+	public ArrayList<Vertex> getDummyVertices() {
+		return dummyVertices;
+	}
+
+	/**
+	 * @return the edges
+	 */
+	public ArrayList<Edge> getEdges() {
+		return edges;
+	}
+
+	/**
+	 * @param edges the edges to set
+	 */
+	public void setEdges(ArrayList<Edge> edges) {
+		this.edges = edges;
+	}
+	
+	
+}
diff --git a/src/sneps/graph/Vertex.java b/src/sneps/graph/Vertex.java
new file mode 100644
index 00000000..1e9d1bdb
--- /dev/null
+++ b/src/sneps/graph/Vertex.java
@@ -0,0 +1,121 @@
+package sneps.graph;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+
+import sneps.network.Node;
+
+public class Vertex implements Comparable<Vertex> {
+
+	private Point2D.Double position;
+	private Node node;
+	private int outDegree = 0;
+	private int inDegree = 0;
+	private ArrayList<Edge> outgoingEdges; 
+	private ArrayList<Edge> incomingEdges;
+	private Double bary;
+	private String label;
+	private ArrayList<Integer> parentIndices;
+
+	public Vertex(Node node, Point2D.Double position, ArrayList<Integer> parentIndices) {
+		this.node=node;
+		this.position=position;
+		this.parentIndices=parentIndices;
+		label = node.getIdentifier();
+		outgoingEdges= new ArrayList<Edge>();
+		incomingEdges= new ArrayList<Edge>();
+	}
+
+	/**
+	 * @return the label
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	
+	public void computeBarycenterValue() {
+		double barycenterIn=0;
+		double barycenterOut=0;
+		for(int i=0; i<inDegree; i++)
+			barycenterIn+=(incomingEdges.get(i).getParentX()/(inDegree+0.0));
+		for(int i=0; i<outDegree; i++)
+			barycenterOut+=(outgoingEdges.get(i).getChildX()/(outDegree+0-0));
+		bary= barycenterIn+barycenterOut;
+		if(inDegree==0 || outDegree==0)
+			return;
+		bary/=2;
+	}
+	
+	public boolean setX(double x) {
+		if(position.x!=x) {
+			position.x=x;
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * @return the barycenter value
+	 */
+	public Double getBary() {
+		return bary;
+	}
+	
+	public void addOutgoingEdge(Edge out) {
+		outgoingEdges.add(out);
+		outDegree++;
+	}
+	
+	public void addIncomingEdge(Edge in) {
+		incomingEdges.add(in);
+		inDegree++;
+	}
+
+	/**
+	 * @return the outDegree
+	 */
+	public int getOutDegree() {
+		return outDegree;
+	}
+
+	/**
+	 * @return the inDegree
+	 */
+	public int getInDegree() {
+		return inDegree;
+	}
+
+	/**
+	 * @return the position
+	 */
+	public Point2D.Double getPosition() {
+		return position;
+	}
+
+	/**
+	 * @return the parentIndices
+	 */
+	public ArrayList<Integer> getParentIndices() {
+		return parentIndices;
+	}
+
+	/**
+	 * @return the node
+	 */
+	public Node getNode() {
+		return node;
+	}
+
+	@Override
+	public int compareTo(Vertex v) {
+		if( bary == v.getBary())
+			return 0;
+		if( bary < v.getBary())
+			return -1;
+		return 1;
+	}
+	
+	
+		
+}
diff --git a/src/sneps/network/Dummy.java b/src/sneps/network/Dummy.java
new file mode 100644
index 00000000..684d2677
--- /dev/null
+++ b/src/sneps/network/Dummy.java
@@ -0,0 +1,59 @@
+package sneps.network;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+import sneps.network.classes.setClasses.NodeSet;
+
+public class Dummy extends Node implements Serializable {
+	
+	private Node parent;
+	private Node child;
+	private static int count=0;
+
+	public Dummy(Node parent, Node child, int level) {
+		super();
+		this.parent=parent;
+		this.child=child;
+		this.updateLevel(level);
+		Network.addNodeLBL(this,level);
+		count++;
+	}
+	
+	public void createDummies(Node parent, Node child) {
+		NodeSet dummies= new NodeSet();
+		dummies.addNode(new Dummy(null,child,child.getLevel()+1));
+		for(int i= 2+child.getLevel();i<parent.getLevel();i++) {
+			dummies.addNode(new Dummy(null,dummies.getNode(i-1),i));
+		}
+			//TODO Create LongSpanEdge Class
+	}
+	
+	/**
+	 * This method gets the parent nodes that are in the ABOVE adjacent level
+	 *
+	 */
+	@Override
+	public ArrayList<Integer> getAdjacentParents() {
+		ArrayList<Integer> result = new ArrayList<Integer>();
+		result.add(Network.getNodesLBL().get(getLevel()+1).indexOf(parent));
+		return result;
+	}
+	
+	/**
+	 * @param parent the parent to set
+	 */
+	public void setParent(Node parent) {
+		this.parent = parent;
+	}
+
+	public Node getparent() {
+		return parent;
+	}
+
+	public Node getchild() {
+		return child;
+	}
+	
+	
+}
diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index bed14303..7fb19603 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -17,6 +17,7 @@
 import java.util.List;
 
 import sneps.exceptions.*;
+import sneps.graph.Graph;
 import sneps.network.cables.Cable;
 import sneps.network.cables.DownCable;
 import sneps.network.cables.DownCableSet;
@@ -2099,7 +2100,7 @@ public static void clearNetwork() {
 		userDefinedVarSuffix.clear();
 	}
 
-	/** This method adds a node to the nodesLBL whenever one has been created, and adds a new level to nodesLBL if level doesn't exist.
+		/** This method adds a node to the nodesLBL whenever one has been created
 	 * @param node
 	 * @param level appropriate level of the node
 	 */
@@ -2110,7 +2111,7 @@ public static void addNodeLBL(Node node, int level) {
 	}
 	
 	/**
-	 * This method updates a node's position in nodesLBL whenever it changed its level, and makes appropriate changes in the nodesLBL
+	 * This method updates a node's position in nodesLBL whenever it changed its level
 	 * @param node that changed its level
 	 * @param oldLevel its old level in order to get it from its old position and remove it from the The nodesLBL 
 	 * @param newLevel to put it in its appropriate level
@@ -2128,5 +2129,9 @@ public static void updateNodeLBL(Node node, int oldLevel, int newLevel) {
 	public static ArrayList<ArrayList<Node>> getNodesLBL(){
 		return nodesLBL;
 	}
-
+	
+	public static void generateGraph() {
+		Graph.constructGraph();
+	}
+	
 }
diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 1a815cb1..2cfc4448 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -12,6 +12,7 @@
 import sneps.snebr.Context;
 import sneps.snip.channels.Channel;
 import sneps.snip.matching.Substitutions;
+import sneps.graph.LongSpanEdge;
 import sneps.network.Network;
 
 public class Node implements Serializable {
@@ -20,7 +21,7 @@ public class Node implements Serializable {
 	protected Semantic semanticType;
 	private static int count = 0;
 	private int id;
-
+	
 	/**
 	 * Attribute level to determine the level of the node
 	 * The higher the node in the y-axis the higher the attribute level
@@ -296,7 +297,7 @@ public int getLevel() {
 	
 	/**
 	 * This method updates the node level if needed.
-	 * @param value of the proposed level updated
+	 *  @param value of the proposed level updated
 	 * @returns boolean to check if level changed.
 	 */
 	public boolean updateLevel(int value) {
@@ -336,15 +337,20 @@ public static int getNumberOfLevels() {
 	}
 	
 	/**
-	 * This method gets the parent nodes that are in the ABOVE adjacent level
-	 *
+	 * This method gets the indices of the parent nodes that are in the ABOVE adjacent level.
+	 * It also creates dummies between its non adjacent parents 
+	 * And adds the first dummy to the returned list as it also is an adjacent parent node
 	 */
-	public ArrayList<Node> getAdjacentParents() {
+	public ArrayList<Integer> getAdjacentParents() {
 		NodeSet parents = getParentNodes();
-		ArrayList<Node> result = new ArrayList<Node>();
+		ArrayList<Integer> result = new ArrayList<Integer>();
 		for (int i=0;i<parents.size();i++) {
 			if(parents.getNode(i).getLevel()==(level+1))
-				result.add(parents.getNode(i));
+				result.add(Network.getNodesLBL().get(level+1).indexOf(parents.getNode(i)));
+			else {
+				LongSpanEdge lse =new LongSpanEdge(parents.getNode(i),this);
+				result.add(Network.getNodesLBL().get(level+1).indexOf(lse.getFirstDummy()));
+			}
 		}
 		return result;
 	}

From e42efdad11910a31a1523765dea645ef9e4af50f Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 28 Jul 2020 04:07:28 +0200
Subject: [PATCH 06/14] variable node level fix

---
 src/sneps/network/Node.java                   | 12 +++++++-----
 src/sneps/network/VariableNode.java           |  9 ---------
 src/sneps/network/classes/term/Molecular.java |  2 +-
 3 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 2cfc4448..7860fa31 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -311,11 +311,13 @@ public boolean updateLevel(int value) {
 			}
 		}
 		else {
-			Network.updateNodeLBL(this,value,level);
-			level = value;
-			if (level>numberOfLevels)
-				numberOfLevels++;
-			return true;
+			if(value<level){
+				Network.updateNodeLBL(this,value,level);
+				level = value;
+				if (level>numberOfLevels)
+					numberOfLevels++;
+				return true;
+			}
 		}
 		return false;
 	}
diff --git a/src/sneps/network/VariableNode.java b/src/sneps/network/VariableNode.java
index 263aeb8d..fb8475e5 100644
--- a/src/sneps/network/VariableNode.java
+++ b/src/sneps/network/VariableNode.java
@@ -54,13 +54,4 @@ public void setSnepslogFlag(boolean snepslogFlag) {
 	public VariableSet getFreeVariables() {
 		return freeVariables;
 	}
-
-	public void updateLevel() {
-		int min=1;
-		for(int i=0; i<getParentNodes().size();i++) {
-			if(min>getParentNodes().getNode(i).getLevel())
-				min=getParentNodes().getNode(i).getLevel();
-		}
-		updateLevel(min-1);
-	}
 }
diff --git a/src/sneps/network/classes/term/Molecular.java b/src/sneps/network/classes/term/Molecular.java
index c79b625a..95fac121 100644
--- a/src/sneps/network/classes/term/Molecular.java
+++ b/src/sneps/network/classes/term/Molecular.java
@@ -71,7 +71,7 @@ public void updateUpCables(Node node, int level) {
 					variableNodes.add(n);
 			}
 			for(int i=0;i<variableNodes.size();i++) {
-				((VariableNode)variableNodes.get(i)).updateLevel();
+				((VariableNode)variableNodes.get(i)).updateLevel(node.getLevel()-1);
 			}
 		}
 	}

From c2164a5ec83f910932400e9693f6a489c0d1a5a6 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 28 Jul 2020 05:07:51 +0200
Subject: [PATCH 07/14] level fix redundancy

---
 src/sneps/network/Node.java                   | 2 +-
 src/sneps/network/classes/term/Molecular.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 2cfc4448..967f1a98 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -284,7 +284,7 @@ public void setTemp(boolean temp) {
 	 * class and pass the current node as a parameter.
 	 */
 	public void updateUpCables() {
-		((Molecular) this.getTerm()).updateUpCables(this,level);
+		((Molecular) this.getTerm()).updateUpCables(this);
 	}
 	
 	
diff --git a/src/sneps/network/classes/term/Molecular.java b/src/sneps/network/classes/term/Molecular.java
index c79b625a..9b5dc048 100644
--- a/src/sneps/network/classes/term/Molecular.java
+++ b/src/sneps/network/classes/term/Molecular.java
@@ -53,7 +53,7 @@ public String toString(){
 	 * 			the node object having the current molecular object
 	 * 			as its syntactic object.
 	 */
-	public void updateUpCables(Node node, int level) {
+	public void updateUpCables(Node node) {
 		DownCableSet dCableSet = this.getDownCableSet();
 		Enumeration<DownCable> dCables = dCableSet.getDownCables().elements();
 		while(dCables.hasMoreElements()){

From 5bcea688ddcff02786165fade60b353801cbe91a Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 28 Jul 2020 05:14:10 +0200
Subject: [PATCH 08/14] variable node level fix

---
 src/sneps/network/Node.java                   | 12 +++++-------
 src/sneps/network/VariableNode.java           |  9 +++++++++
 src/sneps/network/classes/term/Molecular.java |  2 +-
 3 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index af33c287..967f1a98 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -311,13 +311,11 @@ public boolean updateLevel(int value) {
 			}
 		}
 		else {
-			if(value<level){
-				Network.updateNodeLBL(this,value,level);
-				level = value;
-				if (level>numberOfLevels)
-					numberOfLevels++;
-				return true;
-			}
+			Network.updateNodeLBL(this,value,level);
+			level = value;
+			if (level>numberOfLevels)
+				numberOfLevels++;
+			return true;
 		}
 		return false;
 	}
diff --git a/src/sneps/network/VariableNode.java b/src/sneps/network/VariableNode.java
index fb8475e5..fb327eda 100644
--- a/src/sneps/network/VariableNode.java
+++ b/src/sneps/network/VariableNode.java
@@ -54,4 +54,13 @@ public void setSnepslogFlag(boolean snepslogFlag) {
 	public VariableSet getFreeVariables() {
 		return freeVariables;
 	}
+
+	public void updateLevel() {
+		int min=1;
+		for(int i=0; i<getParentNodes().size();i++) {
+			if(min>getParentNodes().getNode(i).getLevel())
+				min=getParentNodes().getNode(i).getLevel();
+		}
+		updateLevel(min);
+	}
 }
diff --git a/src/sneps/network/classes/term/Molecular.java b/src/sneps/network/classes/term/Molecular.java
index 98787d7d..9b5dc048 100644
--- a/src/sneps/network/classes/term/Molecular.java
+++ b/src/sneps/network/classes/term/Molecular.java
@@ -71,7 +71,7 @@ public void updateUpCables(Node node) {
 					variableNodes.add(n);
 			}
 			for(int i=0;i<variableNodes.size();i++) {
-				((VariableNode)variableNodes.get(i)).updateLevel(node.getLevel()-1);
+				((VariableNode)variableNodes.get(i)).updateLevel();
 			}
 		}
 	}

From 790db782d4481edbf5d01348b0439d4974673d78 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Sun, 2 Aug 2020 17:02:45 +0200
Subject: [PATCH 09/14] graph fix

---
 src/sneps/graph/Edge.java      |  2 +-
 src/sneps/graph/Graph.java     | 21 +++++++++++++++------
 src/sneps/network/Network.java |  4 +++-
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/sneps/graph/Edge.java b/src/sneps/graph/Edge.java
index cc1df072..34c9d835 100644
--- a/src/sneps/graph/Edge.java
+++ b/src/sneps/graph/Edge.java
@@ -1,4 +1,4 @@
-package sneps.gragh;
+package sneps.graph;
 
 import java.awt.geom.Line2D;
 import java.awt.geom.Point2D;
diff --git a/src/sneps/graph/Graph.java b/src/sneps/graph/Graph.java
index 5c48a0e9..a3b2b5de 100644
--- a/src/sneps/graph/Graph.java
+++ b/src/sneps/graph/Graph.java
@@ -17,12 +17,10 @@ public class Graph {
 	private static ArrayList<ArrayList<Vertex>> verticesLBL;
 	private static ArrayList<ArrayList<Vertex>> dummyVerticesLBL; 
 	private static ArrayList<LongSpanEdge> longSpanEdges= new ArrayList<LongSpanEdge>();
-	private static int height;
 	
 	
 	public static void constructGraph() {
 		nodesLBL= Network.getNodesLBL();
-		height=nodesLBL.size();
 		Node node;
 		verticesLBL = new ArrayList<ArrayList<Vertex>>();
 		dummyVerticesLBL= new ArrayList<ArrayList<Vertex>>();
@@ -55,9 +53,9 @@ public static void constructGraph() {
 		minimizeEdgeCrossings();
 		
 		//TODO handle remove dummy vertices with appropriate protocols
-		//TODO specify final x-coordinates and level separation
-		//TODO 
-		//TODO Construct edge lines
+		//TODO specify final x-coordinates
+		constructEdges();
+		
 		
 	}
 	
@@ -79,4 +77,15 @@ public static void addLongSpanEdge(LongSpanEdge longSpanEdge) {
 		longSpanEdges.add(longSpanEdge);
 	}
 	
-}
+	public static void constructEdges() {
+		for(int i=0; i<edges.size();i++) {
+			for(int j=0; j<edges.get(i).size();j++) {
+				edges.get(i).get(j).constructLine();
+			}
+		}
+	}
+	
+	public static void clear() {
+		longSpanEdges=new ArrayList<LongSpanEdge>();
+	}
+}
\ No newline at end of file
diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index 7fb19603..f13208da 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -142,7 +142,7 @@ public class Network implements Serializable {
 	/**
 	 * A 2D ArrayList that has all the Nodes divided Level By Lebel (LBL) 
 	 */
-	private static  ArrayList<ArrayList<Node>> nodesLBL = new ArrayList<>();
+	private static  ArrayList<ArrayList<Node>> nodesLBL = new ArrayList<ArrayList<Node>>();
 
 	/**
 	 *
@@ -2098,6 +2098,8 @@ public static void clearNetwork() {
 		userDefinedMolSuffix.clear();
 		userDefinedPatSuffix.clear();
 		userDefinedVarSuffix.clear();
+		Graph.clear();
+		nodesLBL = new ArrayList<ArrayList<Node>>();
 	}
 
 		/** This method adds a node to the nodesLBL whenever one has been created

From c82f5eee138e799e22992b4f82867dc01e04ecc4 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Mon, 3 Aug 2020 03:12:52 +0200
Subject: [PATCH 10/14] graph x-coordinate assignment

---
 src/sneps/graph/Graph.java  | 166 ++++++++++++++++++++++++++++++++++--
 src/sneps/graph/Vertex.java | 100 +++++++++++++++++++++-
 2 files changed, 260 insertions(+), 6 deletions(-)

diff --git a/src/sneps/graph/Graph.java b/src/sneps/graph/Graph.java
index a3b2b5de..1c6087ab 100644
--- a/src/sneps/graph/Graph.java
+++ b/src/sneps/graph/Graph.java
@@ -51,14 +51,13 @@ public static void constructGraph() {
 			}
 		}
 		minimizeEdgeCrossings();
-		
-		//TODO handle remove dummy vertices with appropriate protocols
-		//TODO specify final x-coordinates
+		assignXcoordinates();
 		constructEdges();
 		
 		
+		
 	}
-	
+
 	private static void minimizeEdgeCrossings() {
 		boolean hasChanged = true;
 		for (int c=0;hasChanged; c++) {
@@ -85,7 +84,164 @@ public static void constructEdges() {
 		}
 	}
 	
+	public static void assignXcoordinates() {
+		int sumUpper;
+		int sumLower;
+		ArrayList<ArrayList<Integer>> prioritiesUpperLBL= new ArrayList<ArrayList<Integer>>();
+		ArrayList<ArrayList<Integer>> prioritiesLowerLBL= new ArrayList<ArrayList<Integer>>();
+		for(int i=0; i< verticesLBL.size(); i++) {
+			sumUpper=0;
+			sumLower=0;
+			prioritiesUpperLBL.add(new ArrayList<Integer>());
+			prioritiesLowerLBL.add(new ArrayList<Integer>());
+			for(int j=0; j<verticesLBL.get(i).size(); j++) {
+				sumUpper+=verticesLBL.get(i).get(j).computePriorityUpper();
+				sumLower+=verticesLBL.get(i).get(j).computePriorityLower();
+				prioritiesUpperLBL.get(i).add(verticesLBL.get(i).get(j).getPriorityUpper());
+				prioritiesLowerLBL.get(i).add(verticesLBL.get(i).get(j).getPriorityLower());
+			}
+			for(int j=0; j<verticesLBL.get(i).size(); j++)
+				if(verticesLBL.get(i).get(j).getNode() instanceof Dummy) {
+					verticesLBL.get(i).get(j).setPriorityUpper(sumUpper);
+					verticesLBL.get(i).get(j).setPriorityLower(sumLower);
+					prioritiesUpperLBL.get(i).set(j,verticesLBL.get(i).get(j).getPriorityUpper());
+					prioritiesLowerLBL.get(i).set(j,verticesLBL.get(i).get(j).getPriorityLower());
+				}
+		}
+		int max;
+		ArrayList<Integer> copyPrioritiesUpper;
+		ArrayList<Integer> occurrences;
+		int steps;
+		int step;
+		int index;
+		ArrayList<Vertex> moveableVertices;
+		boolean higherPriority;
+		for(int i=verticesLBL.size()-1; i>-1; i--) {
+			copyPrioritiesUpper=((ArrayList<Integer>) prioritiesUpperLBL.get(i).clone());
+			while(!copyPrioritiesUpper.isEmpty()) {
+				occurrences=new ArrayList<Integer>();
+				max=Collections.max(copyPrioritiesUpper);
+				copyPrioritiesUpper.remove(max);
+				for (int c=0;c<prioritiesUpperLBL.get(i).size();c++)
+					if(max==prioritiesUpperLBL.get(i).get(c))
+						occurrences.add(c);
+				for(int j=0; j<occurrences.size();j++) {
+					index=occurrences.get(j);
+					steps=(int) Math.round(verticesLBL.get(i).get(index).computeBarycenterUpper());
+					steps-=verticesLBL.get(i).get(index).getPosition().x;
+					if(steps<0)
+						step=-1;
+					else
+						step=1;
+					moveableVertices=new ArrayList<Vertex>();
+					for(int s=0;s<Math.abs(steps);s++) {
+						higherPriority=false;
+						for(int k=index;k<verticesLBL.get(i).size();k+=step) {
+							if(!(verticesLBL.get(i).get(k+step).getPosition().x== verticesLBL.get(i).get(k).getPosition().x+step)) 
+								break;
+							if(verticesLBL.get(i).get(k+step).getPriorityUpper()>verticesLBL.get(i).get(k).getPriorityUpper()) {
+								higherPriority=true;
+								break;
+							}
+							moveableVertices.add(verticesLBL.get(i).get(k));
+						}
+						if(higherPriority)
+							break;
+						for(int m=0;m<moveableVertices.size();m++)
+							moveableVertices.get(m).move(step);
+					}
+				}
+			}
+		}
+		ArrayList<Integer> copyPrioritiesLower;
+		for(int i=1; i<verticesLBL.size(); i++) {
+			copyPrioritiesLower=((ArrayList<Integer>) prioritiesLowerLBL.get(i).clone());
+			while(!copyPrioritiesLower.isEmpty()) {
+				occurrences=new ArrayList<Integer>();
+				max=Collections.max(copyPrioritiesLower);
+				copyPrioritiesLower.remove(max);
+				for (int c=0;c<prioritiesLowerLBL.get(i).size();c++)
+					if(max==prioritiesLowerLBL.get(i).get(c))
+						occurrences.add(c);
+				for(int j=0; j<occurrences.size();j++) {
+					index=occurrences.get(j);
+					steps=(int) Math.round(verticesLBL.get(i).get(index).computeBarycenterLower());
+					steps-=verticesLBL.get(i).get(index).getPosition().x;
+					if(steps<0)
+						step=-1;
+					else
+						step=1;
+					moveableVertices=new ArrayList<Vertex>();
+					for(int s=0;s<Math.abs(steps);s++) {
+						higherPriority=false;
+						for(int k=index;k<verticesLBL.get(i).size();k+=step) {
+							if(!(verticesLBL.get(i).get(k+step).getPosition().x== verticesLBL.get(i).get(k).getPosition().x+step)) 
+								break;
+							if(verticesLBL.get(i).get(k+step).getPriorityLower()>verticesLBL.get(i).get(k).getPriorityLower()) {
+								higherPriority=true;
+								break;
+							}
+							moveableVertices.add(verticesLBL.get(i).get(k));
+						}
+						if(higherPriority)
+							break;
+						for(int m=0;m<moveableVertices.size();m++)
+							moveableVertices.get(m).move(step);
+					}
+				}
+			}
+		}
+		
+		for(int i=verticesLBL.size()-1; i>-1; i--) {
+			copyPrioritiesUpper=((ArrayList<Integer>) prioritiesUpperLBL.get(i).clone());
+			while(!copyPrioritiesUpper.isEmpty()) {
+				occurrences=new ArrayList<Integer>();
+				max=Collections.max(copyPrioritiesUpper);
+				copyPrioritiesUpper.remove(max);
+				for (int c=0;c<prioritiesUpperLBL.get(i).size();c++)
+					if(max==prioritiesUpperLBL.get(i).get(c))
+						occurrences.add(c);
+				for(int j=0; j<occurrences.size();j++) {
+					index=occurrences.get(j);
+					steps=(int) Math.round(verticesLBL.get(i).get(index).computeBarycenterUpper());
+					steps-=verticesLBL.get(i).get(index).getPosition().x;
+					if(steps<0)
+						step=-1;
+					else
+						step=1;
+					moveableVertices=new ArrayList<Vertex>();
+					for(int s=0;s<Math.abs(steps);s++) {
+						higherPriority=false;
+						for(int k=index;k<verticesLBL.get(i).size();k+=step) {
+							if(!(verticesLBL.get(i).get(k+step).getPosition().x== verticesLBL.get(i).get(k).getPosition().x+step)) 
+								break;
+							if(verticesLBL.get(i).get(k+step).getPriorityUpper()>verticesLBL.get(i).get(k).getPriorityUpper()) {
+								higherPriority=true;
+								break;
+							}
+							moveableVertices.add(verticesLBL.get(i).get(k));
+						}
+						if(higherPriority)
+							break;
+						for(int m=0;m<moveableVertices.size();m++)
+							moveableVertices.get(m).move(step);
+					}
+				}
+			}
+		}
+		shiftVertices();
+	}
+	
+
+	private static void shiftVertices() {
+		int offset= -(int) Vertex.getMin_X();
+		if(offset!=0)
+			for(int i=0; i<verticesLBL.size();i++)
+				for(int j=0; j<verticesLBL.get(i).size();j++)
+					verticesLBL.get(i).get(j).move(offset);
+	}
+	
 	public static void clear() {
 		longSpanEdges=new ArrayList<LongSpanEdge>();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/sneps/graph/Vertex.java b/src/sneps/graph/Vertex.java
index 1e9d1bdb..8b74ca93 100644
--- a/src/sneps/graph/Vertex.java
+++ b/src/sneps/graph/Vertex.java
@@ -16,6 +16,12 @@ public class Vertex implements Comparable<Vertex> {
 	private Double bary;
 	private String label;
 	private ArrayList<Integer> parentIndices;
+	private Double baryLower;
+	private Double baryUpper;
+	private int priorityLower;
+	private int priorityUpper;
+	private static double max_X=0;
+	private static double min_X=0;
 
 	public Vertex(Node node, Point2D.Double position, ArrayList<Integer> parentIndices) {
 		this.node=node;
@@ -24,6 +30,8 @@ public Vertex(Node node, Point2D.Double position, ArrayList<Integer> parentIndic
 		label = node.getIdentifier();
 		outgoingEdges= new ArrayList<Edge>();
 		incomingEdges= new ArrayList<Edge>();
+		if(position.x>max_X)
+			max_X=position.x;
 	}
 
 	/**
@@ -40,13 +48,89 @@ public void computeBarycenterValue() {
 		for(int i=0; i<inDegree; i++)
 			barycenterIn+=(incomingEdges.get(i).getParentX()/(inDegree+0.0));
 		for(int i=0; i<outDegree; i++)
-			barycenterOut+=(outgoingEdges.get(i).getChildX()/(outDegree+0-0));
+			barycenterOut+=(outgoingEdges.get(i).getChildX()/(outDegree+0.0));
 		bary= barycenterIn+barycenterOut;
 		if(inDegree==0 || outDegree==0)
 			return;
 		bary/=2;
 	}
 	
+	public Double computeBarycenterUpper() {
+		baryUpper=0.0;
+		for(int i=0; i<inDegree; i++)
+			baryLower+=(incomingEdges.get(i).getParentX()/(inDegree+0.0));
+		return baryUpper;
+	}
+			
+			
+	public Double computeBarycenterLower(){
+		baryLower=0.0;
+		for(int i=0; i<outDegree; i++)
+			baryUpper+=(outgoingEdges.get(i).getChildX()/(outDegree+0.0));
+		return baryLower;
+	}
+	
+	public int computePriorityUpper() {    
+		priorityUpper=inDegree;
+		return priorityUpper;
+	}
+	
+	public int computePriorityLower() {    
+		priorityLower=outDegree;
+		return priorityLower;
+	}
+	
+
+	/**
+	 * @param priorityLower the priorityLower to set
+	 */
+	public void setPriorityLower(int priorityLower) {
+		this.priorityLower = priorityLower;
+	}
+
+	/**
+	 * @param priorityUpper the priorityUpper to set
+	 */
+	public void setPriorityUpper(int priorityUpper) {
+		this.priorityUpper = priorityUpper;
+	}
+
+	/**
+	 * @return the baryLower
+	 */
+	public Double getBaryLower() {
+		return baryLower;
+	}
+
+	/**
+	 * @return the baryUpper
+	 */
+	public Double getBaryUpper() {
+		return baryUpper;
+	}
+
+	/**
+	 * @return the priorityLower
+	 */
+	public int getPriorityLower() {
+		return priorityLower;
+	}
+
+	/**
+	 * @return the priorityUpper
+	 */
+	public int getPriorityUpper() {
+		return priorityUpper;
+	}
+	
+	public void move(int displacement) {
+		position.x+=displacement;
+		if(position.x>max_X)
+			max_X=position.x;
+		if(position.x<min_X)
+			min_X=position.x;
+	}
+
 	public boolean setX(double x) {
 		if(position.x!=x) {
 			position.x=x;
@@ -107,6 +191,20 @@ public Node getNode() {
 		return node;
 	}
 
+	/**
+	 * @return the max_X
+	 */
+	public static double getMax_X() {
+		return max_X;
+	}
+
+	/**
+	 * @return the min_X
+	 */
+	public static double getMin_X() {
+		return min_X;
+	}
+
 	@Override
 	public int compareTo(Vertex v) {
 		if( bary == v.getBary())

From 74c47da451359fd865af973cf86bb0bc4498c37d Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Mon, 3 Aug 2020 03:57:56 +0200
Subject: [PATCH 11/14] network class fix like omarnael

---
 src/sneps/network/Network.java | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index f13208da..1ce5cefd 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -988,7 +988,7 @@ private static boolean followingCaseFrame(Object[][] array, RelationsRestrictedC
 		return true;
 	}
 
-	@SuppressWarnings("unchecked")
+	/*@SuppressWarnings("unchecked")
 	private static boolean followingCaseFrame(Object[][] array, CaseFrame caseFrame) {
 		LinkedList<Relation> list = (LinkedList<Relation>) caseFrame.getRelations().clone();
 		for (int i = 0; i < array.length; i++) {
@@ -1006,6 +1006,27 @@ private static boolean followingCaseFrame(Object[][] array, CaseFrame caseFrame)
 		if (!list.isEmpty())
 			return false;
 		return true;
+	}*/
+
+	private static boolean followingCaseFrame(Object[][] array, CaseFrame caseFrame) {
+		LinkedList<Relation> list = new LinkedList<Relation>();
+		list.addAll(caseFrame.getRelations());
+		for (int i = 0; i < array.length; i++) {
+			Relation r = (Relation) array[i][0];
+			if (list.contains(r)) {
+				if (((NodeSet) array[i][1]).size() >= r.getLimit()) {
+					list.remove(r);
+				} else {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
+		if (!list.isEmpty()) {
+			return false;
+		}
+		return true;
 	}
 
 	/**

From 59df7f205a1206e3310b300f269313c7b2079ce8 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Sat, 5 Sep 2020 16:25:26 +0200
Subject: [PATCH 12/14] Graph and node fix

---
 src/sneps/graph/Graph.java  | 30 +++++++++++++++++++++++-------
 src/sneps/graph/Vertex.java | 12 +++++++++---
 src/sneps/network/Node.java |  4 ++--
 3 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/sneps/graph/Graph.java b/src/sneps/graph/Graph.java
index 1c6087ab..907bd444 100644
--- a/src/sneps/graph/Graph.java
+++ b/src/sneps/graph/Graph.java
@@ -54,10 +54,26 @@ public static void constructGraph() {
 		assignXcoordinates();
 		constructEdges();
 		
+		//printGraph();
 		
 		
 	}
 
+	private static void printGraph() {
+		int lastX;
+		for(int i=verticesLBL.size()-1; i>=0; i--) {
+			lastX=0;
+			for(int j=0;j<verticesLBL.get(i).size(); j++) {
+				for(int c=1;c<lastX;c++)
+					System.out.print("           ");
+				System.out.print(verticesLBL.get(i).get(j));
+				lastX=(int) verticesLBL.get(i).get(j).getPosition().x;
+			}
+			System.out.println("");
+		}
+		
+	}
+
 	private static void minimizeEdgeCrossings() {
 		boolean hasChanged = true;
 		for (int c=0;hasChanged; c++) {
@@ -121,7 +137,7 @@ public static void assignXcoordinates() {
 			while(!copyPrioritiesUpper.isEmpty()) {
 				occurrences=new ArrayList<Integer>();
 				max=Collections.max(copyPrioritiesUpper);
-				copyPrioritiesUpper.remove(max);
+				copyPrioritiesUpper.remove(copyPrioritiesUpper.indexOf(max));
 				for (int c=0;c<prioritiesUpperLBL.get(i).size();c++)
 					if(max==prioritiesUpperLBL.get(i).get(c))
 						occurrences.add(c);
@@ -136,8 +152,8 @@ public static void assignXcoordinates() {
 					moveableVertices=new ArrayList<Vertex>();
 					for(int s=0;s<Math.abs(steps);s++) {
 						higherPriority=false;
-						for(int k=index;k<verticesLBL.get(i).size();k+=step) {
-							if(!(verticesLBL.get(i).get(k+step).getPosition().x== verticesLBL.get(i).get(k).getPosition().x+step)) 
+						for(int k=index;k<verticesLBL.get(i).size()-1 && k>0;k+=step) {
+							if(!(verticesLBL.get(i).get(k+step).getPosition().x==verticesLBL.get(i).get(k).getPosition().x+step)) 
 								break;
 							if(verticesLBL.get(i).get(k+step).getPriorityUpper()>verticesLBL.get(i).get(k).getPriorityUpper()) {
 								higherPriority=true;
@@ -159,7 +175,7 @@ public static void assignXcoordinates() {
 			while(!copyPrioritiesLower.isEmpty()) {
 				occurrences=new ArrayList<Integer>();
 				max=Collections.max(copyPrioritiesLower);
-				copyPrioritiesLower.remove(max);
+				copyPrioritiesLower.remove(copyPrioritiesLower.indexOf(max));
 				for (int c=0;c<prioritiesLowerLBL.get(i).size();c++)
 					if(max==prioritiesLowerLBL.get(i).get(c))
 						occurrences.add(c);
@@ -174,7 +190,7 @@ public static void assignXcoordinates() {
 					moveableVertices=new ArrayList<Vertex>();
 					for(int s=0;s<Math.abs(steps);s++) {
 						higherPriority=false;
-						for(int k=index;k<verticesLBL.get(i).size();k+=step) {
+						for(int k=index;k<verticesLBL.get(i).size()-1 && k>0;k+=step) {
 							if(!(verticesLBL.get(i).get(k+step).getPosition().x== verticesLBL.get(i).get(k).getPosition().x+step)) 
 								break;
 							if(verticesLBL.get(i).get(k+step).getPriorityLower()>verticesLBL.get(i).get(k).getPriorityLower()) {
@@ -197,7 +213,7 @@ public static void assignXcoordinates() {
 			while(!copyPrioritiesUpper.isEmpty()) {
 				occurrences=new ArrayList<Integer>();
 				max=Collections.max(copyPrioritiesUpper);
-				copyPrioritiesUpper.remove(max);
+				copyPrioritiesUpper.remove(copyPrioritiesUpper.indexOf(max));
 				for (int c=0;c<prioritiesUpperLBL.get(i).size();c++)
 					if(max==prioritiesUpperLBL.get(i).get(c))
 						occurrences.add(c);
@@ -212,7 +228,7 @@ public static void assignXcoordinates() {
 					moveableVertices=new ArrayList<Vertex>();
 					for(int s=0;s<Math.abs(steps);s++) {
 						higherPriority=false;
-						for(int k=index;k<verticesLBL.get(i).size();k+=step) {
+						for(int k=index;k<verticesLBL.get(i).size()-1 && k>0;k+=step) {
 							if(!(verticesLBL.get(i).get(k+step).getPosition().x== verticesLBL.get(i).get(k).getPosition().x+step)) 
 								break;
 							if(verticesLBL.get(i).get(k+step).getPriorityUpper()>verticesLBL.get(i).get(k).getPriorityUpper()) {
diff --git a/src/sneps/graph/Vertex.java b/src/sneps/graph/Vertex.java
index 8b74ca93..2bca387d 100644
--- a/src/sneps/graph/Vertex.java
+++ b/src/sneps/graph/Vertex.java
@@ -32,6 +32,8 @@ public Vertex(Node node, Point2D.Double position, ArrayList<Integer> parentIndic
 		incomingEdges= new ArrayList<Edge>();
 		if(position.x>max_X)
 			max_X=position.x;
+		
+		
 	}
 
 	/**
@@ -58,7 +60,8 @@ public void computeBarycenterValue() {
 	public Double computeBarycenterUpper() {
 		baryUpper=0.0;
 		for(int i=0; i<inDegree; i++)
-			baryLower+=(incomingEdges.get(i).getParentX()/(inDegree+0.0));
+			baryUpper+=(incomingEdges
+					.get(i).getParentX()/(inDegree+0.0));
 		return baryUpper;
 	}
 			
@@ -66,7 +69,7 @@ public Double computeBarycenterUpper() {
 	public Double computeBarycenterLower(){
 		baryLower=0.0;
 		for(int i=0; i<outDegree; i++)
-			baryUpper+=(outgoingEdges.get(i).getChildX()/(outDegree+0.0));
+			baryLower+=(outgoingEdges.get(i).getChildX()/(outDegree+0.0));
 		return baryLower;
 	}
 	
@@ -214,6 +217,9 @@ public int compareTo(Vertex v) {
 		return 1;
 	}
 	
-	
+	public String toString() {
+		//return " ["+position.x+","+ position.y+"] ";
+		return label;
+	}
 		
 }
diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 967f1a98..044a716a 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -303,7 +303,7 @@ public int getLevel() {
 	public boolean updateLevel(int value) {
 		if(!(this instanceof VariableNode)) {
 			if(value>level) {
-				Network.updateNodeLBL(this,value,level);
+				Network.updateNodeLBL(this,level,value);
 				level = value;
 				if (level>numberOfLevels)
 					numberOfLevels++;
@@ -311,7 +311,7 @@ public boolean updateLevel(int value) {
 			}
 		}
 		else {
-			Network.updateNodeLBL(this,value,level);
+			Network.updateNodeLBL(this,level,value);
 			level = value;
 			if (level>numberOfLevels)
 				numberOfLevels++;

From 314c472b91b2c6f22bb818c4e1f2e420a49fca95 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 8 Sep 2020 01:57:11 +0200
Subject: [PATCH 13/14] node constructor fix

---
 src/sneps/network/Node.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/sneps/network/Node.java b/src/sneps/network/Node.java
index 044a716a..4d6a2201 100644
--- a/src/sneps/network/Node.java
+++ b/src/sneps/network/Node.java
@@ -38,11 +38,11 @@ public Node(Term trm) {
 		term = trm;
 		id = count++;
 		level=0;
+		Network.addNodeLBL(this,level);
 		if(this.getTerm() instanceof Molecular) {
 			this.updateUpCables();
 		}
 		updateParentsLevel();
-		Network.addNodeLBL(this,level);
 	}
 
 	public Node(Semantic sem) {
@@ -57,11 +57,11 @@ public Node(Semantic sem, Term trm) {
 		term = trm;
 		id = count++;
 		level=0;
+		Network.addNodeLBL(this,level);
 		if(this.getTerm() instanceof Molecular) {
 			this.updateUpCables();
 		}
 		updateParentsLevel();
-		Network.addNodeLBL(this,level);
 	}
 
 	/**

From fb458c1f70e15b85d2f0af8a42c2545c3c426f33 Mon Sep 17 00:00:00 2001
From: naim79 <mnaim7191@gmail.com>
Date: Tue, 8 Sep 2020 02:13:47 +0200
Subject: [PATCH 14/14] adding comments

---
 src/sneps/graph/Graph.java     | 18 ++++++++++++++----
 src/sneps/network/Network.java |  1 -
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/sneps/graph/Graph.java b/src/sneps/graph/Graph.java
index 907bd444..82e37c37 100644
--- a/src/sneps/graph/Graph.java
+++ b/src/sneps/graph/Graph.java
@@ -13,13 +13,15 @@
 public class Graph {
 	
 	private static ArrayList<ArrayList<Node>> nodesLBL;
-	private static ArrayList<ArrayList<Edge>> edges= new ArrayList<ArrayList<Edge>>();
+	private static ArrayList<ArrayList<Edge>> edges;
 	private static ArrayList<ArrayList<Vertex>> verticesLBL;
 	private static ArrayList<ArrayList<Vertex>> dummyVerticesLBL; 
-	private static ArrayList<LongSpanEdge> longSpanEdges= new ArrayList<LongSpanEdge>();
+	private static ArrayList<LongSpanEdge> longSpanEdges;
 	
 	
 	public static void constructGraph() {
+		edges= new ArrayList<ArrayList<Edge>>();
+		longSpanEdges= new ArrayList<LongSpanEdge>();
 		nodesLBL= Network.getNodesLBL();
 		Node node;
 		verticesLBL = new ArrayList<ArrayList<Vertex>>();
@@ -101,6 +103,8 @@ public static void constructEdges() {
 	}
 	
 	public static void assignXcoordinates() {
+
+		//setting priorities
 		int sumUpper;
 		int sumLower;
 		ArrayList<ArrayList<Integer>> prioritiesUpperLBL= new ArrayList<ArrayList<Integer>>();
@@ -132,6 +136,8 @@ public static void assignXcoordinates() {
 		int index;
 		ArrayList<Vertex> moveableVertices;
 		boolean higherPriority;
+
+		//Down Procedure
 		for(int i=verticesLBL.size()-1; i>-1; i--) {
 			copyPrioritiesUpper=((ArrayList<Integer>) prioritiesUpperLBL.get(i).clone());
 			while(!copyPrioritiesUpper.isEmpty()) {
@@ -170,6 +176,8 @@ public static void assignXcoordinates() {
 			}
 		}
 		ArrayList<Integer> copyPrioritiesLower;
+
+		//Up Procedure
 		for(int i=1; i<verticesLBL.size(); i++) {
 			copyPrioritiesLower=((ArrayList<Integer>) prioritiesLowerLBL.get(i).clone());
 			while(!copyPrioritiesLower.isEmpty()) {
@@ -207,7 +215,8 @@ public static void assignXcoordinates() {
 				}
 			}
 		}
-		
+
+		//Down Procedure again
 		for(int i=verticesLBL.size()-1; i>-1; i--) {
 			copyPrioritiesUpper=((ArrayList<Integer>) prioritiesUpperLBL.get(i).clone());
 			while(!copyPrioritiesUpper.isEmpty()) {
@@ -245,6 +254,8 @@ public static void assignXcoordinates() {
 				}
 			}
 		}
+
+		//Shift all nodes if any node has a negative x-coordinate
 		shiftVertices();
 	}
 	
@@ -258,6 +269,5 @@ private static void shiftVertices() {
 	}
 	
 	public static void clear() {
-		longSpanEdges=new ArrayList<LongSpanEdge>();
 	}
 }
diff --git a/src/sneps/network/Network.java b/src/sneps/network/Network.java
index 1ce5cefd..edb51048 100644
--- a/src/sneps/network/Network.java
+++ b/src/sneps/network/Network.java
@@ -2119,7 +2119,6 @@ public static void clearNetwork() {
 		userDefinedMolSuffix.clear();
 		userDefinedPatSuffix.clear();
 		userDefinedVarSuffix.clear();
-		Graph.clear();
 		nodesLBL = new ArrayList<ArrayList<Node>>();
 	}