|
@@ -2,27 +2,18 @@ package holeg.algorithm.objective_function;
|
|
|
|
|
|
import java.util.logging.Logger;
|
|
|
|
|
|
+import holeg.model.Flexibility;
|
|
|
+import holeg.model.Holon;
|
|
|
import holeg.model.HolonElement.Priority;
|
|
|
+import holeg.model.HolonObject;
|
|
|
import holeg.model.Model;
|
|
|
|
|
|
public class ObjectiveFunctionByCarlos {
|
|
|
// Parameters
|
|
|
private static final Logger log = Logger.getLogger(ObjectiveFunctionByCarlos.class.getName());
|
|
|
- // weight for f_g(H)
|
|
|
static double w_eb = .3, w_state = .3, w_pro = .2, w_perf = .1, w_holon = .1;
|
|
|
- // killswitch weights
|
|
|
- // static double w_eb = 0.5, w_state = 0.5, w_pro = 0.0f, w_perf = .0,
|
|
|
- // w_holon=.0;
|
|
|
-
|
|
|
- // kappas for squashing function
|
|
|
-//
|
|
|
- // static double k_eb = 1050000.f, k_state = 10000, k_pro = 2000, k_perf =
|
|
|
- // 11000, k_holon= 150000;
|
|
|
-// oversupplied
|
|
|
- static double k_eb = 750000.f, k_state = 20000, k_pro = 3000, k_perf = 15000, k_holon = 200000;
|
|
|
|
|
|
-// old values undersupplied
|
|
|
-// static double k_eb = 1000000.f, k_state = 15000, k_pro = 2100, k_perf = 12000, k_holon= 200000;
|
|
|
+ static double k_eb = 750000.f, k_state = 20000, k_pro = 3000, k_perf = 15000, k_holon = 200000;
|
|
|
|
|
|
// theta for f_pro
|
|
|
static double theta = 3;
|
|
@@ -76,87 +67,75 @@ public class ObjectiveFunctionByCarlos {
|
|
|
*
|
|
|
* @return f_g value between 0 and 100
|
|
|
*/
|
|
|
- //TODO(Tom2022-01-13) Fix ObjectiveFunctionByCarlos
|
|
|
static public double getFitnessValueForState(Model model) {
|
|
|
|
|
|
-// // Calculate f_eb the penalty for unbalenced energy in the network
|
|
|
-// double f_eb = 0;
|
|
|
-// // sum over all objects
|
|
|
-// 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);
|
|
|
-// }
|
|
|
-//
|
|
|
-// // Calculate f_state the penalty function for the supply state
|
|
|
-// double f_state = 0;
|
|
|
-// for (DecoratedNetwork net : state.getNetworkList()) {
|
|
|
-// f_state += net.getConsumerList().stream().map(con -> supplyPenalty(con.getSupplyBarPercentage())).reduce(0.,
|
|
|
-// Double::sum);
|
|
|
-// }
|
|
|
-//
|
|
|
-// // calculate f_pro the penalty function for priority usage
|
|
|
-// // for each active flexibility punish
|
|
|
-//
|
|
|
-// List<Flexibility> allFlexOrdered = state.getAllFlex().filter(flex -> flex.getState().equals(FlexState.IN_USE))
|
|
|
-// .toList();
|
|
|
-// double f_pro = 0;
|
|
|
-// f_pro = allFlexOrdered.stream()
|
|
|
-// .map(flex -> Math.pow(theta, priorityToDouble(flex.getElement().getPriority())) - 1.0)
|
|
|
-// .reduce(0.0, Double::sum);
|
|
|
-//
|
|
|
-// // calculate f_perf the penalty function for the quality of a flexibility used
|
|
|
-//
|
|
|
-// // and the subfuction f_unre, f_cool, f_dur
|
|
|
-// double f_perf = 0;
|
|
|
-// for (Flexibility flex : allFlexOrdered) {
|
|
|
-// double f_unre = unresponsivnessPenalty(flex.getSpeed());
|
|
|
-// double f_cool = cooldownPenalty(flex.getCooldown());
|
|
|
-// double f_dur = durationPenalty(flex.getDuration());
|
|
|
-// f_perf += f_unre + f_cool + f_dur;
|
|
|
-// }
|
|
|
-//
|
|
|
-// // calculate f_holon
|
|
|
-// double f_holon = 0;
|
|
|
-// for (DecoratedNetwork net : state.getNetworkList()) {
|
|
|
-// double f_elements_diviation_production = net.getDeviationInProductionInNetworkForHolonObjects();
|
|
|
-// double f_elements_diviation_consumption = net.getDeviationInProductionInNetworkForHolonObjects();
|
|
|
-// double f_flexibility_diviation_consumption = net.getDiviationInFlexibilityConsumption();
|
|
|
-// double f_flexibility_diviation_production = net.getDiviationInFlexibilityProduction();
|
|
|
-//
|
|
|
-// double con = net.getTotalConsumption();
|
|
|
-// double prod = net.getTotalProduction();
|
|
|
-// double flexcapProd = net.getFlexibilityProductionCapacity();
|
|
|
-// double flexcapCon = net.getFlexibilityConsumptionCapacity();
|
|
|
-// double f_change_positive = lambda_f_change
|
|
|
-// - lambda_f_change * Math.min(1, (con > 0.0) ? flexcapProd / con : 1.0);
|
|
|
-// double f_change_negativ = lambda_f_change
|
|
|
-// - lambda_f_change * Math.min(1, (prod > 0.0) ? flexcapCon / prod : 1.0);
|
|
|
-//
|
|
|
-// double f_element = f_elements_diviation_production + f_elements_diviation_consumption;
|
|
|
-// double f_flexibility = f_flexibility_diviation_consumption + f_flexibility_diviation_production;
|
|
|
-// double f_change = f_change_positive + f_change_negativ;
|
|
|
-//
|
|
|
-// f_holon += f_element + f_flexibility + f_change;
|
|
|
-// }
|
|
|
-// double q1 = squash(f_eb, k_eb);
|
|
|
-// double q2 = squash(f_state, k_state);
|
|
|
-// double q3 = squash(f_pro, k_pro);
|
|
|
-// double q4 = squash(f_perf, k_perf);
|
|
|
-// double q5 = squash(f_holon, k_holon);
|
|
|
-// log.finer("f_eb= " + f_eb + " f_state= " + f_state + " f_pro= " + f_pro + " f_perf= " + f_perf + " f_holon= "
|
|
|
-// + f_holon + " q1= " + q1 + " q2= " + q2 + " q3= " + q3 + " q4= " + q4 + " q5= " + q5);
|
|
|
-//
|
|
|
-// return w_eb * q1 + w_state * q2 + w_pro * q3 + w_perf * q4 + w_holon * q5;
|
|
|
- return 0;
|
|
|
+ // Calculate f_eb the penalty for unbalenced energy in the network
|
|
|
+ double f_eb = 0;
|
|
|
+ // sum over all objects
|
|
|
+ for (Holon holon : model.holons) {
|
|
|
+ double netEnergyDifference = holon.holonObjects.stream().map(hO -> Math.abs(hO.getActualEnergy())).reduce(0.0f, Float::sum);
|
|
|
+ f_eb += netEnergyDifference;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Calculate f_state the penalty function for the supply state
|
|
|
+ double f_state = 0;
|
|
|
+ for (Holon holon : model.holons) {
|
|
|
+ f_state += holon.holonObjects.stream().filter(hO -> hO.getState() != HolonObject.HolonObjectState.PRODUCER)
|
|
|
+ .map(HolonObject::getSupplyBarPercentage).reduce(0.f, Float::sum);
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate f_pro the penalty function for priority usage
|
|
|
+ // for each active flexibility punish
|
|
|
+
|
|
|
+ double f_pro = model.getAllFlexibilities().stream().filter(flex -> flex.getState().equals(Flexibility.FlexState.IN_USE))
|
|
|
+ .map(flex -> Math.pow(theta, priorityToDouble(flex.getElement().getPriority())) - 1.0)
|
|
|
+ .reduce(0.0, Double::sum);
|
|
|
+
|
|
|
+
|
|
|
+ // calculate f_perf the penalty function for the quality of a flexibility used
|
|
|
+
|
|
|
+
|
|
|
+ // and the subfuction f_unre, f_cool, f_dur
|
|
|
+ double f_perf = 0;
|
|
|
+ for (Flexibility flex : model.getAllFlexibilities().stream().filter(flex -> flex.getState().equals(Flexibility.FlexState.IN_USE)).toList()) {
|
|
|
+ double f_unre = unresponsivnessPenalty(flex.getSpeed());
|
|
|
+ double f_cool = cooldownPenalty(flex.getCooldown());
|
|
|
+ double f_dur = durationPenalty(flex.getDuration());
|
|
|
+ f_perf += f_unre + f_cool + f_dur;
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate f_holon
|
|
|
+ double f_holon = 0;
|
|
|
+ for (Holon net : model.holons) {
|
|
|
+ double f_elements_deviation_production = net.getDeviationInProductionInNetworkForHolonObjects();
|
|
|
+ double f_elements_deviation_consumption = net.getDeviationInProductionInNetworkForHolonObjects();
|
|
|
+ double f_flexibility_deviation_consumption = net.getDiviationInFlexibilityConsumption();
|
|
|
+ double f_flexibility_deviation_production = net.getDiviationInFlexibilityProduction();
|
|
|
+
|
|
|
+ double con = net.getTotalConsumption();
|
|
|
+ double prod = net.getTotalProduction();
|
|
|
+ double flexcapProd = net.getFlexibilityProductionCapacity();
|
|
|
+ double flexcapCon = net.getFlexibilityConsumptionCapacity();
|
|
|
+ double f_change_positive = lambda_f_change
|
|
|
+ - lambda_f_change * Math.min(1, (con > 0.0) ? flexcapProd / con : 1.0);
|
|
|
+ double f_change_negativ = lambda_f_change
|
|
|
+ - lambda_f_change * Math.min(1, (prod > 0.0) ? flexcapCon / prod : 1.0);
|
|
|
+
|
|
|
+ double f_element = f_elements_deviation_production + f_elements_deviation_consumption;
|
|
|
+ double f_flexibility = f_flexibility_deviation_consumption + f_flexibility_deviation_production;
|
|
|
+ double f_change = f_change_positive + f_change_negativ;
|
|
|
+
|
|
|
+ f_holon += f_element + f_flexibility + f_change;
|
|
|
+ }
|
|
|
+ double q1 = squash(f_eb, k_eb);
|
|
|
+ double q2 = squash(f_state, k_state);
|
|
|
+ double q3 = squash(f_pro, k_pro);
|
|
|
+ double q4 = squash(f_perf, k_perf);
|
|
|
+ double q5 = squash(f_holon, k_holon);
|
|
|
+ log.finer("f_eb= " + f_eb + " f_state= " + f_state + " f_pro= " + f_pro + " f_perf= " + f_perf + " f_holon= "
|
|
|
+ + f_holon + " q1= " + q1 + " q2= " + q2 + " q3= " + q3 + " q4= " + q4 + " q5= " + q5);
|
|
|
+
|
|
|
+ return w_eb * q1 + w_state * q2 + w_pro * q3 + w_perf * q4 + w_holon * q5;
|
|
|
}
|
|
|
|
|
|
/**
|
|
@@ -164,7 +143,6 @@ public class ObjectiveFunctionByCarlos {
|
|
|
*
|
|
|
* @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;
|
|
@@ -174,7 +152,6 @@ public class ObjectiveFunctionByCarlos {
|
|
|
* f_sup in paper
|
|
|
*
|
|
|
* @param supply from 0 to 1
|
|
|
- * @return
|
|
|
*/
|
|
|
static public double supplyPenalty(double supply) {
|
|
|
double supplyPercentage = 100 * supply;
|
|
@@ -183,31 +160,17 @@ public class ObjectiveFunctionByCarlos {
|
|
|
return (supplyPercentage < 100) ? -0.5 * supplyPercentage + 50 : supplyPercentage - 100;
|
|
|
}
|
|
|
|
|
|
- /**
|
|
|
- * prio function in the paper
|
|
|
- *
|
|
|
- * @param priority
|
|
|
- * @return
|
|
|
- */
|
|
|
private static double priorityToDouble(Priority priority) {
|
|
|
- switch (priority) {
|
|
|
- case Essential:
|
|
|
- return 3.;
|
|
|
- case High:
|
|
|
- return 2.;
|
|
|
- case Medium:
|
|
|
- return 1.;
|
|
|
- case Low:
|
|
|
- default:
|
|
|
- return 0.;
|
|
|
- }
|
|
|
+ return switch (priority) {
|
|
|
+ case Essential -> 3.;
|
|
|
+ case High -> 2.;
|
|
|
+ case Medium -> 1.;
|
|
|
+ default -> 0.;
|
|
|
+ };
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Attention Math.log calcultae ln not log
|
|
|
- *
|
|
|
- * @param kappa
|
|
|
- * @return
|
|
|
*/
|
|
|
private static double range(double kappa) {
|
|
|
return -kappa / Math.log(Math.pow(2.0, 0.05) - 1.0);
|
|
@@ -215,9 +178,7 @@ public class ObjectiveFunctionByCarlos {
|
|
|
|
|
|
/**
|
|
|
* f_unre
|
|
|
- *
|
|
|
- * @param unresponsiv
|
|
|
- * @return
|
|
|
+
|
|
|
*/
|
|
|
private static double unresponsivnessPenalty(double unresponsiv) {
|
|
|
return (2.0 * lambda_f_unre) / (1 + Math.exp(-unresponsiv / range_for_kappa_f_unre)) - lambda_f_unre;
|
|
@@ -225,9 +186,6 @@ public class ObjectiveFunctionByCarlos {
|
|
|
|
|
|
/**
|
|
|
* f_cool
|
|
|
- *
|
|
|
- * @param cooldown
|
|
|
- * @return
|
|
|
*/
|
|
|
private static double cooldownPenalty(double cooldown) {
|
|
|
return (2.0 * lambda_f_cool) / (1 + Math.exp(-cooldown / range_for_kappa_f_cool)) - lambda_f_cool;
|