praktikum-holons/src/psoAlgoCode/PSO.java

package psoAlgoCode;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.EmptyBorder;

import api.CpsAlgorithm;
import classes.AbstractCpsObject;
import classes.CpsUpperNode;
import classes.HolonElement;
import classes.HolonObject;
import classes.HolonSwitch;
import ui.controller.Control;
import ui.model.Model;

public class PSO implements CpsAlgorithm {
	static Coordinate<Vector<Object>> startPos;
	

	static SimplePSO pso;

	@Override
	public void runAlgorithm(Model model, Control controller) {
		startPos = extractInfo(model, controller);
		pso = new SimplePSO(model, controller, startPos);
		callPopUp(model, controller);
	}

	/**
	 * Returns a binary representation of the current state of the network based on the state of the switches and holon elements
	 * @param model the overall model of the network
	 * @param controller the general controller
	 * @return Coordinate<Vector<Object>> where the first coordinate contains all switches states and the second coordinate all states of holon elements
	 */
	public static Coordinate<Vector<Object>> extractInfo(Model model, Control controller) {
		Coordinate<Vector<Object>> information = new Coordinate<Vector<Object>>();
		// First only for Switches configuration
		Vector<Object> temp = new Vector<Object>();
		for (int i = 0; i < model.getSwitches().size(); i++) {
			temp.add(model.getSwitches().get(i).getState());
		}
		information.setCoord(temp, 0);
		temp = new Vector<Object>();
		ArrayList<AbstractCpsObject> canvas_objects = model.getObjectsOnCanvas();
		for (int i = 0; i < canvas_objects.size(); i++) {
			if (canvas_objects.get(i) instanceof HolonObject) {
				HolonObject obj = ((HolonObject) canvas_objects.get(i));
				ArrayList<HolonElement> obj_elements = obj.getElements();
				for (int j = 0; j < obj_elements.size(); j++) {
					temp.add(obj_elements.get(j).isActive());
				}
			}
			else {
				if(canvas_objects.get(i) instanceof CpsUpperNode) {
					CpsUpperNode tmp = (CpsUpperNode) canvas_objects.get(i);
					ArrayList<AbstractCpsObject> upperNodecontent = tmp.getNodes();
					for( int j = 0; j < upperNodecontent.size(); j++) {
						
						//Does not work for recursiveness of more than two levels!!!!
						if (upperNodecontent.get(j) instanceof HolonObject) {
							HolonObject obj = ((HolonObject) upperNodecontent.get(j));
							for (int k = 0; k < obj.getElements().size(); k++) {
								temp.add(obj.getElements().get(k).isActive());
							}
						}
					}
				}
			}
		}
		information.setCoord(temp, 1);
		System.out.println("Information received: " + information.toString());
		return information;
	}

	/**
	 * Applies the best configuration of the run on the model to make it visible on the canvas
	 * @param bestConfig
	 * @param model
	 * @param controller
	 */
	public static void applyBestConfig(Coordinate<Vector<Object>> bestConfig, Model model, Control controller) {
		System.out.println("Applying configuration: " + bestConfig.toString());
		System.out.println("Config size: " + bestConfig.getCoord(1).size());
		Vector<Object> switchstates = bestConfig.getCoord(0);
		Vector<Object> elementstates = bestConfig.getCoord(1);

		for (int i = 0; i < model.getSwitches().size(); i++) {
			model.getSwitches().get(i).setManualMode(true);
			model.getSwitches().get(i).setManualState((boolean) switchstates.get(i));
		}
		int position = 0;
		for (int j = 0; j < model.getObjectsOnCanvas().size(); j++) {
			if (model.getObjectsOnCanvas().get(j) instanceof HolonObject) {
				for (int h = 0; h < ((HolonObject) model.getObjectsOnCanvas().get(j)).getElements().size(); h++) {
					((HolonObject) model.getObjectsOnCanvas().get(j)).getElements().get(h)
							.setActive((boolean) elementstates.get(position));
					position++;
				}
			}
			else {
				//Does not work for more than two recursive levels... seperate function recommended
				if(model.getObjectsOnCanvas().get(j) instanceof CpsUpperNode) {
					CpsUpperNode tmp = (CpsUpperNode) model.getObjectsOnCanvas().get(j);
					for( int k = 0; k < tmp.getNodes().size(); k++) {
						if (tmp.getNodes().get(k) instanceof HolonObject) {
							HolonObject obj = ((HolonObject) tmp.getNodes().get(k));
							for (int l = 0; l < obj.getElements().size(); l++) {
								obj.getElements().get(l).setActive((boolean) elementstates.get(position));
								position++;

							}
						}
					}
				}
			}
		
		}
		controller.calculateStateForCurrentTimeStep();
	}

	
	/*
	 * Write stuff to file. Needs to get completely restructured.
	 */
	public static void printChart(SimplePSO pso, PrintWriter out) {
		int rounds = Constants.ROUNDS;
		Vector<Double> record = null;
		String name = "";
		
	//	while (rounds <= Constants.ROUNDS) {
			//name = pso.getNameOfFunc();
			record = pso.getGBRecord();
			out.println(record.toString());
			//System.out.println("Global best of the round " + rounds + " is " + record.lastElement());
			//chart.createDataSet(record, rounds);
			out.flush();
			//rounds++;
		//}
		
		out.close();

	
		//chart.setTitle("Simple PSO - " + name);
		//chart.plotStuff("Iterations: " + Constants.MAX_ITERATION);
		//chart.setVisible(true);
		
	}

