praktikum-holons/src/algo/TestAlgo.java

package algo;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

import javax.swing.*;

import algo.StorageElement.Mode;
import api.AddOn;
import classes.*;
import ui.controller.Control;

public class TestAlgo implements AddOn {
	private boolean cancel = false;

	// Parameter defined by Algo
	private HashMap<Integer, AccessWrapper> access;
	private List<Boolean> initialState;

	// Gui Part:
	private Control control;
	private JTextArea textArea;
	private JPanel content = new JPanel();
	// ProgressBar
	private JProgressBar progressBar = new JProgressBar();
	private long startTime;
	private Thread runThread;

	// Blackstart Resistance in Watt
	private HolonObject powerPlant;

	private TextField blackstartResistanceTextfield;
	private TextField blackstartSuccessTimeTextfield;
	private TextField powerplantMaxOutputTextfield;
	private TextField blackstartStartTimeTextfield;
	private TextField simulationDurationTextfield;

	private int blackstartSuccessTime;
	private int blackstartStartTime;
	private int blackstartRunningCounter;
	private float powerplantMaxOutput;
	private List<HolonObject> renewableProducers;
	private List<HolonObject> consumers;
	private StorageProductionController SPC;

	public static void main(String[] args) {
		JFrame newFrame = new JFrame("exampleWindow");
		TestAlgo instance = new TestAlgo();
		newFrame.setContentPane(instance.getPanel());
		newFrame.pack();
		newFrame.setVisible(true);
		newFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}

