praktikum-holons/src/algorithm/objectiveFunction/TopologieObjectiveFunction.java

package algorithm.objectiveFunction;


import ui.model.DecoratedHolonObject;
import ui.model.DecoratedNetwork;
import ui.model.DecoratedState;
import ui.model.DecoratedSwitch;

import java.util.HashSet;
import java.util.Locale;
import algorithm.objectiveFunction.GraphMetrics.Graph;
import api.TopologieAlgorithmFramework.IndexCable;

public class TopologieObjectiveFunction {
	//Parameters
	
	//weight for f_g(H)
	static double w_eb = .3, w_max = 0.2, w_holon=.1, w_selection = .1, w_grid = .3;
	
	
	//--> f_eb parameter
	/**
	 * Maximum Energie Difference(kappa)
	 */
	static double k_eb = 100000.f;
	/**
	 * Maximum when all on Energie Difference(kappa)
	 */
	static double k_max = 100000.f;
	
	//--> f_holon parameter
	/**
	 * maximum penalty from holon flexibilities 
	 */
	static double k_holon= 200000;
	
	
	//--> f_selection paramaeter;
	/**
	 *  average Maximum Cost for selction(kappa) of switch and elements.
	 */
	static double k_selection = 4000;
	
	static double cost_switch = 10;
	private static int cost_of_cable_per_meter = 200;
	//--> f_grid parameter
	/**
	 * The avergae shortest path maximum length -> kappa for the squash function
	 */
	static double k_avg_shortest_path = 400;
	
	
	
	//pre-calculated parameters for partial function terms:
	/** 
	 * Pre calculated for the squash function
	 * <br>
	 *  {@link TopologieObjectiveFunction#squash}
	 */
	static double squash_subtract = 1.0f / (1.f + (float) Math.exp(5.0));


	
	
	static {
        //init
		checkParameter();
    }
	
	/**
	 * Check parameter Setting and print error when wrong values are put in.
	 * Here should all invariants be placed to be checked on initialization.
	 */
	private static void checkParameter() {
		if(!(Math.abs(w_eb + w_holon + w_selection + w_grid + w_max - 1) < 0.001)) {
			System.err.println("ParameterError in ObjectiveFunction: Sum of all weights should be 1");
		}
	}
	
