praktikum-holons/src/classes/HolonBattery.java

package classes;
import ui.model.Model;
import ui.controller.*;

public class HolonBattery extends AbstractCpsObject{
	
	private float inRatio;
	private float outRatio;
	private float capacity;
	private float initialStateOfCharge;
	private float stateOfCharge;
	private float newStateOfCharge;
	private float[] stateOfChargeLevels;
	private float iterations = 0;
	public enum State{STANDBY, COLLECT, EMIT};
	private State state;
	/** Constructor for a unique ID.
	 * @param ObjName
	 */
	public HolonBattery(String ObjName)
	{
		super(ObjName);
		inRatio = 0;
		outRatio = 0;
		capacity = 0;
		stateOfCharge = 0;
		newStateOfCharge = 0;
		initialStateOfCharge = 0;
		setState(State.STANDBY);
	}
	/** Constructor to Copy a Battery
	 * @param obj Object to copy.
	 */
	public HolonBattery(AbstractCpsObject obj)
	{
		super(obj);
		super.setName(obj.getName());
		setInRatio(((HolonBattery) obj).getInRatio());
		setOutRatio(((HolonBattery) obj).getOutRatio());
		setCapacity(((HolonBattery) obj).getCapacity());
		setStateOfCharge(((HolonBattery) obj).getStateOfCharge());
		setNewStateOfCharge(((HolonBattery) obj).getStateOfCharge());
		setInitialStateOfCharge(((HolonBattery) obj).getStateOfCharge());
		setState(State.STANDBY);
	}
	public float getStateOfCharge() {
		return stateOfCharge;
	}
	public void setStateOfCharge(float stateOfCharge) {
		this.stateOfCharge = validStateOfCharge(stateOfCharge);
	}
	public float getCapacity() {
	
		return capacity;
	}
	public void setCapacity(float capacity) {	
		if(capacity < 0) //capasity can not be negative
		{
			capacity = 0;
		}
		this.capacity = capacity;
	}
	public float getOutRatio() {
		return outRatio;
	}
	public void setOutRatio(float outRatio) {
		if(outRatio < 0) //
		{
			outRatio = 0;
		}
		this.outRatio = outRatio;
	}
	public float getInRatio() {
			return inRatio;
	}
	//For Calculations
	public float getInAtTimeStep(int x)
	{
		if(getCapacity() - getStateOfChargeAtTimeStep(x) < inRatio)
			return getCapacity() - getStateOfChargeAtTimeStep(x);
		else
			return inRatio;
	}
	public float getOutAtTimeStep(int x)
	{
		if(getStateOfChargeAtTimeStep(x) < outRatio)
			return getStateOfChargeAtTimeStep(x);
		else
			return outRatio;
	}
	public void setInRatio(float inRatio) {
		if(inRatio < 0)
		{
			inRatio = 0;
		}
		this.inRatio = inRatio;
	}
	public State getState() {
		return state;
	}
	public void setState(State state) {
		this.state = state;
	}

	/**
	 * @return The String that is over the Battery in the Canvas if COLLECT the
	 *         input if EMIT the output of the Battery
	 */
	public String getCanvasBatteryString()
	{
		/*
		switch(getState())
		{
		case COLLECT:
			return "-" + Float.toString(getIN());
		case EMIT:
			return "+" + Float.toString(getOUT());
		case STANDBY:
		default:
			return "0";
		}
		*/
		
		if(newStateOfCharge > stateOfCharge)
		{
			return "+" + Float.toString(newStateOfCharge - stateOfCharge);
		}
		else if (newStateOfCharge < stateOfCharge)
		{
			return Float.toString(newStateOfCharge - stateOfCharge); // '"-" +' not needed because negative
		}else
		{
			return "0";
		}
		
	}
	public String toString()
	{
		return "HolonBattery ID:" + this.getId() + " State:" + getState().name() 
				+ " InRatio:" + getInRatio() + " OutRatio:" + getOutRatio() 
				+ " Akku: " + getStateOfCharge() + "/" + getCapacity()
				+ " NewSOC: " + getNewStateOfCharge();
	}
	public float getNewStateOfCharge() {
		return newStateOfCharge;
	}
	public void setNewStateOfCharge(float newStateOfCharge) {
		this.newStateOfCharge = newStateOfCharge;
	}
	public void setStateOfChargeAtTimeStep(float newStateOfCharge, int x) {
		if(iterations != SingletonControl.getInstance().getControl().getModel().getIterations())
		{
			stateOfChargeLevels = new float[SingletonControl.getInstance().getControl().getModel().getIterations()];
			iterations = SingletonControl.getInstance().getControl().getModel().getIterations();
		}
		System.out.println( "Iterations:" + x);
	
		stateOfChargeLevels[x] = validStateOfCharge(newStateOfCharge);
		
		for(int i = 0; i < stateOfChargeLevels.length; i++)
		{
			System.out.println( i+":"+stateOfChargeLevels[i]+ ",");
		}
	}
	public float getStateOfChargeAtTimeStep(int x) {
		if(iterations != SingletonControl.getInstance().getControl().getModel().getIterations())
		{
			stateOfChargeLevels = new float[SingletonControl.getInstance().getControl().getModel().getIterations()];
			iterations = SingletonControl.getInstance().getControl().getModel().getIterations();
		}
		if(x < 0)
		{
			return initialStateOfCharge;
		}
		return stateOfChargeLevels[x];
	}
	public float getInitialStateOfCharge() {
		return initialStateOfCharge;
	}
	public void setInitialStateOfCharge(float initialStateOfCharge) {
		this.initialStateOfCharge = validStateOfCharge(initialStateOfCharge);
	}
	/** Correct if a state of charge is to big or to less
	 * @return a valid State of charge
	 */
	public float validStateOfCharge(float stateOfChargeToValid)
	{
		if(stateOfChargeToValid > capacity) //state of Charege can not more than the capacity
		{
			return capacity;
		}
		else if(stateOfChargeToValid < 0) // state of charge can not be a negativ value
		{
			return 0;
		}
		else
		{
			return stateOfChargeToValid;
		}
	}
}