	/**
	 * Unnecessary popup that is currently used to control the PSO runs, but should be replaced in the future
	 * @param model
	 * @param controller
	 */
	public static void callPopUp(Model model, Control controller) {
		System.out.println("Repeat");
		// Declaration
		JDialog popUp = new JDialog();
		JPanel panel = new JPanel();
		JPanel buttonPanel = new JPanel();

		// Setup
		popUp.setTitle("Particle Swarm Optimization (PSO)");
		popUp.setBounds(100, 100, 500, 300);
		popUp.setModal(true);
		popUp.getContentPane().setLayout(new BorderLayout());
		panel.setBorder(new EmptyBorder(5, 5, 5, 5));
		popUp.getContentPane().add(panel, BorderLayout.CENTER);
		panel.setLayout(null);
		buttonPanel.setLayout(new FlowLayout(FlowLayout.RIGHT));
		popUp.getContentPane().add(buttonPanel, BorderLayout.SOUTH);

		// Names and Labels
		JLabel title1 = new JLabel("Tune the variables of the PSO algorithm in order to reach better results.");
		title1.setBounds(10, 10, 480, 15);
		JLabel swarmSizeText = new JLabel("Swarm Size:");
		swarmSizeText.setBounds(20, 60, 100, 20);
		JLabel maxItText = new JLabel("Max. Iterations:");
		maxItText.setBounds(20, 85, 100, 20);
		JLabel rmuText = new JLabel("Limit:");
		rmuText.setBounds(20, 110, 100, 20);
		JLabel phiText = new JLabel("Dependency:");
		phiText.setBounds(20, 135, 100, 20);
		final JLabel iteration = new JLabel();
		iteration.setBounds(20, 185, 110, 20);
		JLabel counterIt = new JLabel("Repetitions:");
		counterIt.setBounds(20, 155, 110, 20);
		JLabel infoGraph = new JLabel("Show Diagnostic:");
		infoGraph.setBounds(200, 60, 110, 20);
		JLabel infoText1 = new JLabel(
				"Caution: High values in the fields of 'Swarm Size' and 'Max. Iteration' may take some time to calculate.");
		infoText1.setFont(new Font("Serif", Font.ITALIC, 10));
		infoText1.setBounds(10, 210, 480, 15);

		// Input boxes
		JTextField swarmSizeIn = new JTextField();
		swarmSizeIn.setText("" + Constants.SWARM_SIZE);
		swarmSizeIn.addKeyListener(new KeyListener() {
			@Override
			public void keyPressed(KeyEvent arg0) {
			}

			@Override
			public void keyReleased(KeyEvent e) {
			}

			@Override
			public void keyTyped(KeyEvent e) {
				swarmSizeIn.setBackground(Color.WHITE);
			}
		});
		swarmSizeIn.setBounds(125, 60, 50, 20);
		swarmSizeIn.setColumns(10);

		JTextField maxItIn = new JTextField();
		maxItIn.setText("" + Constants.MAX_ITERATION);
		maxItIn.addKeyListener(new KeyListener() {
			@Override
			public void keyPressed(KeyEvent arg0) {
			}

			@Override
			public void keyReleased(KeyEvent e) {
			}

			@Override
			public void keyTyped(KeyEvent e) {
				maxItIn.setBackground(Color.WHITE);
			}
		});
		maxItIn.setBounds(125, 85, 50, 20);
		maxItIn.setColumns(10);

		JTextField rmuIn = new JTextField();
		rmuIn.setText("" + Constants.RMU);
		rmuIn.addKeyListener(new KeyListener() {
			@Override
			public void keyPressed(KeyEvent arg0) {
			}

			@Override
			public void keyReleased(KeyEvent e) {
			}

			@Override
			public void keyTyped(KeyEvent e) {
				rmuIn.setBackground(Color.WHITE);
			}
		});
		rmuIn.setBounds(125, 110, 50, 20);
		rmuIn.setColumns(10);

		JTextField phiIn = new JTextField();
		phiIn.setText("" + Constants.PHI);
		phiIn.addKeyListener(new KeyListener() {
			@Override
			public void keyPressed(KeyEvent arg0) {
			}

			@Override
			public void keyReleased(KeyEvent e) {
			}

			@Override
			public void keyTyped(KeyEvent e) {
				phiIn.setBackground(Color.WHITE);
			}
		});
		phiIn.setBounds(125, 135, 50, 20);
		phiIn.setColumns(10);
		
		
		JTextField runs = new JTextField();
		runs.setText("");
		runs.addKeyListener(new KeyListener() {
			@Override
			public void keyPressed(KeyEvent arg0) {
			}

			@Override
			public void keyReleased(KeyEvent e) {
			}

			@Override
			public void keyTyped(KeyEvent e) {
				phiIn.setBackground(Color.WHITE);
			}
		});
		runs.setBounds(125, 155, 50, 20);
		runs.setColumns(10);

		// Buttons
		JButton run = new JButton("Run");
		run.setActionCommand("Run");
		JButton nextIt = new JButton("Reset");
		nextIt.setActionCommand("Next It.");
		JCheckBox graph = new JCheckBox();
		graph.setSelected(true);
		graph.setBounds(320, 60, 25, 20);

		// Buttons action
		run.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				Constants.setSwarmSize(Integer.parseInt(swarmSizeIn.getText()));
				Constants.setMaxIt(Integer.parseInt(maxItIn.getText()));
				Constants.setRMU(Double.parseDouble(rmuIn.getText()));
				Constants.setPhi(Double.parseDouble(phiIn.getText()));
				int nr_runs = Integer.parseInt(runs.getText());
				
				double overallRecord= Float.MAX_VALUE;
				Coordinate<Vector<Object>> currentBestConfig = startPos;
				
				
				File f = new File("gb_singlerun.txt");
				PrintWriter out = null;
				
				
				try {
					if(f.exists() && !f.isDirectory()) {
						
						out = new PrintWriter(new FileOutputStream(new File("gb_singlerun.txt"),true));
					}else out = new PrintWriter("gb_singlerun.txt");
					
					//printChart(pso, out);
					out.println(""+ Constants.MAX_ITERATION +"," + nr_runs +"," + Constants.SWARM_SIZE);
					out.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				
				
				for(int i =0; i<nr_runs; i++) {
				//applyBestConfig(startPos, model, controller);
					System.out.println("Startpos size:" + startPos.getCoord(1).size() + " in " + i + " : " + startPos.toString() );
				pso = new SimplePSO(model, controller, startPos);
				
				long startTime = System.currentTimeMillis();
				
				pso.caclSimplePSO(model, controller, startPos);
				
				long endTime = System.currentTimeMillis();
				System.out.println("Computation time is: " + (endTime - startTime));
				//HelpFunctions.runRepairConnections(model);
				controller.addTextToConsole("Global best is " + pso.getGBRecord().get(Constants.MAX_ITERATION - 1));
				//applyBestConfig(pso.getBestConfig(), model, controller);
				if(pso.getGBRecord().get(Constants.MAX_ITERATION-1) < overallRecord) {
					overallRecord = pso.getGBRecord().get(Constants.MAX_ITERATION-1);
					currentBestConfig = pso.getBestConfig();
				}
				
				
				try {
					if(f.exists() && !f.isDirectory()) {
						
						out = new PrintWriter(new FileOutputStream(new File("gb_singlerun.txt"),true));
					}else out = new PrintWriter("gb_singlerun.txt");
					
					//printChart(pso, out);
					out.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				//if (graph.isSelected()) {
				applyBestConfig(startPos, model, controller);
	
				}
				applyBestConfig(currentBestConfig, model, controller);
				controller.addTextToConsole(
						"Best of all is " + overallRecord);
				
				//popUp.dispose();
			}
		});

