Adding additional methods to ExtendedFlexOptionsResult.

Author: staudtMarius

src/main/java/edu/ie3/simona/api/data/model/em/ExtendedFlexOptionsResult.java

@@ -10,6 +10,7 @@
 import java.time.ZonedDateTime;
 import java.util.*;
 import javax.measure.quantity.Power;
+import org.slf4j.Logger;
 import tech.units.indriya.ComparableQuantity;
 
 /**
@@ -69,6 +70,19 @@ public ExtendedFlexOptionsResult(
     this.disaggregated = disaggregated;
   }
 
+  /**
+   * Method for adding disaggregated flex option results to this object.
+   *
+   * <p>Note: This method does not check, if the disaggregated flex options match the total flex
+   * options. To do this, please use the method {@link #checkFlexOptions(Logger)}.
+   *
+   * @param uuid of the inferior model
+   * @param flexOptionsResult the flex options of the inferior model
+   */
+  public void addDisaggregated(UUID uuid, FlexOptionsResult flexOptionsResult) {
+    this.disaggregated.put(uuid, flexOptionsResult);
+  }
+
   /** Returns the uuid of the sender ({@link #getInputModel()}) of the results. */
   public UUID getSender() {
     return getInputModel();
@@ -94,6 +108,69 @@ public Map<UUID, FlexOptionsResult> getDisaggregated() {
     return Collections.unmodifiableMap(disaggregated);
   }
 
+  /**
+   * Method for checking if the disaggregated flex options match the total flex options.
+   *
+   * @param log used for logging
+   * @return {@code true} if the flex options match, else {@code false}
+   */
+  public boolean checkFlexOptions(Logger log) {
+    List<ComparableQuantity<Power>> refs = new ArrayList<>();
+    List<ComparableQuantity<Power>> mins = new ArrayList<>();
+    List<ComparableQuantity<Power>> maxs = new ArrayList<>();
+
+    disaggregated.forEach(
+        (uuid, flexOptionsResult) -> {
+          refs.add(flexOptionsResult.getpRef());
+          mins.add(flexOptionsResult.getpMin());
+          maxs.add(flexOptionsResult.getpMax());
+        });
+
+    ComparableQuantity<Power> ref = getpRef();
+    ComparableQuantity<Power> min = getpMin();
+    ComparableQuantity<Power> max = getpMax();
+
+    Optional<ComparableQuantity<Power>> refSum = refs.stream().reduce(ComparableQuantity::add);
+    Optional<ComparableQuantity<Power>> minSum = mins.stream().reduce(ComparableQuantity::add);
+    Optional<ComparableQuantity<Power>> maxSum = maxs.stream().reduce(ComparableQuantity::add);
+
+    boolean isRefValid = false;
+    boolean isMinValid = false;
+    boolean isMaxValid = false;
+
+    if (refSum.isPresent()) {
+      isRefValid = refSum.get().isEquivalentTo(ref);
+
+      if (!isRefValid) {
+        log.warn("Disaggregated reference power does not match total reference power.");
+      }
+    } else {
+      log.warn("Cannot check disaggregated reference power.");
+    }
+
+    if (minSum.isPresent()) {
+      isMinValid = minSum.get().isEquivalentTo(min);
+
+      if (!isMinValid) {
+        log.warn("Disaggregated minimum power does not match total minimum power.");
+      }
+    } else {
+      log.warn("Cannot check disaggregated minimum power.");
+    }
+
+    if (maxSum.isPresent()) {
+      isMaxValid = maxSum.get().isEquivalentTo(max);
+
+      if (!isMaxValid) {
+        log.warn("Disaggregated maximum power does not match total maximum power.");
+      }
+    } else {
+      log.warn("Cannot check disaggregated maximum power.");
+    }
+
+    return isRefValid && isMinValid && isMaxValid;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;

src/test/groovy/edu/ie3/simona/api/data/model/em/ExtendedFlexOptionsResultTest.groovy

@@ -2,6 +2,8 @@ package edu.ie3.simona.api.data.model.em
 
 import edu.ie3.datamodel.models.result.system.FlexOptionsResult
 import edu.ie3.util.quantities.PowerSystemUnits
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import spock.lang.Shared
 import spock.lang.Specification
 import tech.units.indriya.ComparableQuantity
@@ -12,6 +14,9 @@ import java.time.ZonedDateTime
 
 class ExtendedFlexOptionsResultTest extends Specification {
 
+    @Shared
+    Logger logger = LoggerFactory.getLogger(ExtendedFlexOptionsResultTest)
+
     @Shared
     ZonedDateTime time = ZonedDateTime.now()
 
@@ -86,4 +91,50 @@ class ExtendedFlexOptionsResultTest extends Specification {
         ]              | true
     }
 
+    def "The ExtendedFlexOptionsResult should add disaggregated flex options correctly"() {
+        given:
+        def result = new ExtendedFlexOptionsResult(time, senderUuid, receiverUuid, pRef, pMin, pMax)
+        def inferiorUuid1 = UUID.fromString("a246eee3-405c-4af1-9ad2-69ecad2bfb65")
+        def inferiorUuid2 = UUID.fromString("78676121-f154-4f70-ad50-4384ddf8deed")
+
+        def inferiorOptions1 = new FlexOptionsResult(time, inferiorUuid1, pRef, pMin, pMax)
+        def inferiorOptions2 = new FlexOptionsResult(time, inferiorUuid2, pMin, pMin, pMin)
+
+        when:
+        result.addDisaggregated(inferiorUuid1, inferiorOptions1)
+        result.addDisaggregated(inferiorUuid2, inferiorOptions2)
+
+        then:
+        result.hasDisaggregated()
+        result.disaggregated.size() == 2
+        result.disaggregated.get(inferiorUuid1) == inferiorOptions1
+        result.disaggregated.get(inferiorUuid2) == inferiorOptions2
+    }
+
+    def "The ExtendedFlexOptionsResult should check if disaggregated flex options match total flex options correctly"() {
+        given:
+        def result = new ExtendedFlexOptionsResult(time, senderUuid, receiverUuid, pRef, pMin, pMax)
+        def inferiorUuid1 = UUID.fromString("a246eee3-405c-4af1-9ad2-69ecad2bfb65")
+        def inferiorUuid2 = UUID.fromString("78676121-f154-4f70-ad50-4384ddf8deed")
+        def inferiorUuid3 = UUID.randomUUID()
+
+        def inferiorOptions1 = new FlexOptionsResult(time, inferiorUuid1, pRef, pMin, pMin)
+        def inferiorOptions2 = new FlexOptionsResult(time, inferiorUuid2, pMin, pMin, pMax)
+        def inferiorOptions3 = new FlexOptionsResult(time, inferiorUuid3, pRef, pRef, pMax)
+
+        when:
+        result.addDisaggregated(inferiorUuid1, inferiorOptions1)
+        boolean withOnly1 = result.checkFlexOptions(logger)
+
+        result.addDisaggregated(inferiorUuid2, inferiorOptions2)
+        boolean with1And2 = result.checkFlexOptions(logger)
+
+        result.addDisaggregated(inferiorUuid3, inferiorOptions3)
+        boolean with1And2And3 = result.checkFlexOptions(logger)
+
+        then:
+        !withOnly1
+        with1And2
+        !with1And2And3
+    }
 }