praktikum-holons/src/classes/StorageElement.java

package classes;

import blackstart.resistanceCalculator;
import com.google.gson.annotations.Expose;
import ui.model.Model;

public class StorageElement extends HolonElement implements Comparable<StorageElement> {

	@Expose
	private Mode status;
	
	@Expose
	private float stateOfCharge;
	
	@Expose
	private float capacity;
	
	@Expose
	private float maxInRatio;
	
	@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;
		this.maxInRatio = maxInRatio;
		this.maxOutRatio = maxOutRatio;
		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(230, 30, 0.017);//TODO
	}

	public float getEnergyPerElement() {
		if (status == Mode.STANDBY) {
			return 0;
		}
		return this.energyPerElement;
	}

	public float getPossibleProduction(float energyRequiredForPowerplantBlackstart) {
		if (stateOfCharge > 0) {
			if (stateOfCharge >= maxOutRatio) {
				return energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart);
			} else {
				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
	 * @param energyWanted float how much energy is needed from storage/ can be collected
	 *               by the storage
	 * @return float how much energy was collected/emited
	 */

	//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:
			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(energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart));
					chargingRatio = maxOutRatio;
					return energyAfterResistance(maxOutRatio, energyRequiredForPowerplantBlackstart);
				} else { // less energy stored that can be given
					return notEnoughChargedToEmitWantedEnergy(energyRequiredForPowerplantBlackstart);
				}
			} 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
				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;
					}
				}
			}
		default:
			System.out.println("no status available");
			return 0;
		}
	}

	public Mode getStatus() {
		return this.status;
	}

	public void stateOfChargeCalculation(){
		System.out.println("stateofcharge" + getId()+ "before:" + stateOfCharge + " with incomming " + status + " after resi " + getEnergyPerElement() +" before resi "+ chargingRatio);
		switch (status){
			case COLLECT:
			case EMIT:
				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() );
	}

	public void setStateOfCharge(float stateOfCharge){
		if(stateOfCharge < capacity){
			this.stateOfCharge = stateOfCharge;
		}else{
			this.stateOfCharge = capacity;
		}
	}

	private float notEnoughChargedToEmitWantedEnergy(float energyRequiredForPowerplantBlackstart){
		if(stateOfCharge <= 0){
			this.status = Mode.STANDBY;
			this.setEnergyPerElement(0);
			return 0;
		}else{
			this.setEnergyPerElement(energyAfterResistance(stateOfCharge, energyRequiredForPowerplantBlackstart));
			chargingRatio = stateOfCharge;
			return energyAfterResistance(stateOfCharge, energyRequiredForPowerplantBlackstart);
		}
	}



	public float getStateOfCharge() {
		return stateOfCharge;
	}

	public float getMaxOutRatio() {
		return maxOutRatio;
	}

	public boolean chargeDepleted(){
		return stateOfCharge <= 0;
	}

	public boolean fullyCharged(){
		return stateOfCharge >= capacity;
	}

	@Override
	public int compareTo(StorageElement storageElement) {
		if(this.stateOfCharge < storageElement.getStateOfCharge()){
			return -1;
		}else if(this.stateOfCharge > storageElement.getStateOfCharge()){
			return 1;
		}else{
			return 0;
		}
	}

	public enum Mode {
		COLLECT, EMIT, STANDBY
	}
}