2. version of blackstarting with resistance on the cables, now terminates properly

src/blackstart/controlAlgorithm.java

@@ -185,6 +185,7 @@ public class controlAlgorithm implements AddOn {
 	}
 
 	private void run() {
+		clear();
 		cancel = false;
 		disableGuiInput(true);
 		startTimer();
@@ -249,8 +250,9 @@ public class controlAlgorithm implements AddOn {
 				println("No Power Plant in Model");
 				return;
 			}
-			resistanceCalculator resistanceCalculator = new resistanceCalculator(control.getModel());
-			resistanceCalculator.setDistanceToCalcResistance(powerplant);
+			resistanceCalculator resistanceCalculator = new resistanceCalculator(230, 30, 0.017);//TODO
+			resistanceCalculator.setDistancesToCalcResistance(powerplant);
+//			println("bla" + resistanceCalculator.calcEnergyNeededForCertainEnergyAfterResistance(1750, 1000, 4000000));
 			blackstartRunningCounter = 0;
 			deactivateBlackstart();
 			control.getModel().setCurIteration(0);
@@ -397,6 +399,10 @@ public class controlAlgorithm implements AddOn {
 
 	private void enableConsumers(float energyAvailable) {
 		println("currenctrenewable: " + currentRenewableProduction());
+		for (StorageElement ele :
+				getStorageElements()) {
+			println("Storage ID: " + ele.getId() + " now at " + ele.getStateOfCharge() + " charge");
+		}
 		println("currenctpossiblestorage: " + SPC.currentPossibleStorageProduction());
 		println("blackstart resi: " + getEnergyRequiredForPowerplantBlackstart());
 		println("current pp production: " + getPowerplantProduction());

src/blackstart/resistanceCalculator.java

@@ -1,17 +1,27 @@
 package blackstart;
 
 import classes.*;
+import com.google.gson.annotations.Expose;
 import ui.model.Model;
 
 public class resistanceCalculator {
 
-    private Model model;
+    @Expose
+    private int voltage;
 
-    public resistanceCalculator(Model model){
-        this.model = model;
+    @Expose
+    private int diameter;
+
+    @Expose
+    private double specificMaterialResistance;
+
+    public resistanceCalculator(int voltage, int diameter, double specificMaterialResistance){
+        this.voltage = voltage;
+        this.diameter = diameter;
+        this.specificMaterialResistance = specificMaterialResistance;
     }
 
-    void setDistanceToCalcResistance(HolonObject powerPlant) {
+    void setDistancesToCalcResistance(HolonObject powerPlant) {
         if (powerPlant != null) {
             // travers
             if (powerPlant.getConnectedTo().size() > 0) {
@@ -59,13 +69,24 @@ public class resistanceCalculator {
     }
 
     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) / energyRequiredForPowerplantBlackstart;
-        double cableResistance = specificMaterialResistance * (distance / (0.25 * Math.PI * Math.pow(diameter, 2)));
+        double blackstartResistance = blackstartResistance(voltage, energyRequiredForPowerplantBlackstart);
+        double cableResistance = cableResistance(specificMaterialResistance, distance, diameter);
+
         return (float) (1 - (cableResistance / (cableResistance + blackstartResistance))) * currentEnergy;
     }
+
+    private double blackstartResistance(int voltage, float energyRequiredForPowerplantBlackstart){
+        return Math.pow(voltage, 2) / energyRequiredForPowerplantBlackstart;
+    }
+
+    private double cableResistance(double specificMaterialResistance, double distance, int diameter){
+        return specificMaterialResistance * (distance / (0.25 * Math.PI * Math.pow(diameter, 2)));
+    }
+
+    public float calcEnergyNeededForCertainEnergyAfterResistance(float energyWanted, double distance, float energyRequiredForPowerplantBlackstart){
+        double blackstartResistance = blackstartResistance(voltage, energyRequiredForPowerplantBlackstart);
+        double cableResistance = cableResistance(specificMaterialResistance, distance, diameter);
+
+        return (float) (energyWanted / (1 - (cableResistance / (cableResistance + blackstartResistance))));
+    }
 }

src/classes/StorageElement.java

@@ -36,7 +36,7 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 									// minutes//TODO:!
 		this.status = Mode.STANDBY;
 		this.chargingRatio = 0;
-		this.resistanceCalculator = new resistanceCalculator(model);
+		this.resistanceCalculator = new resistanceCalculator(230, 30, 0.017);//TODO
 	}
 
 	public float getEnergyPerElement() {
@@ -73,6 +73,7 @@ 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, float energyRequiredForPowerplantBlackstart) {
+		float energyNeed = resistanceCalculator.calcEnergyNeededForCertainEnergyAfterResistance(energyWanted, getDistance(), energyRequiredForPowerplantBlackstart);
 		this.status = status;
 		switch (status) {
 		case STANDBY:
@@ -86,16 +87,23 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 					chargingRatio = maxOutRatio;
 					return energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart);
 				} else { // less energy stored that can be given
-					return notEnoughChargedToEmitWantedEnergy();
+					return notEnoughChargedToEmitWantedEnergy(energyRequiredForPowerplantBlackstart);
 				}
-			} else {// less wanted than what can be given
-				if (stateOfCharge >= energyWanted) { // more energy stored than wanted
-					this.setEnergyPerElement(energyAfterResistance(energyWanted, energyRequiredForPowerplantBlackstart));
-					chargingRatio = energyWanted;
-					return energyAfterResistance(energyWanted, energyRequiredForPowerplantBlackstart);
-				} else { // less energy stored than wanted
-					return notEnoughChargedToEmitWantedEnergy();
+			} else {// less wanted than what can be max be given
+				if(stateOfCharge >= energyNeed){
+					this.setEnergyPerElement(energyAfterResistance(energyNeed, energyRequiredForPowerplantBlackstart));
+					chargingRatio = energyNeed;
+					return energyAfterResistance(energyNeed, energyRequiredForPowerplantBlackstart);
+				}else{
+					return notEnoughChargedToEmitWantedEnergy(energyRequiredForPowerplantBlackstart);
 				}
+//				if (stateOfCharge >= energyWanted) { // more energy stored than wanted
+//					this.setEnergyPerElement(energyAfterResistance(energyWanted, energyRequiredForPowerplantBlackstart));
+//					chargingRatio = energyWanted;
+//					return energyAfterResistance(energyWanted, energyRequiredForPowerplantBlackstart);
+//				} else { // less energy stored than wanted
+//					return notEnoughChargedToEmitWantedEnergy();
+//				}
 			}
 			case COLLECT://TODO: more testing
 			if (energyWanted >= maxInRatio) { // more engery given than can be collected
@@ -161,17 +169,20 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 		}
 	}
 
-	private float notEnoughChargedToEmitWantedEnergy(){
+	private float notEnoughChargedToEmitWantedEnergy(float energyRequiredForPowerplantBlackstart){
 		if(stateOfCharge <= 0){
 			this.status = Mode.STANDBY;
 			this.setEnergyPerElement(0);
 			return 0;
 		}else{
-			this.setEnergyPerElement(stateOfCharge);
-			return stateOfCharge;
+			this.setEnergyPerElement(energyAfterResistance(stateOfCharge, energyRequiredForPowerplantBlackstart));
+			chargingRatio = stateOfCharge;
+			return energyAfterResistance(stateOfCharge, energyRequiredForPowerplantBlackstart);
 		}
 	}
 
+
+
 	public float getStateOfCharge() {
 		return stateOfCharge;
 	}