Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/utils/DAO.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/utils/DAO.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/utils/DAO.java	(revision 1247)
@@ -7,5 +7,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.scheduling.tasks.TaskInterface;
@@ -20,5 +20,5 @@
 	private TaskToApp taskToApp = new TaskToApp();
 
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -31,10 +31,10 @@
 	}
 	
-	private String getNodeCategory(ComputingNode node){
+	private String getNodeCategory(Node node){
 
 		return node.getCategory();
 	}
 	
-	private int getFrequency(ComputingNode node){
+	private int getFrequency(Node node){
 		Processor proc = (Processor) node.getProcessors().get(0);
 		double freq = proc.getPowerInterface().getFrequency();
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java	(revision 1247)
@@ -10,5 +10,5 @@
 
 import schedframe.events.scheduling.SchedulingEvent;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Core;
 import schedframe.resources.computing.Processor;
@@ -75,6 +75,6 @@
 		//System.out.println("rccc");
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		Core core = (Core)pe.get(0);
 		return core.getParent().getParent().getCategory();
@@ -83,6 +83,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		Core core = (Core)pe.get(0);
 		Processor proc = (Processor) core.getParent();
@@ -98,5 +98,5 @@
 		try {
 			cpuReq = task.getCpuCntRequest();
-			cpuReq = ((ComputingNode)pe.get(0)).getProcessors().get(0).getCores().size();
+			cpuReq = ((Node)pe.get(0)).getProcessors().get(0).getCores().size();
 		} catch (NoSuchFieldException e) {
 				cpuReq = 1;
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -64,5 +64,5 @@
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			break;
 		}
@@ -75,9 +75,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 		if(node.getStatus() == ResourceStatus.UNAVAILABLE) {
 			node.getPowerInterface().setPowerState(StandardPowerStateName.ON);
@@ -113,7 +113,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -156,10 +156,10 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
 	
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessDFSSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessDFSSP.java	(revision 1245)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessDFSSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -75,9 +75,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 
 		int cpuRequest;
@@ -111,7 +111,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -154,5 +154,5 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java	(revision 1247)
@@ -18,5 +18,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -76,5 +76,5 @@
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			break;
 		}
@@ -86,7 +86,7 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
+		List<Node> nodes = resourceManager.getNodes();
 		Collections.sort(nodes, new EnergyComparator(task));
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -156,5 +156,5 @@
 
 	
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -167,10 +167,10 @@
 	}
 	
-	private String getNodeCategory(ComputingNode node){
+	private String getNodeCategory(Node node){
 
 		return node.getCategory();
 	}
 	
-	private int getFrequency(ComputingNode node){
+	private int getFrequency(Node node){
 		Processor proc = (Processor) node.getProcessors().get(0);
 		double freq = proc.getPowerInterface().getFrequency();
@@ -211,5 +211,5 @@
 		return timeBundle;
 	}
-	class EnergyComparator implements Comparator<ComputingNode>{
+	class EnergyComparator implements Comparator<Node>{
 		private TaskInterface<?> task;
 		
@@ -218,5 +218,5 @@
 		}
 		
-	    public int compare(ComputingNode node1, ComputingNode node2){    
+	    public int compare(Node node1, Node node2){    
 	    	double node1EU = Double.MAX_VALUE;
 	    	double node2EU = Double.MAX_VALUE;
@@ -248,6 +248,6 @@
 	}
 	
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessFirstSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessFirstSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessFirstSP.java	(revision 1247)
@@ -10,5 +10,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -67,6 +67,6 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		for (ComputingNode node : nodes) {
+		List<Node> nodes = resourceManager.getNodes();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessNodePowManSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessNodePowManSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessNodePowManSP.java	(revision 1247)
@@ -10,5 +10,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -55,10 +55,10 @@
 						addToSchedulingPlan(plan, task, choosenResources);
 					} else {
-						if(harnessIdleNodesToWork(task, resourceManager.getComputingNodes()))
+						if(harnessIdleNodesToWork(task, resourceManager.getNodes()))
 							i--;
 					}
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			break;
 		}
@@ -70,10 +70,10 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
 
-		for(ComputingNode node: avNodes){
+		for(Node node: avNodes){
 			int cpuRequest;
 			try {
@@ -105,6 +105,6 @@
 	}
 
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
@@ -120,5 +120,5 @@
 	}
 	
-	private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<ComputingNode> nodes){
+	private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<Node> nodes){
 
 		int cpuRequest;
@@ -129,5 +129,5 @@
 		}
 		for (int i = 0; i < nodes.size(); i++) {
-			ComputingNode node = nodes.get(i);
+			Node node = nodes.get(i);
 			if(node.getPowerInterface().getPowerState() == StandardPowerStateName.OFF){
 
@@ -144,7 +144,7 @@
 
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessDFSSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessDFSSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessDFSSP.java	(revision 1247)
@@ -11,5 +11,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -73,9 +73,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 
 		int cpuRequest;
@@ -108,7 +108,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -141,5 +141,5 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsSP.java	(revision 1247)
@@ -7,5 +7,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.scheduling.tasks.TaskInterface;
 import test.drs_tst.recs.utils.AppType;
@@ -27,5 +27,5 @@
 	}
 	
-	protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createExecutivenessQuery(TaskInterface<?> task, Node node) {
 		Executable exec = (Executable)task;
 		String query = getApplicationType(exec) + "." + getNodeCategory(node);
@@ -38,5 +38,5 @@
 	}
 	
-	private String getNodeCategory(ComputingNode node){
+	private String getNodeCategory(Node node){
 		return node.getCategory();
 	}
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomSP.java	(revision 1120)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -73,9 +73,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 		int cpuRequest;
 		try {
@@ -108,7 +108,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -152,5 +152,5 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java	(revision 1245)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java	(revision 1247)
@@ -18,5 +18,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -85,8 +85,8 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
+		List<Node> nodes = resourceManager.getNodes();
 		Collections.sort(nodes, new EnergyComparator(task));
 		//System.out.println("*****");
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			//System.out.println(node.getCategory());
 			int cpuRequest;
@@ -153,5 +153,5 @@
 
 	
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -164,10 +164,10 @@
 	}
 	
-	private String getNodeCategory(ComputingNode node){
+	private String getNodeCategory(Node node){
 
 		return node.getCategory();
 	}
 	
-	private int getFrequency(ComputingNode node){
+	private int getFrequency(Node node){
 		Processor proc = (Processor) node.getProcessors().get(0);
 		double freq = proc.getPowerInterface().getFrequency();
@@ -208,5 +208,5 @@
 		return timeBundle;
 	}
-	class EnergyComparator implements Comparator<ComputingNode>{
+	class EnergyComparator implements Comparator<Node>{
 		private TaskInterface<?> task;
 		
@@ -215,5 +215,5 @@
 		}
 		
-	    public int compare(ComputingNode node1, ComputingNode node2){    
+	    public int compare(Node node1, Node node2){    
 	    	double node1EU = Double.MAX_VALUE;
 	    	double node2EU = Double.MAX_VALUE;
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java	(revision 1245)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java	(revision 1247)
@@ -18,5 +18,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -83,8 +83,8 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
+		List<Node> nodes = resourceManager.getNodes();
 		Collections.sort(nodes, new EnergyComparator(task));
 		//System.out.println("*****");
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			//System.out.println(node.getCategory());
 			int cpuRequest;
@@ -151,5 +151,5 @@
 
 	
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -162,10 +162,10 @@
 	}
 	
-	private String getNodeCategory(ComputingNode node){
+	private String getNodeCategory(Node node){
 
 		return node.getCategory();
 	}
 	
-	private int getFrequency(ComputingNode node){
+	private int getFrequency(Node node){
 		Processor proc = (Processor) node.getProcessors().get(0);
 		double freq = proc.getPowerInterface().getFrequency();
@@ -207,5 +207,5 @@
 		return timeBundle;
 	}
-	class EnergyComparator implements Comparator<ComputingNode>{
+	class EnergyComparator implements Comparator<Node>{
 		private TaskInterface<?> task;
 		
@@ -214,5 +214,5 @@
 		}
 		
-	    public int compare(ComputingNode node1, ComputingNode node2){    
+	    public int compare(Node node1, Node node2){    
 	    	double node1EU = Double.MAX_VALUE;
 	    	double node2EU = Double.MAX_VALUE;
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomZ510NodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomZ510NodeEEP.java	(revision 1243)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomZ510NodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -17,5 +17,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AmdNodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AmdNodeEEP.java	(revision 1243)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AmdNodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -18,5 +18,5 @@
 		double powerConsumption = 0;
 		
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/RecsNodeBaseEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/RecsNodeBaseEEP.java	(revision 1245)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/RecsNodeBaseEEP.java	(revision 1247)
@@ -9,5 +9,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Core;
 import schedframe.resources.computing.Processor;
@@ -54,6 +54,6 @@
 		
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		Core core = (Core)pe.get(0);
 		return core.getParent().getParent().getCategory();
@@ -62,6 +62,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		Core core = (Core)pe.get(0);
 		Processor proc = (Processor) core.getParent();
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomD510NodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomD510NodeEEP.java	(revision 1243)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomD510NodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/IntelNodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/IntelNodeEEP.java	(revision 1243)
+++ DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/IntelNodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		
 		try {
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java	(revision 1197)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java	(revision 1247)
@@ -18,5 +18,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -81,8 +81,8 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
+		List<Node> nodes = resourceManager.getNodes();
 		Collections.sort(nodes, new EnergyComparator(task));
 		//System.out.println("*****");
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			//System.out.println(node.getCategory());
 			int cpuRequest;
@@ -149,5 +149,5 @@
 
 	
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -178,5 +178,5 @@
 		return timeBundle;
 	}
-	class EnergyComparator implements Comparator<ComputingNode>{
+	class EnergyComparator implements Comparator<Node>{
 		private TaskInterface<?> task;
 		
@@ -185,5 +185,5 @@
 		}
 		
-	    public int compare(ComputingNode node1, ComputingNode node2){    
+	    public int compare(Node node1, Node node2){    
 	    	double node1EU = Double.MAX_VALUE;
 	    	double node2EU = Double.MAX_VALUE;
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java	(revision 734)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -64,5 +64,5 @@
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			break;
 		}
@@ -75,9 +75,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 		if(node.getStatus() == ResourceStatus.UNAVAILABLE) {
 			node.getPowerInterface().setPowerState(StandardPowerStateName.ON);
@@ -113,7 +113,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -156,10 +156,10 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
 	
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessDFSSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessDFSSP.java	(revision 734)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessDFSSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -75,9 +75,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 
 		int cpuRequest;
@@ -111,7 +111,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -154,5 +154,5 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java	(revision 1197)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java	(revision 1247)
@@ -18,5 +18,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -75,5 +75,5 @@
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			break;
 		}
@@ -85,7 +85,7 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
+		List<Node> nodes = resourceManager.getNodes();
 		Collections.sort(nodes, new EnergyComparator(task));
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -155,5 +155,5 @@
 
 	
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -184,5 +184,5 @@
 		return timeBundle;
 	}
-	class EnergyComparator implements Comparator<ComputingNode>{
+	class EnergyComparator implements Comparator<Node>{
 		private TaskInterface<?> task;
 		
@@ -191,5 +191,5 @@
 		}
 		
-	    public int compare(ComputingNode node1, ComputingNode node2){    
+	    public int compare(Node node1, Node node2){    
 	    	double node1EU = Double.MAX_VALUE;
 	    	double node2EU = Double.MAX_VALUE;
@@ -221,6 +221,6 @@
 	}
 	
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsSP.java	(revision 1197)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsSP.java	(revision 1247)
@@ -7,5 +7,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.scheduling.tasks.TaskInterface;
@@ -27,5 +27,5 @@
 	}
 	
-	protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createExecutivenessQuery(TaskInterface<?> task, Node node) {
 		Executable exec = (Executable)task;
 		String query = getApplicationType(exec) + "." + getNodeCategory(node);
@@ -38,5 +38,5 @@
 	}
 	
-	protected String getNodeCategory(ComputingNode node){
+	protected String getNodeCategory(Node node){
 		return node.getCategory();
 	}
@@ -52,5 +52,5 @@
 	}
 	
-	protected int getFrequency(ComputingNode node){
+	protected int getFrequency(Node node){
 		Processor proc = (Processor) node.getProcessors().get(0);
 		double freq = proc.getPowerInterface().getFrequency();
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomSP.java	(revision 734)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -73,9 +73,9 @@
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
 		
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
-		List<ComputingNode> avNodes = filterNodes(nodes, task);
+		List<Node> nodes = resourceManager.getNodes();
+		List<Node> avNodes = filterNodes(nodes, task);
 		if(avNodes.size() == 0)
 			return null;
-		ComputingNode node = randomNode(avNodes);
+		Node node = randomNode(avNodes);
 
 		int cpuRequest;
@@ -109,7 +109,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -152,5 +152,5 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java	(revision 1208)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java	(revision 1247)
@@ -18,5 +18,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -84,8 +84,8 @@
 
 		Map<ResourceUnitName, ResourceUnit> map;
-		List<ComputingNode> nodes = resourceManager.getComputingNodes();
+		List<Node> nodes = resourceManager.getNodes();
 		Collections.sort(nodes, new EnergyComparator(task));
 		//System.out.println("*****");
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			//System.out.println(node.getCategory());
 			int cpuRequest;
@@ -152,5 +152,5 @@
 
 	
-	protected String createQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createQuery(TaskInterface<?> task, Node node) {
 		String query;
 		query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task);
@@ -181,5 +181,5 @@
 		return timeBundle;
 	}
-	class EnergyComparator implements Comparator<ComputingNode>{
+	class EnergyComparator implements Comparator<Node>{
 		private TaskInterface<?> task;
 		
@@ -188,5 +188,5 @@
 		}
 		
-	    public int compare(ComputingNode node1, ComputingNode node2){    
+	    public int compare(Node node1, Node node2){    
 	    	double node1EU = Double.MAX_VALUE;
 	    	double node2EU = Double.MAX_VALUE;
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/IntelNodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/IntelNodeEEP.java	(revision 1208)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/IntelNodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		
 		try {
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeModelEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeModelEEP.java	(revision 1208)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeModelEEP.java	(revision 1247)
@@ -11,5 +11,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Core;
 import schedframe.resources.computing.Processor;
@@ -45,5 +45,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		
 		try {
@@ -92,6 +92,6 @@
 		
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		if(pe.get(0) instanceof Processor)
 			return ((Processor)pe.get(0)).getParent().getCategory();
@@ -102,6 +102,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		if(pe.get(0) instanceof Processor)
 			return Double.valueOf(((Processor)pe.get(0)).getPowerInterface().getFrequency()).intValue();
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomZ510NodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomZ510NodeEEP.java	(revision 1208)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomZ510NodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AmdNodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AmdNodeEEP.java	(revision 1208)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AmdNodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeBaseEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeBaseEEP.java	(revision 734)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeBaseEEP.java	(revision 1247)
@@ -8,5 +8,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Core;
 import schedframe.resources.computing.Processor;
@@ -47,6 +47,6 @@
 		
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		Core core = (Core)pe.get(0);
 		return core.getParent().getParent().getCategory();
@@ -55,6 +55,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		Core core = (Core)pe.get(0);
 		Processor proc = (Processor) core.getParent();
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomD510NodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomD510NodeEEP.java	(revision 1208)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomD510NodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/article/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java	(revision 734)
+++ DCWoRMS/branches/coolemall/src/test/article/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java	(revision 1247)
@@ -10,5 +10,5 @@
 
 import schedframe.events.scheduling.SchedulingEvent;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Core;
 import schedframe.resources.computing.Processor;
@@ -74,6 +74,6 @@
 		
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		Core core = (Core)pe.get(0);
 		return core.getParent().getParent().getCategory();
@@ -82,6 +82,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		Core core = (Core)pe.get(0);
 		Processor proc = (Processor) core.getParent();
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOffSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOffSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOffSP.java	(revision 1247)
@@ -13,5 +13,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -55,5 +55,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -61,5 +61,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -69,5 +69,5 @@
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			adjustOtherFans(notSelectedNodes);
 			break;
@@ -76,7 +76,7 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
-		for(ComputingNode node: nodes){
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -92,5 +92,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -126,7 +126,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -169,6 +169,6 @@
 	}
 
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
@@ -183,6 +183,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutOffSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutOffSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutOffSP.java	(revision 1247)
@@ -14,5 +14,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -56,5 +56,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -62,5 +62,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -70,5 +70,5 @@
 				}
 			}
-			turnOffIdleNodes(resourceManager.getComputingNodes());
+			turnOffIdleNodes(resourceManager.getNodes());
 			adjustOtherFans(notSelectedNodes);
 			break;
@@ -77,7 +77,7 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
-		for(ComputingNode node: nodes){
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -93,5 +93,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -127,7 +127,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -170,6 +170,6 @@
 	}
 
-	private void turnOffIdleNodes(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void turnOffIdleNodes(List<Node> nodes){
+		for(Node node : nodes){
 			Processor proc = node.getProcessors().get(0);
 			int freeCores = 0;
@@ -184,6 +184,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInIdleSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInIdleSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInIdleSP.java	(revision 1247)
@@ -13,5 +13,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -51,5 +51,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -57,5 +57,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -71,7 +71,7 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
-		for(ComputingNode node: nodes){
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -84,5 +84,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -118,7 +118,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -161,6 +161,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				//node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutIdleSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutIdleSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutIdleSP.java	(revision 1247)
@@ -13,5 +13,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -51,5 +51,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -57,5 +57,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -71,7 +71,7 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
-		for(ComputingNode node: nodes){
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -84,5 +84,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -118,7 +118,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -161,6 +161,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				//node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOutSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOutSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOutSP.java	(revision 1247)
@@ -16,5 +16,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -54,5 +54,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -60,5 +60,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -74,8 +74,8 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
 		Collections.sort(nodes, new ResourceIdRandomComparator());
-		for(ComputingNode node: nodes){
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -88,5 +88,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -122,7 +122,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -165,6 +165,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				//node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
@@ -177,5 +177,5 @@
 
 
-class ResourceIdRandomComparator implements Comparator<ComputingNode>{
+class ResourceIdRandomComparator implements Comparator<Node>{
 	
 	protected Random random;
@@ -183,5 +183,5 @@
 		random = new Random(5);
 	}
-	public int compare(ComputingNode node1, ComputingNode node2){    
+	public int compare(Node node1, Node node2){    
 		return random.nextInt(3) - 1;
 	   
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsIn2OutSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsIn2OutSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsIn2OutSP.java	(revision 1247)
@@ -15,5 +15,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -53,5 +53,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -59,5 +59,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -73,8 +73,8 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
 		Collections.sort(nodes, new ResourceIdComparator());
-		for(ComputingNode node: nodes){
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -88,5 +88,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -122,7 +122,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -165,6 +165,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				//node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
@@ -175,7 +175,7 @@
 	}
 	
-	class ResourceIdComparator implements Comparator<ComputingNode> {
-
-		public int compare(ComputingNode node1, ComputingNode node2) {
+	class ResourceIdComparator implements Comparator<Node> {
+
+		public int compare(Node node1, Node node2) {
 			Integer id1 = Integer.parseInt(node1.getName().split("_")[1]);
 			Integer id2 = Integer.parseInt(node2.getName().split("_")[1]);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsOut2InSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsOut2InSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsOut2InSP.java	(revision 1247)
@@ -15,5 +15,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -53,5 +53,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -59,5 +59,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -73,8 +73,8 @@
 	}
 	
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
 		Collections.sort(nodes, new ResourceIdComparator());
-		for(ComputingNode node: nodes){
+		for(Node node: nodes){
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if((id >= START_ID  && id <= END_ID)){
@@ -87,5 +87,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -121,7 +121,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -164,6 +164,6 @@
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				//node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
@@ -174,7 +174,7 @@
 	}
 	
-	class ResourceIdComparator implements Comparator<ComputingNode> {
+	class ResourceIdComparator implements Comparator<Node> {
 
-		public int compare(ComputingNode node1, ComputingNode node2) {
+		public int compare(Node node1, Node node2) {
 			Integer id1 = Integer.parseInt(node1.getName().split("_")[1]);
 			Integer id2 = Integer.parseInt(node2.getName().split("_")[1]);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsRandomSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsRandomSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsRandomSP.java	(revision 1247)
@@ -11,5 +11,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -50,5 +50,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -56,5 +56,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseRandomProvider(resourceManager, task);
+					Node node = chooseRandomProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -70,6 +70,6 @@
 	}
 	
-	private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
+	private Node chooseRandomProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
 		if(nodes.size() > 0)
 			return randomNode(nodes);
@@ -78,5 +78,5 @@
 
 	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
-			ComputingNode node, TaskInterface<?> task) {
+			Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -112,7 +112,7 @@
 	}
 	
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -145,10 +145,10 @@
 	}
 	
-	private ComputingNode randomNode(List<ComputingNode> nodes){
+	private Node randomNode(List<Node> nodes){
 		return nodes.get(rand.nextInt(nodes.size()));
 	}
 	
-	private void adjustOtherFans(List<ComputingNode> nodes){
-		for(ComputingNode node : nodes){
+	private void adjustOtherFans(List<Node> nodes){
+		for(Node node : nodes){
 			if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
 				node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsLeft2RightSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsLeft2RightSP.java	(revision 1211)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsLeft2RightSP.java	(revision 1247)
@@ -15,5 +15,5 @@
 import schedframe.events.scheduling.SchedulingEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -54,5 +54,5 @@
 			TaskQueue q = queues.get(0);
 
-			List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes();
+			List<Node> notSelectedNodes = resourceManager.getNodes();
 			// check all tasks in queue
 			for (int i = 0; i < q.size(); i++) {
@@ -60,5 +60,5 @@
 				// if status of the tasks in READY
 				if (task.getStatus() == DCWormsTags.READY) {
-					ComputingNode node = chooseProvider(resourceManager, task);
+					Node node = chooseProvider(resourceManager, task);
 					if (node != null) {
 						node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
@@ -74,8 +74,8 @@
 	}
 
-	private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
-		List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task);
+	private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) {
+		List<Node> nodes = filterNodes(resourceManager.getNodes(), task);
 		Collections.sort(nodes, new ResourceIdComparator());
-		for (ComputingNode node : nodes) {
+		for (Node node : nodes) {
 			Integer id = Integer.parseInt(node.getName().split("_")[1]);
 			if ((id >= START_ID && id <= END_ID)) {
@@ -88,5 +88,5 @@
 	}
 
-	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(ComputingNode node, TaskInterface<?> task) {
+	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(Node node, TaskInterface<?> task) {
 
 		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
@@ -122,7 +122,7 @@
 	}
 
-	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task) {
-		List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
-		for (ComputingNode node : nodes) {
+	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task) {
+		List<Node> filteredNodes = new ArrayList<Node>();
+		for (Node node : nodes) {
 			int cpuRequest;
 			try {
@@ -165,6 +165,6 @@
 	}
 
-	private void adjustOtherFans(List<ComputingNode> nodes) {
-		for (ComputingNode node : nodes) {
+	private void adjustOtherFans(List<Node> nodes) {
+		for (Node node : nodes) {
 			if (node.getFreeProcessorsNumber() == node.getProcessorsNumber()) {
 				// node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
@@ -175,7 +175,7 @@
 	}
 
-	class ResourceIdComparator implements Comparator<ComputingNode> {
+	class ResourceIdComparator implements Comparator<Node> {
 
-		public int compare(ComputingNode node1, ComputingNode node2) {
+		public int compare(Node node1, Node node2) {
 			Integer id1 = Integer.parseInt(node1.getName().split("_")[1]);
 			Integer id2 = Integer.parseInt(node2.getName().split("_")[1]);
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/RecsSP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/RecsSP.java	(revision 828)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/RecsSP.java	(revision 1247)
@@ -7,5 +7,5 @@
 import java.util.ResourceBundle;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.scheduling.tasks.TaskInterface;
 import test.article2.recs.utils.AppType;
@@ -27,5 +27,5 @@
 	}
 	
-	protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) {
+	protected String createExecutivenessQuery(TaskInterface<?> task, Node node) {
 		Executable exec = (Executable)task;
 		String query = getApplicationType(exec) + "." + getNodeCategory(node);
@@ -38,5 +38,5 @@
 	}
 	
-	private String getNodeCategory(ComputingNode node){
+	private String getNodeCategory(Node node){
 		return node.getCategory();
 	}
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AtomD510NodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AtomD510NodeEEP.java	(revision 1210)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AtomD510NodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/IntelNodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/IntelNodeEEP.java	(revision 1210)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/IntelNodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		
 		try {
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/DataCenterEnergyEstimationPlugin.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/DataCenterEnergyEstimationPlugin.java	(revision 1210)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/DataCenterEnergyEstimationPlugin.java	(revision 1247)
@@ -1,5 +1,5 @@
 package test.article2.recs.plugins.energy;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.DataCenter;
@@ -17,5 +17,5 @@
 		double power = 0;
 		DataCenter dataCenter = (DataCenter)resource;
-		for(ComputingNode cn:dataCenter.getComputingNodes()){
+		for(Node cn:dataCenter.getNodes()){
 			PowerUsage powerUsage = cn.getPowerInterface().getRecentPowerUsage();
 			power += (powerUsage == null ? 0 : powerUsage.getValue());
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AmdNodeEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AmdNodeEEP.java	(revision 1210)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AmdNodeEEP.java	(revision 1247)
@@ -4,5 +4,5 @@
 import java.io.IOException;
 
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
@@ -15,5 +15,5 @@
 			PhysicalResource resource) {
 		double powerConsumption = 0;
-		ComputingNode node = (ComputingNode) resource;
+		Node node = (Node) resource;
 		try {
 			if(jobRegistry.getRunningTasks().size() > 0) {
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/RecsNodeBaseEEP.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/RecsNodeBaseEEP.java	(revision 1210)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/RecsNodeBaseEEP.java	(revision 1247)
@@ -10,5 +10,5 @@
 
 import schedframe.events.scheduling.EventReason;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Core;
@@ -137,6 +137,6 @@
 		
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		if(pe.get(0) instanceof Processor)
 			return ((Processor)pe.get(0)).getParent().getCategory();
@@ -147,6 +147,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		if(pe.get(0) instanceof Processor)
 			return Double.valueOf(((Processor)pe.get(0)).getPowerInterface().getFrequency()).intValue();
Index: DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java	(revision 826)
+++ DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java	(revision 1247)
@@ -10,5 +10,5 @@
 
 import schedframe.events.scheduling.SchedulingEvent;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.Core;
 import schedframe.resources.computing.Processor;
@@ -74,6 +74,6 @@
 		
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return ((ComputingNode)pe.get(0)).getCategory();
+		if(pe.get(0) instanceof Node)
+			return ((Node)pe.get(0)).getCategory();
 		if(pe.get(0) instanceof Processor)
 			return ((Processor)pe.get(0)).getParent().getCategory();
@@ -84,6 +84,6 @@
 	private int getFrequency(PEUnit peUnit){
 		ProcessingElements pe = (ProcessingElements) peUnit;
-		if(pe.get(0) instanceof ComputingNode)
-			return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
+		if(pe.get(0) instanceof Node)
+			return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue();
 		if(pe.get(0) instanceof Processor)
 			return Double.valueOf(((Processor)pe.get(0)).getPowerInterface().getFrequency()).intValue();
Index: DCWoRMS/branches/coolemall/src/test/ariel/FCFSCPUFreqScalingPlugin.java
===================================================================
--- DCWoRMS/branches/coolemall/src/test/ariel/FCFSCPUFreqScalingPlugin.java	(revision 506)
+++ DCWoRMS/branches/coolemall/src/test/ariel/FCFSCPUFreqScalingPlugin.java	(revision 1247)
@@ -12,5 +12,5 @@
 import schedframe.events.scheduling.TaskRequestedTimeExpiredEvent;
 import schedframe.resources.ResourceStatus;
-import schedframe.resources.computing.ComputingNode;
+import schedframe.resources.computing.Node;
 import schedframe.resources.computing.ComputingResource;
 import schedframe.resources.computing.Processor;
