praktikum-holons/src/holeg/algorithm/objective_function/Evaluation.java

package holeg.algorithm.objective_function;

import holeg.model.Flexibility;
import holeg.model.Holon;
import holeg.model.HolonObject;
import holeg.model.HolonObject.HolonObjectState;
import holeg.model.HolonElement.Priority;
import holeg.model.Model;

import java.util.List;

public class Evaluation {
	
	/**
	 * Calculate the Fitness(Penelty) Value for a state (alias the calculated Position).
	 * @return
	 */
	public static double getFitnessValueForState(Model model) {
		double fitness = 0.0;
		double nw_fitness =0.0;
		double object_fitness = 0.0;
		double flexFitness = 0.0;
		
		double sigma = 9;

		// calculate network_fitness
		for(Holon holon : model.holons) {
			float production = holon.getTotalProduction();
			float consumption = holon.getTotalConsumption();
			nw_fitness += Math.abs((production - consumption)/100); //Energy is now everywhere positive
		}



		// calculate object_fitness
		for(Holon holon : model.holons) {

			object_fitness += holon.holonObjects.stream().filter(HolonObject::isConsumer).map(con -> holonObjectSupplyPenaltyFunction(con.getSupplyBarPercentage()) /*+ inactiveHolonElementPenalty(con.getModel())*/).reduce(0.0, Double::sum);
			object_fitness += holon.holonObjects.stream().filter(HolonObject::isConsumer).map(con -> StateToDouble(con.getState())).reduce(0.0, Double::sum);
		}
		List<Flexibility> getAllFlexInUse = model.getAllFlexibilities().stream().filter(flex -> flex.getState().equals(Flexibility.FlexState.IN_USE)).toList();
		for(Flexibility flex : getAllFlexInUse) {
			flexFitness += Math.pow(sigma, (double)priorityToInt(flex.getElement().getPriority())) - 1;
		}

		fitness = nw_fitness + object_fitness + flexFitness;
		return fitness;
	}

	
	
	
	
	private static int priorityToInt(Priority priority) {
		switch(priority) {
		case Essential:
			return 3;
		case High:
			return 2;
		case Medium:
			return 1;
		case Low:
		default:		
			return 0;
		}
	}





	/**
	 * Untouched:
	 * Function that returns the fitness depending on the number of elements deactivated in a single holon object
	 * @param obj Holon Object that contains Holon Elements
	 * @return fitness value for that object depending on the number of deactivated holon elements
	 */
	@SuppressWarnings("unused")
	private static double inactiveHolonElementPenalty(HolonObject obj) {
		float result = 0;
		int activeElements = obj.getNumberOfActiveElements();
		int maxElements = (int)obj.elementsStream().count();
		
		//result = (float) Math.pow((maxElements -activeElements),2)*10;
		result = (float) Math.pow(5, 4* ( (float) maxElements - (float) activeElements)/ (float) maxElements) - 1;
		//System.out.console.println("max: " + maxElements + " active: " + activeElements + " results in penalty: " + result);
	return result;
		
	}
	/**
	 * Untouched:
	 * Calculates a penalty value based on the HOs current supply percentage
	 * @param supplyPercentage
	 * @return
	 */
	private static double holonObjectSupplyPenaltyFunction(float supplyPercentage) {
		double result = 0;
		/*if(supplyPercentage == 1)
			return result;
		else if(supplyPercentage < 1 && supplyPercentage >= 0.25) // undersupplied inbetween 25% and 100%
			result = (float) Math.pow(1/supplyPercentage, 2);
		else if (supplyPercentage < 0.25) //undersupplied with less than 25%
			result = (float) Math.pow(1/supplyPercentage,2);
		else if (supplyPercentage < 1.25)  //Oversupplied less than 25%
			result = (float) Math.pow(supplyPercentage,3) ;
		else result = (float) Math.pow(supplyPercentage,4); //Oversupplied more than 25%
		
		
		if(Float.isInfinite(result) || Float.isNaN(result))
			result = 1000;
	*/
		if(supplyPercentage <= 1.0) {
			result = Math.pow(5,(Math.abs((100 - (supplyPercentage*100)))/50 + 2)) - Math.pow(5, 2);
		}
		else {
			result = Math.pow(6,(Math.abs((100 - (supplyPercentage*100)))/50 + 2)) - Math.pow(6, 2);
		}
		
		return result;
	}
	/**
	 * If you want to get in touch with a reliable state? Working function not in use currently.
	 * @param state
	 * @return
	 */
	private static double StateToDouble(HolonObjectState state) {
		switch (state) {
		case NOT_SUPPLIED:
			return 150.0;
		case NO_ENERGY:
			return 150.0;
		case OVER_SUPPLIED:
			return 100.0;
		case PARTIALLY_SUPPLIED:
			return 100.0;
		case PRODUCER:
			return 0;
		case SUPPLIED:
			return 0;
		default:
			return 0;
		}
	}
}