battery scheduler now implemented

src/blackstart/ControlAlgorithm.java

@@ -343,7 +343,7 @@ public class ControlAlgorithm implements AddOn {
 			if (SPC.currentPossibleStorageProduction() >= getEnergyRequiredForPowerplantBlackstart()
 					- currentRenewableProduction()) {// is there currently enough power available from storage?
 				SPC.setAllStorageToStandy();//TODO: placement
-				SPC.enableStorageDischarging(getEnergyRequiredForPowerplantBlackstart() - currentRenewableProduction());
+				SPC.scheduleDischarging(getEnergyRequiredForPowerplantBlackstart() - currentRenewableProduction());
 				rampUpPowerplant();
 				enableConsumers(getPowerplantProduction());
 				return true;

src/ui/controller/StorageProductionController.java

@@ -4,7 +4,6 @@ import classes.StorageElement;
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.LinkedList;
 
 public class StorageProductionController {
 	private ArrayList<StorageElement> storages;
@@ -15,12 +14,8 @@ public class StorageProductionController {
 		this.energyRequiredForPowerplantBlackstart = energyRequiredForPowerplantBlackstart;
 	}
 
-	public float currentPossibleStorageProduction() {
-		float possibleEnergy = 0;
-		for (StorageElement ele : storages) {
-			possibleEnergy += ele.getPossibleProduction(energyRequiredForPowerplantBlackstart);
-		}
-		return possibleEnergy;
+	public double currentPossibleStorageProduction() {
+		return getPossibleProduction(storages);
 	}
 
 //	public float currentStorageProduction() {
@@ -50,7 +45,7 @@ public class StorageProductionController {
 //				storagesLeft = storagesLeft - 1;
                 if(energyLeftToEnabled <= 0){
                 	System.out.println("enabled energy from storage");
-					assessFitness(1,1,1,energyNeeded);
+//					assessFitness(1,1,1,energyNeeded);
                     return;
                 }/*else if(storagesLeft <= 0){
                 	System.out.println("nicht genug enabled");
@@ -82,46 +77,46 @@ public class StorageProductionController {
 		}
 	}
 
-	private void assessFitness(float w1, float w2, float w3, double energyNeeded){
-		double fitness = 0f;
-
-		fitness = w1 * distanceFitness(energyNeeded) + w2 * supplyFitness(energyNeeded) + w3 * holdMaxPowerFitness();
-		System.out.println("Fitness score: " + fitness);
-	}
-
-	private double distanceFitness(double energyNeeded){//TODO: nicht lieber mit wiederstand?
-		double distancePenalty = 0;
-		ArrayList<StorageElement> sortedElements = storages;
-		Collections.sort(sortedElements, Collections.reverseOrder());
-		for (StorageElement ele : sortedElements) {
-			if(!ele.chargeDepleted()){
-				if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
-					distancePenalty += goodDistance(energyNeeded ,ele);
-					energyNeeded -= ele.getEnergyPerElement();
-				}
-			}
-		}
-		return distancePenalty;
-	}
-
-	private double goodDistance(double energyNeeded, StorageElement ele){
-		if(energyNeeded <= 0){
-			return 0;
-		}
-		if(energyNeeded >= ele.getCurrentMaxOutRatio()){
-			if(ele.getChargingRatio() < ele.getCurrentMaxOutRatio()){
-				return Math.abs(ele.getCurrentMaxOutRatio() - ele.getChargingRatio());
-			}else{
-				return 0;
-			}
-		}else{
-			if(ele.getChargingRatio() < energyNeeded){
-				return Math.abs(energyNeeded - ele.getChargingRatio());
-			}else{
-				return 0;
-			}
-		}
-	}
+//	private void assessFitness(float w1, float w2, float w3, double energyNeeded){
+//		double fitness = 0f;
+//
+//		fitness = w1 * distanceFitness(energyNeeded) + w2 * supplyFitness(energyNeeded) + w3 * holdMaxPowerFitness();
+//		System.out.println("Fitness score: " + fitness);
+//	}
+//
+//	private double distanceFitness(double energyNeeded){//TODO: nicht lieber mit wiederstand?
+//		double distancePenalty = 0;
+//		ArrayList<StorageElement> sortedElements = storages;
+//		Collections.sort(sortedElements, Collections.reverseOrder());
+//		for (StorageElement ele : sortedElements) {
+//			if(!ele.chargeDepleted()){
+//				if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
+//					distancePenalty += goodDistance(energyNeeded ,ele);
+//					energyNeeded -= ele.getEnergyPerElement();
+//				}
+//			}
+//		}
+//		return distancePenalty;
+//	}
+//
+//	private double goodDistance(double energyNeeded, StorageElement ele){
+//		if(energyNeeded <= 0){
+//			return 0;
+//		}
+//		if(energyNeeded >= ele.getCurrentMaxOutRatio()){
+//			if(ele.getChargingRatio() < ele.getCurrentMaxOutRatio()){
+//				return Math.abs(ele.getCurrentMaxOutRatio() - ele.getChargingRatio());
+//			}else{
+//				return 0;
+//			}
+//		}else{
+//			if(ele.getChargingRatio() < energyNeeded){
+//				return Math.abs(energyNeeded - ele.getChargingRatio());
+//			}else{
+//				return 0;
+//			}
+//		}
+//	}
 
 //	private double produceTooMuch(StorageElement ele){
 //		if(avgUtilization() >= ele.getUtilization(energyRequiredForPowerplantBlackstart)){
@@ -169,35 +164,88 @@ public class StorageProductionController {
 //		return activeStorages;
 //	}
 
-	private double supplyFitness(double energyNeeded){
-		double activeStoragePower = 0;
+//	private double supplyFitness(double energyNeeded){
+//		double activeStoragePower = 0;
+//		for (StorageElement ele : storages) {
+//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
+//				activeStoragePower += ele.getEnergyPerElement();
+//			}
+//		}
+//		if((int) activeStoragePower + 1 < energyNeeded){
+//			return Math.pow(9000, 9000);//TODO:
+//		}else{
+//			return Math.abs(activeStoragePower - energyNeeded);
+//		}
+//	}
+//
+//	private double holdMaxPowerFitness(){
+//		double willNotHoldPower = 0;
+//		for (StorageElement ele : storages) {
+//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
+//				willNotHoldPower += maxPowerNextIteration(ele);
+//			}
+//		}
+//		return willNotHoldPower;
+//	}
+//
+//	private double maxPowerNextIteration(StorageElement ele){
+//		if(ele.getStateOfCharge() - ele.getChargingRatio() >= ele.getNominalOutRatio()){//TODO:
+//			return 0;
+//		}else{
+//			return ele.getNominalOutRatio() - (ele.getStateOfCharge() - ele.getChargingRatio());
+//		}
+//	}
+
+	public void scheduleDischarging(final double energyNeeded){
+		ArrayList<StorageElement> lowRisk = new ArrayList<StorageElement>();
+		ArrayList<StorageElement> highRisk = new ArrayList<StorageElement>();
+		
+		//vorsortieren
 		for (StorageElement ele : storages) {
-			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
-				activeStoragePower += ele.getEnergyPerElement();
+			if(ele.getStateOfCharge() - ele.getCurrentMaxOutRatio() < ele.getCurrentMaxOutRatio()
+			|| ele.getStateOfChargeInPercent() < 0.2){
+				if(!ele.chargeDepleted()){
+					highRisk.add(ele);
+				}
+			}else{
+				lowRisk.add(ele);
 			}
 		}
-		if((int) activeStoragePower + 1 < energyNeeded){
-			return Math.pow(9000, 9000);//TODO:
-		}else{
-			return Math.abs(activeStoragePower - energyNeeded);
+
+		double energyLeftToEnabled = energyNeeded;
+		//activate with lowRisk
+		for (StorageElement ele : lowRisk) {
+			energyLeftToEnabled = energyLeftToEnabled - ele.setStatusAndSetEnergy(
+					StorageElement.Mode.EMIT, energyLeftToEnabled, energyRequiredForPowerplantBlackstart);
+			if(energyLeftToEnabled <=0) {
+				return;
+			}
 		}
-	}
 
-	private double holdMaxPowerFitness(){
-		double willNotHoldPower = 0;
-		for (StorageElement ele : storages) {
-			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
-				willNotHoldPower += maxPowerNextIteration(ele);
+		double highRiskenable = 0;
+		//activate with highRisk
+		if(energyLeftToEnabled <=0){
+			return;
+		}else {
+			double possibleHighRiskProduction = getPossibleProduction(highRisk);
+
+
+			for (StorageElement ele : highRisk) {
+				highRiskenable = highRiskenable + ele.setStatusAndSetEnergy(
+						StorageElement.Mode.EMIT,
+						ele.getPossibleProduction(energyRequiredForPowerplantBlackstart)/possibleHighRiskProduction * energyLeftToEnabled,
+						energyRequiredForPowerplantBlackstart);
 			}
 		}
-		return willNotHoldPower;
+
+		System.out.println("energy left to enable = " + energyLeftToEnabled + " highrisk enable = "+ highRiskenable);
 	}
 
-	private double maxPowerNextIteration(StorageElement ele){
-		if(ele.getStateOfCharge() - ele.getChargingRatio() >= ele.getNominalOutRatio()){//TODO:
-			return 0;
-		}else{
-			return ele.getNominalOutRatio() - (ele.getStateOfCharge() - ele.getChargingRatio());
+	private double getPossibleProduction(ArrayList<StorageElement> list){
+		double production = 0;
+		for (StorageElement ele: list) {
+			production += ele.getPossibleProduction(energyRequiredForPowerplantBlackstart);
 		}
+		return production;
 	}
 }