first version of blackstarting with resistance on the cables

src/blackstart/controlAlgorithm.java

@@ -9,8 +9,6 @@ import javax.swing.*;
 
 import api.AddOn;
 import classes.*;
-import org.nd4j.linalg.api.ndarray.INDArray;
-import org.nd4j.linalg.factory.Nd4j;
 import ui.controller.Control;
 import ui.controller.StorageProductionController;
 
@@ -27,9 +25,9 @@ public class controlAlgorithm implements AddOn {
 	private Thread runThread;
 
 	// Blackstart Resistance in Watt
-	private HolonObject powerPlant;
+	private HolonObject powerplant;
 
-	private TextField blackstartResistanceTextfield;
+	private TextField blackstartEnergyrequierementTextfield;
 	private TextField blackstartSuccessTimeTextfield;
 	private TextField powerplantMaxOutputTextfield;
 	private TextField blackstartStartTimeTextfield;
@@ -79,13 +77,13 @@ public class controlAlgorithm implements AddOn {
 		JPanel parameterPanel = new JPanel(null);
 		parameterPanel.setPreferredSize(new Dimension(510, 300));
 
-		blackstartResistanceTextfield = new TextField("5000000");
-		blackstartResistanceTextfield.setBounds(10, 10, 170, 20);
-		parameterPanel.add(blackstartResistanceTextfield);
+		blackstartEnergyrequierementTextfield = new TextField("5000000");
+		blackstartEnergyrequierementTextfield.setBounds(10, 10, 170, 20);
+		parameterPanel.add(blackstartEnergyrequierementTextfield);
 
-		JLabel blackstartResistanceLabel = new JLabel("Blackstart resistance in Watt");
-		blackstartResistanceLabel.setBounds(185, 10, 300, 20);
-		parameterPanel.add(blackstartResistanceLabel);
+		JLabel blackstartEnergyrequierementLabel = new JLabel("Blackstart Energyrequirement in Watt");
+		blackstartEnergyrequierementLabel.setBounds(185, 10, 300, 20);
+		parameterPanel.add(blackstartEnergyrequierementLabel);
 
 		blackstartSuccessTimeTextfield = new TextField("30");
 		blackstartSuccessTimeTextfield.setBounds(10, 35, 170, 20);
@@ -242,18 +240,17 @@ public class controlAlgorithm implements AddOn {
 	private void initAlgo() {
 		try {
 			// init
-			SPC = new StorageProductionController(getStorageElements());// DANGER DONT GIVE NULL
-//			control.getModel().setStorageProductionController();
-//			SPC = control.getModel().getStorageProductionController();
 			renewableProducers = getRenewableProducers();
 			consumers = getConsumers();
-			powerPlant = control.getSimManager().getPowerPlant();// DANGER DONT GIVE NULL
-			if(powerPlant == null){
+			powerplant = control.getSimManager().getPowerplant();// DANGER DONT GIVE NULL
+			setPowerPlantBlackstartResistance(-Float.parseFloat(blackstartEnergyrequierementTextfield.getText()));
+			SPC = new StorageProductionController(getStorageElements(), getEnergyRequiredForPowerplantBlackstart());// DANGER DONT GIVE NULL
+			if(powerplant == null){
 				println("No Power Plant in Model");
 				return;
 			}
-			resistanceCalculator resistanceCalculator = new resistanceCalculator();
-			resistanceCalculator.setDistanceToCalcResistance(powerPlant);
+			resistanceCalculator resistanceCalculator = new resistanceCalculator(control.getModel());
+			resistanceCalculator.setDistanceToCalcResistance(powerplant);
 			blackstartRunningCounter = 0;
 			deactivateBlackstart();
 			control.getModel().setCurIteration(0);
@@ -267,7 +264,7 @@ public class controlAlgorithm implements AddOn {
 			/////////
 
 			// Get parameters from textfields
-			setPowerPlantBlackstartResistance(-Float.parseFloat(blackstartResistanceTextfield.getText()));
+			setPowerPlantBlackstartResistance(-Float.parseFloat(blackstartEnergyrequierementTextfield.getText()));
 			blackstartSuccessTime = Integer.parseInt(blackstartSuccessTimeTextfield.getText());
 			powerplantMaxOutput = Float.parseFloat(powerplantMaxOutputTextfield.getText());
 			blackstartStartTime = Integer.parseInt(blackstartStartTimeTextfield.getText());
@@ -347,12 +344,12 @@ public class controlAlgorithm implements AddOn {
 	 *         this iteration
 	 */
 	private boolean blackstartAlgo() {
-		if (currentRenewableProduction() < getPowerPlantBlackstartResistance()) {
+		if (currentRenewableProduction() < getEnergyRequiredForPowerplantBlackstart()) {
 			// renewable energy production is not sufficient for the blackstart
-			if (SPC.currentPossibleStorageProduction() >= getPowerPlantBlackstartResistance()
+			if (SPC.currentPossibleStorageProduction() >= getEnergyRequiredForPowerplantBlackstart()
 					- currentRenewableProduction()) {// is there currently enough power available from storage?
 				SPC.disableStorageDischarging(-1);// emergency fix
-				SPC.enableStorageDischarging(getPowerPlantBlackstartResistance() - currentRenewableProduction());
+				SPC.enableStorageDischarging(getEnergyRequiredForPowerplantBlackstart() - currentRenewableProduction());
 				rampUpPowerplant();
 				enableConsumers(getPowerplantProduction());
 				return true;
@@ -367,7 +364,7 @@ public class controlAlgorithm implements AddOn {
 			// renewable energy production is sufficient for the blackstart
 			rampUpPowerplant();
 			enableConsumers(
-					currentRenewableProduction() - getPowerPlantBlackstartResistance() + getPowerplantProduction());
+					currentRenewableProduction() - getEnergyRequiredForPowerplantBlackstart() + getPowerplantProduction());
 			return true;
 		}
 	}
@@ -401,7 +398,7 @@ public class controlAlgorithm implements AddOn {
 	private void enableConsumers(float energyAvailable) {
 		println("currenctrenewable: " + currentRenewableProduction());
 		println("currenctpossiblestorage: " + SPC.currentPossibleStorageProduction());
-		println("blackstart resi: " + getPowerPlantBlackstartResistance());
+		println("blackstart resi: " + getEnergyRequiredForPowerplantBlackstart());
 		println("current pp production: " + getPowerplantProduction());
 		println("energy available for consumers" + energyAvailable);
 
@@ -458,7 +455,7 @@ public class controlAlgorithm implements AddOn {
 	}
 
 	private void rampUpPowerplant() {
-		for (HolonElement ele : powerPlant.getElements()) {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Power")) {
 				ele.setEnergyPerElement(ele.getEnergyPerElement() + powerplantMaxOutput / blackstartSuccessTime);
 			}
@@ -467,7 +464,7 @@ public class controlAlgorithm implements AddOn {
 
 	private float getPowerplantProduction() {
 		float totalProduction = 0;
-		for (HolonElement ele : powerPlant.getElements()) {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Power")) {
 				totalProduction = ele.getEnergyPerElement();
 			}
@@ -476,15 +473,15 @@ public class controlAlgorithm implements AddOn {
 	}
 
 	private void setPowerplantProduction(float power) {
-		for (HolonElement ele : powerPlant.getElements()) {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Power")) {
 				ele.setEnergyPerElement(power);
 			}
 		}
 	}
 
-	private float getPowerPlantBlackstartResistance() {
-		for (HolonElement ele : powerPlant.getElements()) {
+	private float getEnergyRequiredForPowerplantBlackstart() {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Blackstart")) {
 				return -ele.getEnergyPerElement();
 			}
@@ -493,7 +490,7 @@ public class controlAlgorithm implements AddOn {
 	}
 
 	private void setPowerPlantBlackstartResistance(float resistance) {
-		for (HolonElement ele : powerPlant.getElements()) {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Blackstart")) {
 				ele.setEnergyPerElement(resistance);
 			}
@@ -501,7 +498,7 @@ public class controlAlgorithm implements AddOn {
 	}
 
 	private void activateBlackstart() {
-		for (HolonElement ele : powerPlant.getElements()) {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Blackstart")) {
 				ele.setActive(true);
 			}
@@ -509,7 +506,7 @@ public class controlAlgorithm implements AddOn {
 	}
 
 	private void deactivateBlackstart() {
-		for (HolonElement ele : powerPlant.getElements()) {
+		for (HolonElement ele : powerplant.getElements()) {
 			if (ele.getEleName().equals("Blackstart")) {
 				ele.setActive(false);
 			}

src/blackstart/resistanceCalculator.java

@@ -1,20 +1,21 @@
 package blackstart;
 
 import classes.*;
-import org.nd4j.linalg.api.ndarray.INDArray;
-import org.nd4j.linalg.factory.Nd4j;
+import ui.model.Model;
 
 public class resistanceCalculator {
 
+    private Model model;
+
+    public resistanceCalculator(Model model){
+        this.model = model;
+    }
+
     void setDistanceToCalcResistance(HolonObject powerPlant) {
         if (powerPlant != null) {
-//			println("Powerplant Energy @"+powerPlant.getEnergyAtTimeStep(1));
-//			println("" + getPowerplantProduction());
-
             // travers
             if (powerPlant.getConnectedTo().size() > 0) {
                 for (CpsEdge edge : powerPlant.getConnectedTo()) {
-//					println(edge.toString());
                     if (powerPlant.getId() == edge.getA().getId()) {
                         traversEdges(edge.getB(), powerPlant, calcEdgeLength(edge));
                     } else {
@@ -22,10 +23,10 @@ public class resistanceCalculator {
                     }
                 }
             } else {
-//                println("Nothing connected to powerplant");
+                System.out.println("Nothing connected to powerplant");
             }
         } else {
-//            println("No powerplant connected");
+            System.out.println("No powerplant connected");
         }
     }
 
@@ -45,20 +46,10 @@ public class resistanceCalculator {
         } else { // at leaf
             for (HolonElement ele : ((HolonObject) currentObject).getElements()) {
                 ele.setDistance(distance);
-//				if (ele.getEleName().equals("Solar Panels")) {// TODO: das wollen wir ja so nicht
-//					ele.setEnergyPerElement(5000);
-//					ele.setEnergyPerElement(calcEnergyAfterResistance(ele.getEnergyPerElement(), distance));
-//				}
             }
-
         }
     }
 
-    private void matrixtest(){
-        INDArray nd = Nd4j.create(new float[]{1, 2, 3, 4}, new int[]{2, 2});
-
-    }
-
     private double calcEdgeLength(CpsEdge edge) {
         Position aPos = edge.getA().getPosition();
         Position bPos = edge.getB().getPosition();
@@ -67,14 +58,14 @@ public class resistanceCalculator {
         return Math.sqrt(Math.pow(xDiff, 2) + Math.pow(yDiff, 2));
     }
 
-    private float calcEnergyAfterResistance(float currentEnergy, double distance, float powerPlantBlackstartResistance) {
+    public float calcEnergyAfterResistance(float currentEnergy, double distance, float energyRequiredForPowerplantBlackstart){
         // 230v kupfer 30mm durchmesser
         int volatage = 230;
         int diameter = 30;
         // kupfer
         double specificMaterialResistance = 0.017;
-        double blackstartResistance = Math.pow(volatage, 2) / powerPlantBlackstartResistance; //getPowerPlantBlackstartResistance() carefull look if positive or negative
+        double blackstartResistance = Math.pow(volatage, 2) / energyRequiredForPowerplantBlackstart;
         double cableResistance = specificMaterialResistance * (distance / (0.25 * Math.PI * Math.pow(diameter, 2)));
         return (float) (1 - (cableResistance / (cableResistance + blackstartResistance))) * currentEnergy;
     }
-}
+}

src/classes/StorageElement.java

@@ -1,5 +1,6 @@
 package classes;
 
+import blackstart.resistanceCalculator;
 import com.google.gson.annotations.Expose;
 import ui.model.Model;
 
@@ -20,6 +21,12 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 	@Expose
 	private float maxOutRatio;
 
+	@Expose
+	private float chargingRatio;
+
+	@Expose
+	private resistanceCalculator resistanceCalculator;
+
 	public StorageElement(String eleName, int amount, float energy, Model model, float capacity, float maxInRatio, float maxOutRatio) {
 		super(eleName, amount, energy, model);
 		this.stateOfCharge = 0;
@@ -28,6 +35,8 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 		this.capacity = capacity * 60;// for example tesla power wall 10kwh, 10kw per hour thus * 60 if iteration =
 									// minutes//TODO:!
 		this.status = Mode.STANDBY;
+		this.chargingRatio = 0;
+		this.resistanceCalculator = new resistanceCalculator(model);
 	}
 
 	public float getEnergyPerElement() {
@@ -37,18 +46,22 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 		return this.energyPerElement;
 	}
 
-	public float getPossibleProduction() {
+	public float getPossibleProduction(float energyRequiredForPowerplantBlackstart) {
 		if (stateOfCharge > 0) {
 			if (stateOfCharge >= maxOutRatio) {
-				return maxOutRatio;
+				return energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart);
 			} else {
-				return stateOfCharge;
+				return energyAfterResistance(stateOfCharge, energyRequiredForPowerplantBlackstart);
 			}
 		} else {
 			return 0;
 		}
 	}
 
+	private float energyAfterResistance(float energy, float energyRequiredForPowerplantBlackstart){
+		return resistanceCalculator.calcEnergyAfterResistance(energy, getDistance(), energyRequiredForPowerplantBlackstart);
+	}
+
 	/**
 	 * 
 	 * @param status Mode of currect operation
@@ -59,47 +72,55 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 
 	//TODO: das beachtet nicht wie viel durch widerstand verloren geht
 
-	public float setStatusAndSetEnergy(Mode status, float energyWanted) {
+	public float setStatusAndSetEnergy(Mode status, float energyWanted, float energyRequiredForPowerplantBlackstart) {
 		this.status = status;
 		switch (status) {
 		case STANDBY:
 			this.setEnergyPerElement(0);
+			chargingRatio = 0;
 			return 0;
 		case EMIT:
 			if (energyWanted >= maxOutRatio) { // more energy wanted than can be giving
 				if (stateOfCharge >= maxOutRatio) { // more energy wanted than can be given
-					this.setEnergyPerElement(maxOutRatio);
-					return maxOutRatio;
+					this.setEnergyPerElement(energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart));
+					chargingRatio = maxOutRatio;
+					return energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart);
 				} else { // less energy stored that can be given
 					return notEnoughChargedToEmitWantedEnergy();
 				}
-			} else {// not enough energy stored than what can be given
+			} else {// less wanted than what can be given
 				if (stateOfCharge >= energyWanted) { // more energy stored than wanted
-					this.setEnergyPerElement(energyWanted);
-					return energyWanted;
+					this.setEnergyPerElement(energyAfterResistance(energyWanted, energyRequiredForPowerplantBlackstart));
+					chargingRatio = energyWanted;
+					return energyAfterResistance(energyWanted, energyRequiredForPowerplantBlackstart);
 				} else { // less energy stored than wanted
 					return notEnoughChargedToEmitWantedEnergy();
 				}
 			}
-			case COLLECT://TODO: testing
+			case COLLECT://TODO: more testing
 			if (energyWanted >= maxInRatio) { // more engery given than can be collected
 				if (stateOfCharge + maxInRatio > capacity) { // Storage nearly full only load rest to get full
 					this.setEnergyPerElement(-(capacity - stateOfCharge));
+					chargingRatio = -(capacity - stateOfCharge);
 					return capacity - stateOfCharge;
 				} else { // load with maximal of what can be collected
 					this.setEnergyPerElement(-maxInRatio);
+					chargingRatio = -maxInRatio;
 					return maxInRatio;
 				}
 			} else { // less engery given than can be taken in
 				if (capacity == stateOfCharge) { // storage full no energy collected
 					this.status = Mode.STANDBY;
+					chargingRatio = 0;
 					return 0;
 				} else {
 					if (stateOfCharge + energyWanted > capacity) { // Storage nearly full only load rest to get full
 						this.setEnergyPerElement(-(capacity - stateOfCharge));
+						chargingRatio = -(capacity - stateOfCharge);
 						return capacity - stateOfCharge;
 					} else { // take all engery that is available
 						this.setEnergyPerElement(-energyWanted);
+						chargingRatio = -energyWanted;
 						return energyWanted;
 					}
 				}
@@ -115,17 +136,18 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 	}
 
 	public void stateOfChargeCalculation(){
-		System.out.println("stateofcharge" + getId()+ "before:" + stateOfCharge + " with incomming " + status + " " + getEnergyPerElement() );
+		System.out.println("stateofcharge" + getId()+ "before:" + stateOfCharge + " with incomming " + status + " after resi " + getEnergyPerElement() +" before resi "+ chargingRatio);
 		switch (status){
 			case COLLECT:
 			case EMIT:
-				stateOfCharge = stateOfCharge - getEnergyPerElement();
+				stateOfCharge = stateOfCharge - chargingRatio;
 				break;
 			default:
 		}
 		//TODO: fix for gui error comment out bottom if (not sure if side effects should work since storage gets disabled every iteration)
 		if(stateOfCharge <= 0 || stateOfCharge >= capacity){
 			status = Mode.STANDBY;
+			chargingRatio = 0;
 			setEnergyPerElement(0);
 		}
 		System.out.println("stateofcharge after:" + stateOfCharge + " now as " + status + " " + getEnergyPerElement() );

src/ui/controller/SimulationManager.java

@@ -92,26 +92,26 @@ public class SimulationManager {
 			list = calculateNetworks(minimumModel, timestep, leftOver);
 			for(MinimumNetwork net : list) {
 				//if there is storage and it is needed turn it on//TODO:!!!
-				if(!blackstartRunning() && !net.getStorageElementList().isEmpty()) {
-
-                    StorageProductionController SPC = new StorageProductionController(net.getStorageElementList()); //TODO: unschoen
-                    SPC.disableStorageDischarging(-1);
-
-                    //calc consuption and production
-                    float consumption = calculateConsumption(net);
-                    float production = calculateProduction(net);
-                    float difference = production - consumption;
-                    System.out.println("Consumption " + consumption);
-                    System.out.println("production " + production);
-                    System.out.println("Difference " + difference);
-
-                    if(difference > 0){
-                        SPC.enableStorageCharging(difference);
-                    }
-                    if(difference < 0){
-                        SPC.enableStorageDischarging(-difference);
-                    }
-                }
+//				if(!blackstartRunning() && !net.getStorageElementList().isEmpty()) {
+//
+//                    StorageProductionController SPC = new StorageProductionController(net.getStorageElementList()); //TODO: unschoen
+//                    SPC.disableStorageDischarging(-1);
+//
+//                    //calc consuption and production
+//                    float consumption = calculateConsumption(net);
+//                    float production = calculateProduction(net);
+//                    float difference = production - consumption;
+//                    System.out.println("Consumption " + consumption);
+//                    System.out.println("production " + production);
+//                    System.out.println("Difference " + difference);
+//
+//                    if(difference > 0){
+//                        SPC.enableStorageCharging(difference);
+//                    }
+//                    if(difference < 0){
+//                        SPC.enableStorageDischarging(-difference);
+//                    }
+//                }
 
 				float energyOnCables = net.getHolonObjectList()
 						.stream()
@@ -313,7 +313,7 @@ public class SimulationManager {
 	////////////////////////////////////////TODO:comments
 
 	public boolean blackstartRunning(){
-        for (HolonElement ele : getPowerPlant().getElements()) {
+        for (HolonElement ele : getPowerplant().getElements()) {
             if (ele.getEleName().equals("Blackstart")) {
                 if (ele.isActive()) {
                     return true;
@@ -325,9 +325,8 @@ public class SimulationManager {
         return false;
     }
 
-    public HolonObject getPowerPlant() {
+    public HolonObject getPowerplant() {
         for (AbstractCpsObject cps : model.getAllHolonObjectsOnCanvas()) {
-            // geht nur wenn nur ein power plant vorhanden ist
             if (cps instanceof HolonObject) {
                 if (cps.getObjName().equals("Power Plant")) {
                     return (HolonObject) cps;

src/ui/controller/StorageProductionController.java

@@ -7,32 +7,34 @@ import java.util.Collections;
 
 public class StorageProductionController {
 	private ArrayList<StorageElement> storages;
+	private float energyRequiredForPowerplantBlackstart;
 
-	public StorageProductionController(ArrayList<StorageElement> storages) {
+	public StorageProductionController(ArrayList<StorageElement> storages, float energyRequiredForPowerplantBlackstart) {
 		this.storages = storages;
+		this.energyRequiredForPowerplantBlackstart = energyRequiredForPowerplantBlackstart;
 	}
 
 	public float currentPossibleStorageProduction() {
 		float possibleEnergy = 0;
 		for (StorageElement so : storages) {
-			possibleEnergy += so.getPossibleProduction();
+			possibleEnergy += so.getPossibleProduction(energyRequiredForPowerplantBlackstart);
 		}
 		return possibleEnergy;
 	}
 
-	public float currentStorageProduction() {
-		float producedEnergy = 0;
-		for (StorageElement ele : storages) {
-			if (ele.getStatus().equals(StorageElement.Mode.EMIT)) {
-				// needed to no emit more than what is available
-				if(ele.getStateOfCharge() - ele.getEnergyPerElement() < 0){
-					ele.setEnergyPerElement(ele.getStateOfCharge());
-				}
-				producedEnergy += ele.getEnergyPerElement();
-			}
-		}
-		return producedEnergy;
-	}
+//	public float currentStorageProduction() {
+//		float producedEnergy = 0;
+//		for (StorageElement ele : storages) {
+//			if (ele.getStatus().equals(StorageElement.Mode.EMIT)) {
+//				// needed to no emit more than what is available
+//				if(ele.getStateOfCharge() - ele.getEnergyPerElement() < 0){
+//					ele.setEnergyPerElement(ele.getStateOfCharge());
+//				}
+//				producedEnergy += ele.getEnergyPerElement();
+//			}
+//		}
+//		return producedEnergy;
+//	}
 
 	public void enableStorageDischarging(final float energyNeeded) {
 		Collections.sort(storages, Collections.reverseOrder());
@@ -51,7 +53,7 @@ public class StorageProductionController {
 //						&& se.getEnergyPerElement() < se.getStateOfCharge())) {
                     // TODO: eventuell nach entfernung sortieren
 				if(!se.chargeDepleted()){
-					energyLeftToEnabled = energyLeftToEnabled - se.setStatusAndSetEnergy(StorageElement.Mode.EMIT, energyLeftToEnabled);
+					energyLeftToEnabled = energyLeftToEnabled - se.setStatusAndSetEnergy(StorageElement.Mode.EMIT, energyLeftToEnabled, energyRequiredForPowerplantBlackstart);
 				}
 //                }
 
@@ -69,7 +71,7 @@ public class StorageProductionController {
 	public void disableStorageDischarging(float energyNotNeeded) {
 		if(energyNotNeeded == -1) {
 			for (StorageElement se : storages) {
-				se.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0);
+				se.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0, energyRequiredForPowerplantBlackstart);
 			}
 		}
 //		float disabledEnergy = 0;
@@ -98,7 +100,7 @@ public class StorageProductionController {
 		float availableEnergyLeft = energyAvailable;
 		for (StorageElement se: storages) {
 			if(!se.fullyCharged()){
-				availableEnergyLeft = availableEnergyLeft - se.setStatusAndSetEnergy(StorageElement.Mode.COLLECT, availableEnergyLeft);
+				availableEnergyLeft = availableEnergyLeft - se.setStatusAndSetEnergy(StorageElement.Mode.COLLECT, availableEnergyLeft, energyRequiredForPowerplantBlackstart);
 			}
 			if(availableEnergyLeft <= 0){
 				System.out.println("storage charging");

src/ui/view/AddStorageElementPopUp.java

@@ -120,7 +120,7 @@ public class AddStorageElementPopUp extends JDialog {
         maxInRatio.setBounds(130, 90, 110, 20);
         contentPanel.add(maxInRatio);
 
-        JLabel lbloutRatio = new JLabel("maxInRatio in kW");
+        JLabel lbloutRatio = new JLabel("maxOutRatio in kW");
         lbloutRatio.setBounds(10, 130, 100, 20);
         contentPanel.add(lbloutRatio);
 
@@ -216,7 +216,7 @@ public class AddStorageElementPopUp extends JDialog {
                     hl.setEleName(elementName.getText());
                     hl.setAmount(elementAmount);
                     hl.setEnergyPerElement(0);
-                    hl.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0);
+                    hl.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0 ,0);
                 }
                 hl.setActive(checkBoxActive.isSelected());
                 dispose();