		nextIt.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				applyBestConfig(startPos, model, controller);
				/*	iteration.setText("Current Iteration:");
				Constants.setSwarmSize(Integer.parseInt(swarmSizeIn.getText()));
				Constants.setMaxIt(Integer.parseInt(maxItIn.getText()));
				Constants.setRMU(Double.parseDouble(rmuIn.getText()));
				Constants.setPhi(Double.parseDouble(phiIn.getText()));
				
				PrintWriter out;
			
				pso.caclNextItSimplePSO(model, controller, startPos);
				counterIt.setText("" + pso.getIteration());
				HelpFunctions.runRepairConnections(model);
				controller.addTextToConsole(
						"Best of this " + pso.getIteration() + " is " + pso.getGBRecord().get(pso.getIteration() - 1));
				applyBestConfig(pso.getBestConfig(), model, controller);
				//PrintWriter out;
				try {
					out = new PrintWriter(new FileWriter("gb_singlerun.txt"));
					printChart(pso, out);
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
					popUp.dispose();*/
				
			}
		});

		// Add to the panel
		panel.add(title1);
		panel.add(swarmSizeText);
		panel.add(maxItText);
		panel.add(rmuText);
		panel.add(phiText);
		buttonPanel.add(run);
		buttonPanel.add(nextIt);
		panel.add(swarmSizeIn);
		panel.add(maxItIn);
		panel.add(infoText1);
		panel.add(iteration);
		panel.add(counterIt);
		panel.add(infoGraph);
		panel.add(graph);
		panel.add(phiIn);
		panel.add(rmuIn);
		panel.add(runs);

		popUp.setVisible(true);
	}

}