praktikum-holons/src/ui/controller/StorageProductionController.java

package ui.controller;

import classes.StorageElement;

import java.util.ArrayList;
import java.util.Collections;

public class StorageProductionController {
	private ArrayList<StorageElement> storages;
	private float energyRequiredForPowerplantBlackstart;

	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(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 void enableStorageDischarging(final float energyNeeded) {
		Collections.sort(storages, Collections.reverseOrder());
//		System.out.println("energy needed from storage" + energyNeeded);
		int storagesLeft = storages.size();
        float energyLeftToEnabled = energyNeeded;
        	for (StorageElement se: storages) {
				if(!se.chargeDepleted()){
					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,energyNeeded);
                    return;
                }else if(storagesLeft <= 0){
                	System.out.println("nicht genug enabled");
				}
            }

	}

	public void setAllStorageToStandy() {
		for (StorageElement se : storages) {
			se.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0, energyRequiredForPowerplantBlackstart);
		}
	}

	//TODO: selbe probleme wie discharging
	void enableStorageCharging(float energyAvailable){
		Collections.sort(storages);
		System.out.println("energy available to storage" + energyAvailable);
		float availableEnergyLeft = energyAvailable;
		for (StorageElement se: storages) {
			if(!se.fullyCharged()){
				availableEnergyLeft = availableEnergyLeft - se.setStatusAndSetEnergy(
						StorageElement.Mode.COLLECT, availableEnergyLeft, energyRequiredForPowerplantBlackstart);
			}
			if(availableEnergyLeft <= 0){
				System.out.println("storage charging");
				return;
			}
		}
	}

	private void assessFitness(float w1, float w2, float w3, float energyNeeded){
		float fitness = 0f;

		fitness = w1 * distanceFitness() + w2 * supplyFitness(energyNeeded) + w3 * holdMaxPowerFitness();
		System.out.println("Fitness score: " + fitness);
	}

	private float distanceFitness(){//TODO: nicht lieber mit wiederstand?
		float distancePenalty = 0;
		for (StorageElement ele : storages) {
			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
				distancePenalty = goodDistance(ele);
			}
		}
		return distancePenalty;
	}

	private float goodDistance(StorageElement ele){
		if(avgDistance() < ele.getHighDistance() + ele.getLowDistance()){
			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)){
				totalDistance += ele.getHighDistance() + ele.getLowDistance();
			}
		}
		return totalDistance/activeStorages();
	}

	private float avgUtilization(){
		float totalUtilization = 0;
		for (StorageElement ele : storages) {
			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
				totalUtilization += ele.getUtilization();
			}
		}
		return totalUtilization/activeStorages();
	}

	private float activeStorages(){
		float activeStorages = 0;
		for (StorageElement ele : storages) {
			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
				activeStorages++;
			}
		}
		return activeStorages;
	}

	private float supplyFitness(float energyNeeded){
		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 holdMaxPowerFitness(){
		float couldNotHoldPower = 0;
		for (StorageElement ele : storages) {
			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
				couldNotHoldPower += maxPowerNextIteration(ele);
			}
		}
		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;
//	}
}