	/**
	 * ObjectifeFunction by Carlos.
	 * Function computes f_g:
	 * f_g = w1 * squash(f_eb, k1) + w2 * squash(f_state, k2) + w3 * squash(f_pro, k3) + w4 * squash(f_perf, k4) + w5 * squash(f_holon, k5) 
	 * 
	 * 
	 * squash is the squashing function {@link TopologieObjectiveFunction#squash}
	 * 
	 * 
	 * @param state
	 * @param moreInformation TODO
	 * @return f_g value between 0 and 100
	 */
	static public float getFitnessValueForState(DecoratedState state, int amountOfAddedSwitch, double addedCableMeters, boolean moreInformation) {
		
		

		//Calculate f_eb the penalty for unbalenced energy in the network
		double f_eb = 0;
		for(DecoratedNetwork net : state.getNetworkList()) {
			double netEnergyDifference = 0;
			netEnergyDifference += net.getConsumerList().stream().map(con -> con.getEnergySelfSupplied() - con.getEnergyFromConsumingElemnets()).reduce(0.f, Float::sum);
			netEnergyDifference += net.getConsumerSelfSuppliedList().stream().map(con -> con.getEnergySelfSupplied() - con.getEnergyFromConsumingElemnets()).reduce(0.f, Float::sum);
			netEnergyDifference += net.getSupplierList().stream().map(sup -> sup.getEnergyProducing() - sup.getEnergySelfConsuming()).reduce(0.f, Float::sum);
			//abs
			f_eb += Math.abs(netEnergyDifference);
		}
		
		double f_maximum = 0;
		for(DecoratedNetwork net : state.getNetworkList()) {
			final int timestep = state.getTimestepOfState();
			f_maximum += Math.abs(net.getConsumerList().stream().map(con -> con.getModel().getMaximumConsumptionPossible(timestep)).reduce(0.f, Float::sum));
			f_maximum += Math.abs(net.getConsumerSelfSuppliedList().stream().map(con -> con.getModel().getMaximumConsumptionPossible(timestep)).reduce(0.f, Float::sum));
			f_maximum += Math.abs(net.getSupplierList().stream().map(con -> con.getModel().getMaximumConsumptionPossible(timestep)).reduce(0.f, Float::sum));
		}
		
		
		//calculate f_holon
		double f_holon = 0;
		for(DecoratedNetwork net : state.getNetworkList()) {
			double f_elements_diviation_production = net.getDiviationInProductionInNetworkForHolonObjects();
			double f_elements_diviation_consumption = net.getDiviationInProductionInNetworkForHolonObjects();
			double f_element = f_elements_diviation_production+f_elements_diviation_consumption;
			f_holon += f_element;
		}
		
		//calculating f_selection
		double f_selection = 0;
		double cost = 0;
		int amountOfElemetsInWildcard = 0;
		for(DecoratedNetwork net : state.getNetworkList()) {
			for(DecoratedHolonObject dHobject : net.getConsumerList()) {
				if(dHobject.getModel().getName().contains("Wildcard")){
					if(dHobject.getModel().getName().length() > 9) {
						String costString = dHobject.getModel().getName().substring(9);
						cost += Double.parseDouble(costString);
					}
				}
			}
<<<<<<< HEAD
			for(DecoratedHolonObject dHobject : net.getConsumerSelfSuppliedList()) {
=======
			for(DecoratedHolonObject dHobject : net.getConsumerList()) {
>>>>>>> refs/remotes/origin/updateInProgress
				if(dHobject.getModel().getName().contains("Wildcard")){
					if(dHobject.getModel().getName().length() > 9) {
						String costString = dHobject.getModel().getName().substring(9);
						cost += Double.parseDouble(costString);
					}
				}
			}
			for(DecoratedHolonObject dHobject : net.getSupplierList()) {
				if(dHobject.getModel().getName().contains("Wildcard")){
					if(dHobject.getModel().getName().length() > 9) {
						String costString = dHobject.getModel().getName().substring(9);
						cost += Double.parseDouble(costString);
					}
				}
			}
		}
		f_selection += cost;
		f_selection += cost_switch * amountOfAddedSwitch;
		
		
		f_selection += cost_of_cable_per_meter * addedCableMeters;
		if(moreInformation)System.out.println("CostForWildcards:" + cost + ", CostSwitches(#" + amountOfAddedSwitch +"):" + cost_switch * amountOfAddedSwitch + ", CostCables(" +addedCableMeters+ "m):" + cost_of_cable_per_meter * addedCableMeters);
		
		
		//calculating f_grid
		double f_grid = 0;
		//each network is a holon
		for(DecoratedNetwork net: state.getNetworkList()) {
			Graph G = GraphMetrics.convertDecoratedNetworkToGraph(net);
			//We have to penalize single Networks;
			if(G.V.length <= 1) {
				f_grid += 100;
				continue;
			}
			
			
			double avgShortestPath = GraphMetrics.averageShortestDistance(G.V,  G.E);
			double squached = squash(avgShortestPath, k_avg_shortest_path);
			//System.out.println("AVG:" + avgShortestPath + "  squached:" + squached);
			
			//k-edge-conneted
			int maximumK = G.V.length - 1;
			if(maximumK != 0) {
				int k = GraphMetrics.minimumCut(G.V, G.E);				
				double proportion = k/(double)maximumK;
				//System.out.println("proportion ("+ k+"/"+ maximumK+")=" + proportion);
				squached =  0.5 * squash(1.0-proportion, 1) + 0.5 *squached;
			}
			f_grid += squached;
		}
		if(!state.getNetworkList().isEmpty()) {
			f_grid /= state.getNetworkList().size();		
		}
		//System.out.println("f_grid:" + f_grid);
		
		
//		System.out.print(" f_eb(" + w_eb * squash(f_eb, k_eb) + ") ");
//		System.out.print(" f_holon(" + w_holon * squash(f_holon, k_holon)  + ") ");
//		System.out.print(" f_selection(" + w_selection * squash(f_selection, k_selection)  + ") ");
//		System.out.println(" f_grid(" + w_grid * f_grid + ") ");
		
		/**
		 * F_grid is already squashed
		 */
		return (float) (w_eb * squash(f_eb, k_eb) 
<<<<<<< HEAD
				+ w_max * squash(f_maximum, k_max) 
=======
				+ w_max * squash(f_holon, k_max) 
>>>>>>> refs/remotes/origin/updateInProgress
				+ w_holon * squash(f_holon, k_holon) 
				+ w_selection * squash(f_selection, k_selection) 
				+ w_grid * f_grid);
	}

	private static String doubleToString(double value) {
		return String.format (Locale.US, "%.2f", value);
	}
	
	
	
	
	
	/**
	 * The squashing function in paper
	 * @param x the input
	 * @param kappa the corresponding kappa
	 * @return
	 */
	static public double squash(double x, double kappa) {
		return 100.f/(1.0f + Math.exp(-(10.f * (x - kappa/2.f))/ kappa)) - squash_subtract;
	}
	
	/**
	 * f_sup in paper
	 * @param supply from 0 to 1
	 * @return
	 */
	static public double supplyPenalty(double supply) {
		double supplyPercentage = 100 * supply;
		//	double test = (supplyPercentage < 100) ? -0.5 * supplyPercentage + 50: supplyPercentage - 100;
		return (supplyPercentage < 100) ? -0.5 * supplyPercentage + 50: supplyPercentage - 100;
	}
	

}