next level fitness function

src/classes/StorageElement.java

@@ -96,7 +96,7 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 					return emitWantedEnergy(currentMaxOutRatio, energyRequiredForPowerplantBlackstart);
 				}
 			} else {// less wanted than what can be max be given
-				if(stateOfCharge >= energyNeed){
+				if(stateOfCharge >= energyNeed){//TODO: das kann doch garnicht funktioniern
 //					return emitWantedEnergy(energyNeed, energyRequiredForPowerplantBlackstart);//zurueckrechnungs problem! float nicht genau genug
 					this.setEnergyPerElement(energyWanted);
 					chargingRatio = energyNeed;
@@ -198,6 +198,10 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 		return energyAfterResistance;
 	}
 
+	public float getUtilization(){
+		return (getEnergyPerElement() * 100) / currentMaxOutRatio;
+	}
+
 	public float getStateOfCharge() {
 		return stateOfCharge;
 	}
@@ -219,7 +223,7 @@ public class StorageElement extends HolonElement implements Comparable<StorageEl
 	}
 
 	@Override
-	public int compareTo(StorageElement storageElement) {
+	public int compareTo(StorageElement storageElement) {//TODO:!!!
 		if(this.getPossiblePower() < storageElement.getPossiblePower()){
 			return 1;
 		}else if(this.getPossiblePower() > storageElement.getPossiblePower()){

src/ui/controller/StorageProductionController.java

@@ -43,12 +43,13 @@ public class StorageProductionController {
         float energyLeftToEnabled = energyNeeded;
         	for (StorageElement se: storages) {
 				if(!se.chargeDepleted()){
-					energyLeftToEnabled = energyLeftToEnabled - se.setStatusAndSetEnergy(StorageElement.Mode.EMIT, energyLeftToEnabled / storagesLeft, energyRequiredForPowerplantBlackstart);
+					energyLeftToEnabled = energyLeftToEnabled - se.setStatusAndSetEnergy(
+											StorageElement.Mode.EMIT, energyLeftToEnabled /*/ storagesLeft*/, energyRequiredForPowerplantBlackstart);
 				}
 				storagesLeft = storagesLeft - 1;
                 if(energyLeftToEnabled <= 0){
                 	System.out.println("enabled energy from storage");
-					assessFitness(1,1,1);
+					assessFitness(1,1,1,energyNeeded);
                     return;
                 }else if(storagesLeft <= 0){
                 	System.out.println("nicht genug enabled");
@@ -70,7 +71,8 @@ public class StorageProductionController {
 		float availableEnergyLeft = energyAvailable;
 		for (StorageElement se: storages) {
 			if(!se.fullyCharged()){
-				availableEnergyLeft = availableEnergyLeft - se.setStatusAndSetEnergy(StorageElement.Mode.COLLECT, availableEnergyLeft, energyRequiredForPowerplantBlackstart);
+				availableEnergyLeft = availableEnergyLeft - se.setStatusAndSetEnergy(
+						StorageElement.Mode.COLLECT, availableEnergyLeft, energyRequiredForPowerplantBlackstart);
 			}
 			if(availableEnergyLeft <= 0){
 				System.out.println("storage charging");
@@ -79,62 +81,120 @@ public class StorageProductionController {
 		}
 	}
 
-	private void assessFitness(float w1, float w2, float w3){
+	private void assessFitness(float w1, float w2, float w3, float energyNeeded){
 		float fitness = 0f;
 
-		fitness = w1 * distanceFitness() + w2 * distributionFitness() + w3 * participationFitness();
+		fitness = w1 * distanceFitness() + w2 * supplyFitness(energyNeeded) + w3 * holdMaxPowerFitness();
 		System.out.println("Fitness score: " + fitness);
 	}
 
-	private float distanceFitness(){
+	private float distanceFitness(){//TODO: nicht lieber mit wiederstand?
-		int activeStorage = 0;
+		float distancePenalty = 0;
-		float distance = 0;
 		for (StorageElement ele : storages) {
 			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
-				distance = (float) (distance + ele.getHighDistance() + ele.getLowDistance());
+				distancePenalty = goodDistance(ele);
-				activeStorage++;
 			}
 		}
-		return distance / activeStorage /1000;
+		return distancePenalty;
 	}
 
-	private float distributionFitness(){
+	private float goodDistance(StorageElement ele){
-		int emptyStorage = 0;
+		if(avgDistance() < ele.getHighDistance() + ele.getLowDistance()){
-		int activeStorage = 0;
+			return produceTooMuch(ele);
+		}else{
+			return produceTooLittle(ele);
+		}
+	}
+
+	private float produceTooMuch(StorageElement ele){
+		if(avgUtilization() <= ele.getUtilization()){
+			return 0;
+		}else{
+			return 1;
+		}
+	}
+
+	private float produceTooLittle(StorageElement ele){
+		if(avgUtilization() >= ele.getUtilization()){
+			return 0;
+		}else{
+			return 1;
+		}
+	}
+
+	private float avgDistance(){
+		float totalDistance = 0;
 		for (StorageElement ele : storages) {
 			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
-				activeStorage++;
+				totalDistance += ele.getHighDistance() + ele.getLowDistance();
 			}
-			if(ele.chargeDepleted()){
+		}
-				emptyStorage++;
+		return totalDistance/activeStorages();
+	}
+
+	private float avgUtilization(){
+		float totalUtilization = 0;
+		for (StorageElement ele : storages) {
+			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
+				totalUtilization += ele.getUtilization();
 			}
 		}
-		return storages.size()- emptyStorage - activeStorage;
+		return totalUtilization/activeStorages();
 	}
 
-	private float participationFitness(){
+	private float activeStorages(){
-		float participation = 0;
+		float activeStorages = 0;
 		for (StorageElement ele : storages) {
-				participation = participation +
+			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
-						Math.abs(
+				activeStorages++;
-								(storageEnergy(ele)/totalEnergy())
+			}
-										-(ele.getEnergyPerElement()/ele.getPossibleProduction(energyRequiredForPowerplantBlackstart))
-						);
 		}
-		return participation;
+		return activeStorages;
 	}
 
-	private float storageEnergy(StorageElement ele){
+	private float supplyFitness(float energyNeeded){
-		return ele.getStateOfCharge();
+		int activeStoragePower = 0;
+		for (StorageElement ele : storages) {
+			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
+				activeStoragePower += ele.getEnergyPerElement();
+			}
+		}
+		if(activeStoragePower < energyNeeded){
+			return (float) Math.pow(9000, 9000);//TODO:
+		}else{
+			return activeStoragePower - energyNeeded;
+		}
 	}
 
-	private float totalEnergy(){
+	private float holdMaxPowerFitness(){
-		float energy = 0;
+		float couldNotHoldPower = 0;
 		for (StorageElement ele : storages) {
-			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
+			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
-				energy = energy + storageEnergy(ele);
+				couldNotHoldPower += maxPowerNextIteration(ele);
 			}
 		}
-		return  energy;
+		return couldNotHoldPower;
 	}
+
+	private float maxPowerNextIteration(StorageElement ele){
+		if(ele.getStateOfCharge() - ele.getEnergyPerElement() >= ele.getCurrentMaxOutRatio()){//TODO:
+			return 0;
+		}else{
+			return (float) Math.pow(2, ele.getStateOfCharge() - ele.getEnergyPerElement());
+		}
+	}
+
+//	private float storageEnergy(StorageElement ele){
+//		return ele.getStateOfCharge();
+//	}
+//
+//	private float totalEnergy(){
+//		float energy = 0;
+//		for (StorageElement ele : storages) {
+//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
+//				energy = energy + storageEnergy(ele);
+//			}
+//		}
+//		return  energy;
+//	}
 }