Merge Battery

src/classes/HolonBattery.java

@@ -8,8 +8,6 @@ public class HolonBattery extends AbstractCpsObject{
 	private float outRatio;
 	private float capacity;
 	private float initialStateOfCharge;
-	private float stateOfCharge;
-	private float newStateOfCharge;
 	private float[] stateOfChargeLevels;
 	private float iterations = 0;
 	public enum State{STANDBY, COLLECT, EMIT};
@@ -23,8 +21,6 @@ public class HolonBattery extends AbstractCpsObject{
 		inRatio = 0;
 		outRatio = 0;
 		capacity = 0;
-		stateOfCharge = 0;
-		newStateOfCharge = 0;
 		initialStateOfCharge = 0;
 		setState(State.STANDBY);
 	}
@@ -38,17 +34,9 @@ public class HolonBattery extends AbstractCpsObject{
 		setInRatio(((HolonBattery) obj).getInRatio());
 		setOutRatio(((HolonBattery) obj).getOutRatio());
 		setCapacity(((HolonBattery) obj).getCapacity());
-		setStateOfCharge(((HolonBattery) obj).getStateOfCharge());
-		setNewStateOfCharge(((HolonBattery) obj).getStateOfCharge());
-		setInitialStateOfCharge(((HolonBattery) obj).getStateOfCharge());
+		setInitialStateOfCharge(((HolonBattery) obj).getInitialStateOfCharge());
 		setState(State.STANDBY);
 	}
-	public float getStateOfCharge() {
-		return stateOfCharge;
-	}
-	public void setStateOfCharge(float stateOfCharge) {
-		this.stateOfCharge = validStateOfCharge(stateOfCharge);
-	}
 	public float getCapacity() {
 	
 		return capacity;
@@ -106,28 +94,18 @@ public class HolonBattery extends AbstractCpsObject{
 	 * @return The String that is over the Battery in the Canvas if COLLECT the
 	 *         input if EMIT the output of the Battery
 	 */
-	public String getCanvasBatteryString()
+	public String getCanvasBatteryString(int x)
 	{
-		/*
-		switch(getState())
-		{
-		case COLLECT:
-			return "-" + Float.toString(getIN());
-		case EMIT:
-			return "+" + Float.toString(getOUT());
-		case STANDBY:
-		default:
-			return "0";
-		}
-		*/
-		
-		if(newStateOfCharge > stateOfCharge)
+		x--;
+		float stateOfCharge1 = getStateOfChargeAtTimeStep(x-1);
+		float newStateOfCharge1 =  getStateOfChargeAtTimeStep(x);
+		if(newStateOfCharge1 > stateOfCharge1)
 		{
-			return "+" + Float.toString(newStateOfCharge - stateOfCharge);
+			return "+" + Float.toString(newStateOfCharge1 - stateOfCharge1);
 		}
-		else if (newStateOfCharge < stateOfCharge)
+		else if (newStateOfCharge1 < stateOfCharge1)
 		{
-			return Float.toString(newStateOfCharge - stateOfCharge); // '"-" +' not needed because negative
+			return Float.toString(newStateOfCharge1 - stateOfCharge1); // '"-" +' not needed because negative
 		}else
 		{
 			return "0";
@@ -138,14 +116,7 @@ public class HolonBattery extends AbstractCpsObject{
 	{
 		return "HolonBattery ID:" + this.getId() + " State:" + getState().name() 
 				+ " InRatio:" + getInRatio() + " OutRatio:" + getOutRatio() 
-				+ " Akku: " + getStateOfCharge() + "/" + getCapacity()
-				+ " NewSOC: " + getNewStateOfCharge();
-	}
-	public float getNewStateOfCharge() {
-		return newStateOfCharge;
-	}
-	public void setNewStateOfCharge(float newStateOfCharge) {
-		this.newStateOfCharge = newStateOfCharge;
+				+ " Akku: " + getStateOfChargeAtTimeStep(SingletonControl.getInstance().getControl().getModel().getCurIteration()) + "/" + getCapacity();
 	}
 	public void setStateOfChargeAtTimeStep(float newStateOfCharge, int x) {
 		if(iterations != SingletonControl.getInstance().getControl().getModel().getIterations())
@@ -153,13 +124,24 @@ public class HolonBattery extends AbstractCpsObject{
 			stateOfChargeLevels = new float[SingletonControl.getInstance().getControl().getModel().getIterations()];
 			iterations = SingletonControl.getInstance().getControl().getModel().getIterations();
 		}
-		System.out.println( "Iterations:" + x);
+		
 	
 		stateOfChargeLevels[x] = validStateOfCharge(newStateOfCharge);
-		
-		for(int i = 0; i < stateOfChargeLevels.length; i++)
+		//DEBUG
+		//TODO delete Debug
+		boolean debug = false;
+		if(debug)
 		{
-			System.out.println( i+":"+stateOfChargeLevels[i]+ ",");
+			System.out.println( "Iterations:" + x);
+			for(int i = 0; i < stateOfChargeLevels.length - 1; i++)
+			{
+				System.out.print( i+":"+stateOfChargeLevels[i]+ ", ");
+				if(i%10 == 0)
+				{
+					System.out.println();
+				}
+			}
+			System.out.println( stateOfChargeLevels.length - 1+":"+stateOfChargeLevels[stateOfChargeLevels.length - 1]);
 		}
 	}
 	public float getStateOfChargeAtTimeStep(int x) {

src/classes/HolonObject.java

@@ -321,7 +321,8 @@ public class HolonObject extends AbstractCpsObject {
      * @return boolean is partially supplied
      */
     public boolean checkIfPartiallySupplied(int x) {
-        if (getElements().size() == 0) {
+        
+    	if (getElements().size() == 0) {
             return false;
         }
         float minConsum = 0;
@@ -341,7 +342,7 @@ public class HolonObject extends AbstractCpsObject {
             if (e.isActive()) {
                 float overallEnergy = e.getOverallEnergyAtTimeStep(x);
                 if (overallEnergy > 0) {
-                    prod = prod + overallEnergy;
+                    prod += overallEnergy;
                 }else{
                 	cons += overallEnergy;
                 }
@@ -357,8 +358,23 @@ public class HolonObject extends AbstractCpsObject {
         } else {
             return false;
         }
+        /*
+        float prod = getSelfMadeEnergy(x);
+        float cons =-getMinEnergy(x);
+        //cons = (cons != Float.NEGATIVE_INFINITY)? -cons : 0.f;
+        suppliedPercentage = -(prod + currentSupply)/cons;
+        return (prod  >= cons );*/
     }
     
+    /**@param x TimeStep
+     * @return 
+     */
+    public float getSelfMadeEnergy(int x)
+    {
+    	return getElements().stream()
+    			.map(e ->(e.isActive() && e.getOverallEnergyAtTimeStep(x) > 0) ? e.getOverallEnergyAtTimeStep(x) : 0.0f)
+    			.reduce(0.0f, (a , b) -> a + b );
+    }
     /**
      * Calculates the minimumEnergy Needed to turn on atleast on device
      * of this HolonObject

src/classes/SubNet.java

@@ -84,22 +84,22 @@ public class SubNet {
     public String toString() {
         StringBuilder sb = new StringBuilder();
 
-        sb.append("  Objects:");
-        for (int j = 0; j < getObjects().size(); j++) {
-            HolonObject hl = getObjects().get(j);
-            sb.append("    " + hl.getName() + " " + hl.getId());
+        sb.append("\nObjects:");
+        for (HolonObject hl: getObjects()) {
+            sb.append("    " + hl.getName() + "[ID:" + hl.getId()+ "]");
         }
-        sb.append("  Edges:");
-        for (int j = 0; j < getEdges().size(); j++) {
-            CpsEdge edge = getEdges().get(j);
+        sb.append("\nEdges:");
+        for (CpsEdge edge :getEdges()) {
             sb.append("     " + edge.getA().getName() + " connected To " + edge.getB().getName());
         }
-        sb.append("  Switches:");
-        for (int j = 0; j < getSwitches().size(); j++) {
-            HolonSwitch sw = getSwitches().get(j);
-            sb.append("    " + sw.getName() + " " + sw.getId() + " State:" + sw.getActiveAt());
+        sb.append("\nSwitches:");
+        for (HolonSwitch sw : getSwitches()) {
+            sb.append("    " + sw.getName() + "[ID:" + sw.getId()+ "]" + " State:" + sw.getActiveAt());
+        }
+        sb.append("\nBatteries:");
+        for (HolonBattery hB: getBatteries()) {
+            sb.append("    " + hB.getName() + "[ID:" + hB.getId()+ "]");
         }
-
         return sb.toString();
     }
 }

src/classes/comparator/WeakestBattery.java

@@ -5,8 +5,10 @@ import java.util.Comparator;
 import classes.HolonBattery;
 
 public class WeakestBattery implements Comparator<HolonBattery>{
-
-	
+	int timeStep = 0;
+	 public WeakestBattery(int compareAtTimeStep) {
+	        timeStep = compareAtTimeStep;
+	    }
 	@Override
 	public int compare(HolonBattery o1, HolonBattery o2) {
 		//Sort Battery by the value of StateOfCharge/Capasity
@@ -20,10 +22,10 @@ public class WeakestBattery implements Comparator<HolonBattery>{
 		{
 			return -1;
 		}
-		if (o1.getStateOfCharge() / O1capasity < o2.getStateOfCharge() / O2capasity)
+		if (o1.getStateOfChargeAtTimeStep(timeStep-1) / O1capasity < o2.getStateOfChargeAtTimeStep(timeStep-1) / O2capasity)
 		{
 			return -1;
-		}else if(o1.getStateOfCharge() / O1capasity > o2.getStateOfCharge() / O2capasity)
+		}else if(o1.getStateOfChargeAtTimeStep(timeStep-1) / O1capasity > o2.getStateOfChargeAtTimeStep(timeStep-1) / O2capasity)
 		{
 			return 1;
 		}

src/ui/controller/SimulationManager.java

@@ -11,6 +11,7 @@ import ui.view.MyCanvas;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+
 
 /**
  * Controller for Simulation.
@@ -67,8 +68,16 @@ public class SimulationManager {
 		timeStep = x;
 		searchForSubNets();
 		for (SubNet singleSubNet : subNets) {
-			resetConnections(singleSubNet.getObjects().get(0),
+			if(singleSubNet.getObjects().size() == 0)
+			{
+				resetConnections(singleSubNet.getBatteries().get(0),
+						new ArrayList<>(), new ArrayList<>());
+			}else
+			{
+				resetConnections(singleSubNet.getObjects().get(0),
 					new ArrayList<>(), new ArrayList<>());
+			}
+			
 		}
 		for (SubNet singleSubNet : subNets) {
 			float production = calculateEnergyWithoutFlexDevices("prod",
@@ -113,24 +122,26 @@ public class SimulationManager {
 			 * HolonObjects that can be partially Supplied but might be fully
 			 * Supplied
 			 */
+			/*
 			ArrayList<HolonObject> partiallySuppliedList = new ArrayList<HolonObject>();
 			/**
 			 * HolonObjects that can get the spare energy
 			 */
-			ArrayList<HolonObject> notSuppliedList = new ArrayList<HolonObject>();
+//			
+//			ArrayList<HolonObject> notSuppliedList = new ArrayList<HolonObject>();
 			/**
 			 * Number of HolonObjects that need to be supplied
 			 */
-			long numberOfConsumers = singleSubNet.getObjects().stream()
-			.filter(hl -> (hl.getState() != HolonObject.NO_ENERGY
-					&& hl.getState() != HolonObject.PRODUCER && hl
-					.getConnectedTo().stream()
-					.filter(e -> (e.getFlow() > 0)).count() > 0))
-			.count();
+//			long numberOfConsumers = singleSubNet.getObjects().stream()
+//			.filter(hl -> (hl.getState() != HolonObject.NO_ENERGY
+//					&& hl.getState() != HolonObject.PRODUCER && hl
+//					.getConnectedTo().stream()
+//					.filter(e -> (e.getFlow() > 0)).count() > 0))
+//			.count();
 			/**
 			 * energy each HolonObject receives in AlleEqualModus
 			 */
-			float energyPerHolonObject = 0;
+			
 			if(energySurplus >= 0)
 			{
 				//Supply all consumer
@@ -144,26 +155,22 @@ public class SimulationManager {
 					}
 				}
 				//Supply all Batterys with the left currentProduction
-				System.out.println("production: "+production + " consumption: "+ consumption);
-				singleSubNet.getBatteries().sort(new WeakestBattery());//Sort all batteries by the Value of ther StateOfCharge/Capasity
+				singleSubNet.getBatteries().sort(new WeakestBattery(x));//Sort all batteries by the Value of ther StateOfCharge/Capasity
 				for(HolonBattery hB : singleSubNet.getBatteries())
 				{
-					float energyToCollect = hB.getInAtTimeStep(x);
+					float energyToCollect = hB.getInAtTimeStep(x-1);
 					if(currentProduction >= energyToCollect)
 					{
-						//TODO: change StateofCharge soc = soc + energyToCollect
-						hB.setNewStateOfCharge(hB.getStateOfCharge() + energyToCollect);
+						//change StateofCharge soc = soc + energyToCollect
 						hB.setStateOfChargeAtTimeStep(hB.getStateOfChargeAtTimeStep(x-1) + energyToCollect, x);
 						currentProduction -= energyToCollect;
 					}else
 					{
-						//TODO: change StateofCharge soc = soc + currentProduction
-						hB.setNewStateOfCharge(hB.getStateOfCharge() + currentProduction);
+						//change StateofCharge soc = soc + currentProduction
 						hB.setStateOfChargeAtTimeStep(hB.getStateOfChargeAtTimeStep(x-1) + currentProduction, x);
 						currentProduction = 0;
 						//no break must be calculatet for all break; //because no more energy
 					}
-					System.out.println(hB.toString() + " currentProduction: "+ currentProduction);
 				}
 				//Over_Supply all consumer equal
 				long nOConsumer = singleSubNet.getObjects().stream().filter(hl -> (hl.getCurrentEnergyAtTimeStep(x) < 0)).count();			
@@ -184,28 +191,27 @@ public class SimulationManager {
 			}
 			else
 			{
-				
 				//Check all Battries what they can provide
 				if(energySurplus + GetOutAllBatteries(singleSubNet.getBatteries(), x) >= 0)
 				{
-					singleSubNet.getBatteries().sort(new WeakestBattery());//.reverse();
+					singleSubNet.getBatteries().sort(new WeakestBattery(x));//.reverse();
 					Collections.reverse(singleSubNet.getBatteries()); //most supplyed first
 					//Get the NEEDED energy
 					for(HolonBattery hB : singleSubNet.getBatteries())
 					{
 						float neededEnergyFromBattery = currentProduction + consumption; //Energy is negativ
-						float maxEnergyAvailable = hB.getOutAtTimeStep(x); //energy is positiv
+						float maxEnergyAvailable = hB.getOutAtTimeStep(x-1); //energy is positiv
 						if(maxEnergyAvailable >= -neededEnergyFromBattery)
 						{
-							//TODO: change StateofCharge soc = soc - -neededEnergyFromBattery
-							hB.setNewStateOfCharge(hB.getStateOfCharge() - -neededEnergyFromBattery);
+							//change StateofCharge soc = soc - -neededEnergyFromBattery
+							hB.setStateOfChargeAtTimeStep(hB.getStateOfChargeAtTimeStep(x-1) - -neededEnergyFromBattery, x);
 							currentProduction += -neededEnergyFromBattery;
 							//no break must be calculatet for all beabreak; //When a energy can supply the last needed energy break;
 						}
 						else
 						{
-							//TODO: change StateofCharge soc = soc - maxEnergyAvailable
-							hB.setNewStateOfCharge(hB.getStateOfCharge() - maxEnergyAvailable);
+							//change StateofCharge soc = soc - maxEnergyAvailable
+							hB.setStateOfChargeAtTimeStep(hB.getStateOfChargeAtTimeStep(x-1) - maxEnergyAvailable, x);
 							currentProduction += maxEnergyAvailable;
 						}
 					}
@@ -226,37 +232,92 @@ public class SimulationManager {
 					//Get all Energy out of battries as possible
 					for(HolonBattery hB : singleSubNet.getBatteries())
 					{
-						float maxEnergyAvailable = hB.getOutAtTimeStep(x); //energy is positiv
-						//TODO: change StateofCharge soc = soc - maxEnergyAvailable
-						hB.setNewStateOfCharge(hB.getStateOfCharge() - maxEnergyAvailable);
+						float maxEnergyAvailable = hB.getOutAtTimeStep(x-1); //energy is positiv
+						//change StateofCharge soc = soc - maxEnergyAvailable
+						hB.setStateOfChargeAtTimeStep(hB.getStateOfChargeAtTimeStep(x-1) - maxEnergyAvailable, x);
 						currentProduction += maxEnergyAvailable;
 					}
-					calculation(x, singleSubNet, production, consumption, energySurplus, currentProduction,
-							partiallySuppliedList, notSuppliedList, energyPerHolonObject);
+					//Calc
+					singleSubNet.getObjects().stream().forEach(hl -> hl.setCurrentSupply(0));
+					if(model.getFairnessModel() == fairnessAllEqual)
+					{
+						long nOConsumer = singleSubNet.getObjects().stream().filter(hl -> (hl.getCurrentEnergyAtTimeStep(x) < 0)).count();
+						float energyPerHolonObject = 0;
+						if (nOConsumer != 0)
+							energyPerHolonObject = currentProduction / nOConsumer;
+						for(HolonObject hO : singleSubNet.getObjects())
+						{
+							if(hO.getCurrentEnergyAtTimeStep(x) < 0) //Just Consumer need Energy 
+							{
+								hO.setCurrentSupply(energyPerHolonObject);
+								currentProduction -= energyPerHolonObject; //Subtract the Energy from the Production
+							}
+						}
+					}
+					else //(model.getFairnessModel() == fairnessMininumDemandFirst)
+					{
+						singleSubNet.getObjects().sort(new MinEnergyComparator(x));
+						//SupplyAllMinimumEnergy
+						for(HolonObject hO : singleSubNet.getObjects())
+						{
+							if(hO.checkIfPartiallySupplied(x))continue;
+							if(hO.getCurrentEnergyAtTimeStep(x) > 0)continue;
+							float minEnergy = -hO.getMinEnergy(x); //Energy from getMinEnergy is negative -> convert to positive
+							if(minEnergy <= currentProduction)
+							{
+								hO.setCurrentSupply(minEnergy);
+								currentProduction -= minEnergy;
+							}else
+							{
+								hO.setCurrentSupply(currentProduction);
+								currentProduction = 0;
+								break;
+							}
+						}
+						singleSubNet.getObjects().sort(new EnergyMinToMaxComparator(x));
+						//supplyFullytillEnd ... because its cant be fully supplied 
+						for(HolonObject hO : singleSubNet.getObjects())
+						{
+							float neededEnergy = -hO.getCurrentEnergyAtTimeStep(x);
+							if(neededEnergy < 0)continue; //Producer
+							if(neededEnergy <= currentProduction)
+							{
+								hO.setCurrentSupply(neededEnergy+hO.getCurrentSupply());
+								currentProduction -= neededEnergy;
+							}else
+							{
+								hO.setCurrentSupply(currentProduction+hO.getCurrentSupply());
+								currentProduction = 0;
+								break;
+							}
+						}
+						
+						
+					}
 				}
 				
 			}
 			//Visualize the Color
 			for(HolonObject hO : singleSubNet.getObjects())
 			{
-				
-				float neededEnergy = hO.getCurrentEnergyAtTimeStep(x);
-				if(neededEnergy > 0)
+				float neededEnergy = -hO.getCurrentEnergyAtTimeStep(x); // convert negative energy in positive for calculations
+				if(neededEnergy < 0)
 				{
 					hO.setState(HolonObject.PRODUCER);
 				}
-				else if(neededEnergy < 0)
+				else if(neededEnergy > 0)
 				{
-					float currentSupply = hO.getCurrentSupply();
-					if(currentSupply > -neededEnergy)
+					float currentSupply = hO.getCurrentSupply() ;
+					if(currentSupply > neededEnergy)
 					{
 						hO.setState(HolonObject.OVER_SUPPLIED);
-					}else if (currentSupply ==  -neededEnergy)
+					}else if (currentSupply ==  neededEnergy)
 					{
 						hO.setState(HolonObject.SUPPLIED);
-					}else if (currentSupply <  -neededEnergy)
+					}else if (currentSupply <  neededEnergy)
 					{
-						if(currentSupply >= hO.getMinEnergy(x))
+						float minEnergy = -hO.getMinEnergy(x);
+						if(currentSupply >= minEnergy || hO.getSelfMadeEnergy(x)  >= minEnergy )
 						{
 							hO.setState(HolonObject.PARTIALLY_SUPPLIED);
 						}else
@@ -270,9 +331,6 @@ public class SimulationManager {
 					hO.setState(HolonObject.NO_ENERGY);
 				}
 			}
-			//Old Calculation
-//			calculation(x, singleSubNet, production, consumption, energySurplus, currentProduction,
-//					partiallySuppliedList, notSuppliedList, energyPerHolonObject);
 		}
 		canvas.repaint();
 		flexPane.recalculate();
@@ -430,7 +488,7 @@ public class SimulationManager {
 	/**
 	 * add all battries.getOut() from a list of battries and return them
 	 * @param aL a List of HolonBattries likely from subnet.getBatteries()
-	 * @param x TODO
+	 * @param x TimeStep
 	 * @return 
 	 * 
 	 */
@@ -439,8 +497,10 @@ public class SimulationManager {
 		float OutEnergy = 0;
 		for(HolonBattery hB : aL)
 		{
-			OutEnergy += hB.getOutAtTimeStep(x);
+			//System.out.println("Iteration: "+ x +"OutBattery: "+ hB.getOutAtTimeStep(x-1));
+			OutEnergy += hB.getOutAtTimeStep(x-1);
 		}
+		//System.out.println("Iteration: "+ x +"GetOutAllBatteries: "+ OutEnergy);
 		return OutEnergy;
 	}
 	/**
@@ -838,7 +898,7 @@ public class SimulationManager {
 				SubNet singleSubNet = new SubNet(new ArrayList<>(),
 						new ArrayList<>(), new ArrayList<>(), new ArrayList<>());
 				singleSubNet = buildSubNet(cps, new ArrayList<>(), singleSubNet);
-				if (singleSubNet.getObjects().size() != 0) {
+				if (singleSubNet.getObjects().size() + singleSubNet.getBatteries().size() != 0 ) {
 					subNets.add(singleSubNet);
 				}
 				if (0 == objectsToHandle.size()) {

src/ui/model/Model.java

@@ -201,7 +201,7 @@ public class Model {
     /**
      * Get all Edges on the Canvas.
      *
-     * @return the objectsOnCanvas
+     * @return the edgesOnCanvas
      */
     public ArrayList<CpsEdge> getEdgesOnCanvas() {
         return edgesOnCanvas;

src/ui/view/AbstractCanvas.java

@@ -302,7 +302,7 @@ public abstract class AbstractCanvas extends JPanel {
 				}else if (showedInformation[1] && cps instanceof HolonBattery)
                 {
                 	g2.setColor(Color.BLACK);
-                    g2.drawString(((HolonBattery) cps).getCanvasBatteryString(), cps.getPosition().x - controller.getScaleDiv2(),
+                    g2.drawString(((HolonBattery) cps).getCanvasBatteryString(model.getCurIteration()), cps.getPosition().x - controller.getScaleDiv2(),
                             cps.getPosition().y - controller.getScaleDiv2() - 10);
                 }
 			} else if (cps instanceof HolonObject) {
@@ -322,7 +322,7 @@ public abstract class AbstractCanvas extends JPanel {
 			}else if (cps instanceof HolonBattery) {
                 if (showedInformation[1]) {
                 	g2.setColor(Color.BLACK);
-                    g2.drawString(((HolonBattery) cps).getCanvasBatteryString(), cps.getPosition().x - controller.getScaleDiv2(),
+                    g2.drawString(((HolonBattery) cps).getCanvasBatteryString(model.getCurIteration()), cps.getPosition().x - controller.getScaleDiv2(),
                             cps.getPosition().y - controller.getScaleDiv2() - 10);
                 }
             }

src/ui/view/AddObjectPopUp.java

@@ -312,7 +312,7 @@ public class AddObjectPopUp extends JDialog {
         batteryCapasityBox.setText(Float.toString(editBat.getCapacity()));
         JLabel batterySOCLabel = new JLabel("State of charge:"); 
         JTextField batterySOCBox = new JTextField(10);
-        batterySOCBox.setText(Float.toString(editBat.getStateOfCharge()));
+        batterySOCBox.setText(Float.toString(editBat.getInitialStateOfCharge()));
         
     
         batteryNameLabel.setBounds(beginLabelX, beginColumAtY, 200, 20);
@@ -366,7 +366,7 @@ public class AddObjectPopUp extends JDialog {
         			editBat.setInRatio(changedInRatio);
         			editBat.setOutRatio(changedOutRatio);
         			editBat.setCapacity(changedCapasity);
-        			editBat.setStateOfCharge(changedSOC);
+        			editBat.setInitialStateOfCharge(changedSOC);
 					try {
 						controller.saveCategory();
 						controller.notifyAll();

src/ui/view/MyCanvas.java

@@ -616,21 +616,22 @@ public class MyCanvas extends AbstractCanvas implements MouseListener,
 				AbstractCpsObject toBeReplaced = null;
 				
 				/** for each cps on Canvas */
-				for (AbstractCpsObject cps : model.getObjectsOnCanvas()){
-					
-					/** same object -> ignore */
-					if(cps == tempCps)continue;
-					
-					/** x of object that might get replaced */
-					int c_x = cps.getPosition().x;
-					
-					/** y of object that might get replaced */
-					int c_y = cps.getPosition().y;
-					
-					/** if near enough */
-					if(Math.abs(x-c_x)<treshhold && Math.abs(y-c_y)<treshhold){
-						replaceCounter++;
-						toBeReplaced = cps;
+				if(!(tempCps instanceof CpsNode)){
+					for (AbstractCpsObject cps : model.getObjectsOnCanvas()){
+						/** same object -> ignore */
+						if(cps == tempCps)continue;
+						if(tempCps instanceof CpsNode)continue;
+						/** x of object that might get replaced */
+						int c_x = cps.getPosition().x;
+						
+						/** y of object that might get replaced */
+						int c_y = cps.getPosition().y;
+						
+						/** if near enough */
+						if(Math.abs(x-c_x)<treshhold && Math.abs(y-c_y)<treshhold){
+							replaceCounter++;
+							toBeReplaced = cps;
+						}
 					}
 				}
 				/** if replacement of exactly one object possible */

src/ui/view/UpperNodeCanvas.java

@@ -736,21 +736,23 @@ public class UpperNodeCanvas extends AbstractCanvas implements MouseListener, Mo
 				AbstractCpsObject toBeReplaced = null;
 				
 				/** for each cps on Canvas */
-				for (AbstractCpsObject cps : upperNode.getNodes()){
-					
-					/** same object -> ignore */
-					if(cps == tempCps)continue;
-					
-					/** x of object that might get replaced */
-					int c_x = cps.getPosition().x;
-					
-					/** y of object that might get replaced */
-					int c_y = cps.getPosition().y;
-					
-					/** if near enough */
-					if(Math.abs(x-c_x)<treshhold && Math.abs(y-c_y)<treshhold){
-						replaceCounter++;
-						toBeReplaced = cps;
+				if(!(tempCps instanceof CpsNode)){
+					for (AbstractCpsObject cps : upperNode.getNodes()){
+						
+						/** same object -> ignore */
+						if(cps == tempCps)continue;
+						
+						/** x of object that might get replaced */
+						int c_x = cps.getPosition().x;
+						
+						/** y of object that might get replaced */
+						int c_y = cps.getPosition().y;
+						
+						/** if near enough */
+						if(Math.abs(x-c_x)<treshhold && Math.abs(y-c_y)<treshhold){
+							replaceCounter++;
+							toBeReplaced = cps;
+						}
 					}
 				}
 				/** if replacement of exactly one object possible */