	public TestAlgo() {
		content.setLayout(new BorderLayout());

		textArea = new JTextArea();
		textArea.setEditable(false);
		JScrollPane scrollPane = new JScrollPane(textArea);
		JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, createOptionPanel(), scrollPane);
		splitPane.setResizeWeight(0.0);
		content.add(splitPane, BorderLayout.CENTER);
		content.setPreferredSize(new Dimension(800, 800));
	}

	public JPanel createOptionPanel() {
		JPanel optionPanel = new JPanel(new BorderLayout());
		JScrollPane scrollPane = new JScrollPane(createParameterPanel());
		scrollPane.setBorder(BorderFactory.createTitledBorder("Parameter"));
		optionPanel.add(scrollPane, BorderLayout.CENTER);
		optionPanel.add(createButtonPanel(), BorderLayout.PAGE_END);
		return optionPanel;
	}

	private Component createParameterPanel() {
		JPanel parameterPanel = new JPanel(null);
		parameterPanel.setPreferredSize(new Dimension(510, 300));

		blackstartResistanceTextfield = new TextField("5000000");
		blackstartResistanceTextfield.setBounds(10, 10, 170, 20);
		parameterPanel.add(blackstartResistanceTextfield);

		JLabel blackstartResistanceLabel = new JLabel("Blackstart resistance in Watt");
		blackstartResistanceLabel.setBounds(185, 10, 300, 20);
		parameterPanel.add(blackstartResistanceLabel);

		blackstartSuccessTimeTextfield = new TextField("30");
		blackstartSuccessTimeTextfield.setBounds(10, 35, 170, 20);
		parameterPanel.add(blackstartSuccessTimeTextfield);

		JLabel blackstartSuccessTimeLabel = new JLabel("Time for successfull blackstart in minutes(iterations)");
		blackstartSuccessTimeLabel.setBounds(185, 35, 300, 20);
		parameterPanel.add(blackstartSuccessTimeLabel);

		blackstartStartTimeTextfield = new TextField("15");
		blackstartStartTimeTextfield.setBounds(10, 60, 170, 20);
		parameterPanel.add(blackstartStartTimeTextfield);

		JLabel blackstartStartTimeLabel = new JLabel("Starttime for the blackstart");
		blackstartStartTimeLabel.setBounds(185, 60, 300, 20);
		parameterPanel.add(blackstartStartTimeLabel);

		simulationDurationTextfield = new TextField("500");// TODO:!
		simulationDurationTextfield.setBounds(10, 85, 170, 20);
		parameterPanel.add(simulationDurationTextfield);

		JLabel simulationDurationLabel = new JLabel("How long should the simulation run?");
		simulationDurationLabel.setBounds(185, 85, 300, 20);
		parameterPanel.add(simulationDurationLabel);

		powerplantMaxOutputTextfield = new TextField("40000000");
		powerplantMaxOutputTextfield.setBounds(10, 110, 170, 20);
		parameterPanel.add(powerplantMaxOutputTextfield);

		JLabel powerplantMaxOutputLabel = new JLabel("Powerplant Output afer Blackstart");
		powerplantMaxOutputLabel.setBounds(185, 110, 300, 20);
		parameterPanel.add(powerplantMaxOutputLabel);

//		JButton selectGroupNodeButton = new JButton("Select GroupNode");
//		selectGroupNodeButton.setEnabled(false);
//		selectGroupNodeButton.setBounds(10, 25, 165, 20);
//		selectGroupNodeButton.addActionListener(actionEvent -> selectGroupNode());
//		borderPanel.add(selectGroupNodeButton);

//		JCheckBox useGroupNodeCheckBox = new JCheckBox();
//		useGroupNodeCheckBox.setSelected(false);
//		useGroupNodeCheckBox.setBounds(155, 1, 25, 20);
//		useGroupNodeCheckBox.addActionListener(actionEvent -> {
//			useGroupNode = useGroupNodeCheckBox.isSelected();
//			selectGroupNodeButton.setEnabled(useGroupNode);
//		});
//		borderPanel.add(useGroupNodeCheckBox);

		return parameterPanel;
	}

	public JPanel createButtonPanel() {
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		JButton cancelButton = new JButton("Cancel Run");
		cancelButton.addActionListener(actionEvent -> cancel());
		buttonPanel.add(cancelButton);
		JButton clearButton = new JButton("Clear Console");
		clearButton.addActionListener(actionEvent -> clear());
		buttonPanel.add(clearButton);
		JButton resetButton = new JButton("Reset");
		resetButton.setToolTipText("Resets the State to before the Algorithm has runed.");
		resetButton.addActionListener(actionEvent -> reset());
		buttonPanel.add(resetButton);
		JButton runButton = new JButton("Run");
		runButton.addActionListener(actionEvent -> {
			Runnable task = () -> run();
			runThread = new Thread(task);
			runThread.start();
		});
		buttonPanel.add(runButton);
		return buttonPanel;
	}

	private void cancel() {
		if (runThread.isAlive()) {
			println("");
			println("Cancel run.");
			cancel = true;
			progressBar.setValue(0);
		} else {
			println("Nothing to cancel.");
		}
	}

	private void run() {
		cancel = false;
		disableGuiInput(true);
		startTimer();
		initAlgo();
		if (cancel) {
			reset();
			disableGuiInput(false);
			return;
		}
		printElapsedTime();
		disableGuiInput(false);
	}

	private void reset() {
		if (initialState != null) {
			println("Resetting..");
			resetState();
			updateVisual();
		} else {
			println("No run inistialized.");
		}
	}

	private void disableGuiInput(boolean bool) {
		control.guiDisable(bool);
	}

	@Override
	public JPanel getPanel() {
		return content;
	}

	@Override
	public void setController(Control control) {
		this.control = control;
	}

	private void clear() {
		textArea.setText("");
	}

	private void print(String message) {
		textArea.append(message);
	}

	private void println(String message) {
		textArea.append(message + "\n");
	}

	private void startTimer() {
		startTime = System.currentTimeMillis();
	}

	private void printElapsedTime() {
		long elapsedMilliSeconds = System.currentTimeMillis() - startTime;
		println("Execution Time of Algo in Milliseconds:" + elapsedMilliSeconds);
	}

	///////////////////////////////////////////////////////////////////////////////////
	/**
	 * 
	 */
	private void initAlgo() {
		try {

			// init
			SPC = new StorageProductionController(getStorageElements());// DANGER DONT GIVE NULL
			renewableProducers = getRenewableProducers();
			consumers = getConsumers();
			powerPlant = getPowerPlant();// DANGER DONT GIVE NULL
			if(powerPlant == null){
				println("No Power Plant in Model");
				return;
			}
			calcResistance();
			blackstartRunningCounter = 0;
			deactivateBlackstart();
			control.getModel().setCurIteration(0);

			// prepare model
			/////////
			setPowerplantProduction(0);
			enableAllConsumers();
//			StorageElement ele = new StorageElement("Storage", 1, 0, control.getModel());
//			ele.setStatusAndSetEnergy(Mode.EMIT, 5000);
//			
//			System.out.println(""+ele.getEnergyPerElement());
//			powerPlant.addElement(ele);
			
//			for (HolonElement elem : powerPlant.getElements()) {
//				if(elem instanceof StorageElement) {
//					println("boom");
//				}
//			}
			// TODO: prios?
			/////////

			// Get parameters from textfields
			setPowerPlantBlackstartResistance(-Float.parseFloat(blackstartResistanceTextfield.getText()));
			blackstartSuccessTime = Integer.parseInt(blackstartSuccessTimeTextfield.getText());
			powerplantMaxOutput = Float.parseFloat(powerplantMaxOutputTextfield.getText());
			blackstartStartTime = Integer.parseInt(blackstartStartTimeTextfield.getText());
			control.getModel().setIterations(Integer.parseInt(simulationDurationTextfield.getText()));

			updateVisual();
			if (blackstartStartTime + blackstartSuccessTime > control.getModel().getIterations() - 1) {
				println("No Time for the blackstart, use working numbers");
			} else {
				blackstartMain(control.getModel().getCurIteration());
			}
		} catch (NumberFormatException e) {
			println("Worng Input, only numbers please");
		}
	}

	/**
	 * 
	 * @param curIteration
	 */
	private void blackstartMain(int curIteration) {
//		try {
//			Thread.sleep(1000);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		control.getModel().setCurIteration(curIteration);
		if (blackstartRunning()) {
			if (!blackstartAlgo(curIteration)) {
				// blackstart for this iteration was not successfull
				deactivateBlackstart();
				updateVisual();
				println("Simulation of blackstart failed in Iteration: " + curIteration);
			} else {
				// blackstart for this iteration was successfull
				blackstartRunningCounter++;
				if (blackstartRunningCounter == blackstartSuccessTime) {
					// blackstart was successfull for the needed iterations
					deactivateBlackstart();
					enableAllConsumers();
					updateVisual();
					println("Simulation of blackstart Successfull in Iteration: " + curIteration);
				} else {
					// blackstart not finished yet
					updateVisual();
					blackstartMain(curIteration + 1);
				}
			}
		} else {
			// blackstart has not started yet
			if (curIteration == blackstartStartTime) {
				activateBlackstart();
				disableConsumers();
				blackstartMain(curIteration);
			} else {
				updateVisual();
				blackstartMain(curIteration + 1);
			}

		}
	}

	/**
	 * TODO:HOLEG UNTERVERSORGUNG CHECKEN
	 * 
	 * @param curIteration
	 * @return true or false depending on whether the blackstart was successful for
	 *         this iteration
	 */
	private boolean blackstartAlgo(int curIteration) {
		if (currentRenewableProduction() < getPowerPlantBlackstartResistance()) {
			// renewable energy production is not sufficient for the blackstart
			if (SPC.currentPossibleStorageProduction() >= getPowerPlantBlackstartResistance()
					- currentRenewableProduction()) {// is there currently enough power available from storage?
				SPC.enableStorageProduction(getPowerPlantBlackstartResistance() - currentRenewableProduction());
				rampUpPowerplant();
				enableConsumers(getPowerplantProduction());
				return true;
			} else {
				// blackstart has failed
				println("Not enough storage energy available");
				return false;
			}
		} else {
			// renewable energy production is sufficient for the blackstart
			rampUpPowerplant();
			enableConsumers(
					currentRenewableProduction() - getPowerPlantBlackstartResistance() + getPowerplantProduction());
			return true;
		}
	}

	private HolonObject getPowerPlant() {
		for (AbstractCpsObject cps : control.getModel().getObjectsOnCanvas()) {
			// geht nur wenn nur ein power plant vorhanden ist
			if (cps instanceof HolonObject) {
				if (cps.getObjName().equals("Power Plant")) {
					return (HolonObject) cps;
				}
			}
		}
		return null;
	}

	private ArrayList<StorageElement> getStorageElements() {
		ArrayList<StorageElement> storageElements = new ArrayList<StorageElement>();
		for (HolonObject holonObject : control.getModel().getAllHolonObjectsOnCanvas()) {
//			if(holonObject.getName().contentEquals("House")) {
//				holonObject.addElement(new StorageElement("Storage", 1, 0, control.getModel()));
//			}
			for (HolonElement ele : holonObject.getElements()) {				
				if (ele.getEleName().equals("Storage")) {
					println(ele.getEleName() + "is : " + ele.getClass());
					if (ele instanceof StorageElement) {
						println("boomboomboomboom");
					}
				}
			}
		}
		return storageElements;
	}

	private void calcResistance() {

		if (powerPlant != null) {
//			println("Powerplant Energy @"+powerPlant.getEnergyAtTimeStep(1));
//			println("" + getPowerplantProduction());

			// travers
			if (powerPlant.getConnectedTo().size() > 0) {
				for (CpsEdge edge : powerPlant.getConnectedTo()) {
//					println(edge.toString());
					if (powerPlant.getId() == edge.getA().getId()) {
						traversEdges(edge.getB(), powerPlant, calcEdgeLength(edge));
					} else {
						traversEdges(edge.getA(), powerPlant, calcEdgeLength(edge));
					}
				}
			} else {
				println("Nothing connected to powerplant");
			}
		} else {
			println("No powerplant connected");
		}
	}

	private void traversEdges(AbstractCpsObject currentObject, AbstractCpsObject last, double distance) {
		if (currentObject.getConnectedTo().size() > 1) { // recursive call for all edges
			for (CpsEdge edge : currentObject.getConnectedTo()) {
				if (currentObject.getId() == edge.getA().getId()) { // look at which way the edge points
					if (last.getId() != edge.getB().getId()) {
						traversEdges(edge.getB(), currentObject, distance + calcEdgeLength(edge));
					}
				} else {
					if (last.getId() != edge.getA().getId()) {
						traversEdges(edge.getA(), currentObject, distance + calcEdgeLength(edge));
					}
				}
			}
		} else { // at leaf
//			println("Distance to " + currentObject.getId() + ": " + distance);
//			((HolonObject) currentObject).addElement(new StorageElement("Storage", 1, 0, control.getModel()));
			for (HolonElement ele : ((HolonObject) currentObject).getElements()) {
				if (ele.isProducer()) {
					ele.setEnergyPerElement(5000);// TODO: das wollen wir ja so nicht
//					println("Energy: " + ele.getEnergyPerElement());
					// set how much energy is left after resistance22
					ele.setEnergyPerElement(calcEnergyAfterResistance(ele.getEnergyPerElement(), distance));// TODO: das
																											// wollen
																											// wir ja so
																											// auch
																											// nicht
//					println("Energy after resistance: " + ele.getEnergyPerElement());
				}
			}
		}
	}

	private float calcEnergyAfterResistance(float currentEnergy, double distance) {
		// 230v kupfer 30mm durchmesser
		int volatage = 230;
		int diameter = 30;
		// kupfer
		double specificMaterialResistance = 0.017;
		double blackstartResistance = Math.pow(volatage, 2) / getPowerPlantBlackstartResistance();
		double cableResistance = specificMaterialResistance * (distance / (0.25 * Math.PI * Math.pow(diameter, 2)));
		return (float) (1 - (cableResistance / (cableResistance + blackstartResistance))) * currentEnergy;
	}

	private double calcEdgeLength(CpsEdge edge) {
		Position aPos = edge.getA().getPosition();
		Position bPos = edge.getB().getPosition();
		double xDiff = Math.abs(aPos.x - bPos.x);
		double yDiff = Math.abs(aPos.y - bPos.y);
		return Math.sqrt(Math.pow(xDiff, 2) + Math.pow(yDiff, 2));
	}

	private void disableConsumers() {
		// TODO: disableBatteryLoading? will ich das wirklich?
		// SPC.disableStorageProduction();

		for (HolonObject consumer : consumers) {
			for (HolonElement ele : consumer.getElements()) {
				if (ele.isActive() && ele.isConsumer()) {
					ele.setActive(false);
				}
			}
		}
	}

	private void enableConsumers(float energyAvailable) {
		println("currenctrenewable: " + currentRenewableProduction());
		println("currenctpossiblestorage: " + SPC.currentPossibleStorageProduction());
		println("blackstart resi: " + getPowerPlantBlackstartResistance());
		println("current pp production: " + getPowerplantProduction());
		println("energy available for consumers" + energyAvailable);

//		Damit wir immer die gleiche ausgangslage haben //TODO: wirklich?
		disableConsumers();

		// TODO: das ganze lieber mit prirotaeten
		for (HolonObject consumer : consumers) {
			for (HolonElement ele : consumer.getElements()) {
				if (energyAvailable > 0
						&& energyAvailable - Math.abs(ele.getEnergyPerElement() * ele.getAmount()) >= 0) {
					if (!ele.isActive()) {
						ele.setActive(true);
						energyAvailable = energyAvailable - Math.abs(ele.getEnergyPerElement() * ele.getAmount());// +
																													// since
																													// its
																													// negative
//						System.out.println("Element " + ele.getId() + " was enabled Energy left: "+ energyAvailable);
					}
				} else {
					return;
				}
			}
		}

//		if (!SPC.batteriesFull()) {
//			// TODO: load unused batteries
//		} else {
//
//		}
	}

	private void enableAllConsumers() {
		for (HolonObject consumer : consumers) {
			for (HolonElement ele : consumer.getElements()) {
				if (!ele.isActive() && ele.isConsumer()) {
					ele.setActive(true);
				}
			}
		}
	}

	private float currentRenewableProduction() {
		float production = 0;
		for (HolonObject house : renewableProducers) {
			for (HolonElement ele : house.getElements()) {
				if (ele.getEleName().equals("Solar Panels")) {// TODO: hier muss noch mehr dazu
					production = production + ele.getEnergyAtTimeStep(control.getModel().getCurIteration());
				}
			}
		}

		return production;
	}

	private void rampUpPowerplant() {
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Power")) {
				ele.setEnergyPerElement(ele.getEnergyPerElement() + powerplantMaxOutput / blackstartSuccessTime);
			}
		}
	}

	private float getPowerplantProduction() {
		float totalProduction = 0;
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Power")) {
				totalProduction = ele.getEnergyPerElement();
			}
		}
		return totalProduction;
	}

	private float setPowerplantProduction(float power) {
		float totalProduction = 0;
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Power")) {
				ele.setEnergyPerElement(power);
			}
		}
		return totalProduction;
	}

	private float getPowerPlantBlackstartResistance() {
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Blackstart")) {
				return -ele.getEnergyPerElement();
			}
		}
		return 0;
	}

	private void setPowerPlantBlackstartResistance(float resistance) {
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Blackstart")) {
				ele.setEnergyPerElement(resistance);
			}
		}
	}

	private boolean blackstartRunning() {
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Blackstart")) {
				if (ele.isActive()) {
					return true;
				} else {
					return false;
				}
			}
		}
		return false;
	}

	private void activateBlackstart() {
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Blackstart")) {
				ele.setActive(true);
			}
		}
	}

	private void deactivateBlackstart() {
		for (HolonElement ele : powerPlant.getElements()) {
			if (ele.getEleName().equals("Blackstart")) {
				ele.setActive(false);
			}
		}
	}

	private LinkedList<HolonObject> getRenewableProducers() {
		LinkedList<HolonObject> list = new LinkedList<HolonObject>();
		for (HolonObject holonObject : control.getModel().getAllHolonObjectsOnCanvas()) {
			if (holonObject.getObjName().contentEquals("House")) {// TODO: das reicht so nicht da muss noch gecheckt
																	// werden ob es renewables gibt
				list.add(holonObject);
			}
		}
		return list;
	}

	private LinkedList<HolonObject> getConsumers() {
		LinkedList<HolonObject> list = new LinkedList<HolonObject>();
		for (HolonObject holonObject : control.getModel().getAllHolonObjectsOnCanvas()) {
			if (holonObject.getObjName().contentEquals("House")) {// TODO: das reicht so nicht da muss noch gecheckt
																	// werden ob es consumer gibt
				list.add(holonObject);
			}
		}
		return list;
	}

	/**
	 * To let the User See the current state without touching the Canvas.
	 */
	private void updateVisual() {
		System.out.println("Start updateVisual in Iteration: " + control.getModel().getCurIteration());
		control.calculateStateAndVisualForCurrentTimeStep();
		control.updateCanvas();
		System.out.println("Finish updateVisual in Iteration: " + control.getModel().getCurIteration());
	}

	/**
	 * Sets the Model back to its original State before the LAST run.
	 */
	private void resetState() {
		setState(initialState);
	}

	/**
	 * Sets the State out of the given position for calculation or to show the user.
	 * 
	 * @param position
	 */
	private void setState(List<Boolean> position) {
		for (int i = 0; i < position.size(); i++) {
			access.get(i).setState(position.get(i));
		}
	}

	/**
	 * A Wrapper Class for Access HolonElement and HolonSwitch in one Element and
	 * not have to split the List.
	 */
	private class AccessWrapper {
		public static final int HOLONELEMENT = 0;
		public static final int SWITCH = 1;
		private int type;
		private HolonSwitch hSwitch;
		private HolonElement hElement;

		public AccessWrapper(HolonSwitch hSwitch) {
			type = SWITCH;
			this.hSwitch = hSwitch;
		}

		public AccessWrapper(HolonElement hElement) {
			type = HOLONELEMENT;
			this.hElement = hElement;
		}

		public void setState(boolean state) {
			if (type == HOLONELEMENT) {
				hElement.setActive(state);
			} else {// is switch
				hSwitch.setManualMode(true);
				hSwitch.setManualState(state);
			}

		}

		public boolean getState(int timeStep) {
			return (type == HOLONELEMENT) ? hElement.isActive() : hSwitch.getState(timeStep);
		}

		public int getType() {
			return type;
		}
	}

	private class Handle<T> {
		public T object;

		Handle(T object) {
			this.object = object;
		}

		public String toString() {
			return object.toString();
		}
	}
}