Merge pull request #367 from ie3-institute/ms/#366-fix-issues-related-to-em-data

Fixed issues related to em data

Author: sebastian-peter

CHANGELOG.md

@@ -6,6 +6,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased/Snapshot]
 
+### Changed
+- Changes to sent and received em data [#2366](https://github.com/ie3-institute/simonaAPI/issues/366)
+
+### Fixed
+- Issues related to em data [#2366](https://github.com/ie3-institute/simonaAPI/issues/366)
+
 ## [0.11.0] - 2025-10-23
 
 ### Added

src/main/java/edu/ie3/simona/api/data/connection/ExtEmDataConnection.java

@@ -9,6 +9,7 @@
 import edu.ie3.simona.api.data.model.em.*;
 import edu.ie3.simona.api.ontology.em.*;
 import java.util.*;
+import org.slf4j.Logger;
 
 /** Enables data connection of em data between SIMONA and SimonaAPI */
 public final class ExtEmDataConnection
@@ -32,42 +33,39 @@ public List<UUID> getControlledEms() {
   }
 
   /**
-   * Tries to send em data to SIMONA. A message is sent, if at least one map is not empty.
+   * Tries to send em data to SIMONA. A message is sent, if the map is not empty.
    *
    * @param tick current tick
-   * @param flexRequests receiver to flex option request
-   * @param flexOptions receiver to flex options
-   * @param setPoints receiver to set point
-   * @param maybeNextTick option for the next tick in the simulation
+   * @param emData a map: receiver to em data
+   * @param log logger for logging warnings
    * @return true, if data was sent
    */
-  public boolean sendEmData(
-      long tick,
-      Map<UUID, FlexOptionRequest> flexRequests,
-      Map<UUID, List<FlexOptions>> flexOptions,
-      Map<UUID, EmSetPoint> setPoints,
-      Optional<Long> maybeNextTick) {
+  public boolean sendEmData(long tick, Map<UUID, ? extends EmData> emData, Logger log) {
     // send message only if at least one value is present
-    if (!flexRequests.isEmpty() || !flexOptions.isEmpty() || !setPoints.isEmpty()) {
-      sendExtMsg(new ProvideEmData(tick, flexRequests, flexOptions, setPoints, maybeNextTick));
+    if (!emData.isEmpty()) {
+      sendExtMsg(ProvideEmData.create(tick, emData, log));
       return true;
     }
     return false;
   }
 
   /**
-   * Tries to send flex option requests to SIMONA. A message is sent, if at least one entity is
-   * given.
+   * Tries to send em data to SIMONA. A message is sent, if at least one map is not empty.
    *
    * @param tick current tick
-   * @param entities for which flex options should be requested
-   * @param disaggregated if disaggregated flex option should be returned
+   * @param flexRequests receiver to flex option request
+   * @param flexOptions receiver to flex options
+   * @param setPoints receiver to set point that should be sent to SIMONA
    * @return true, if data was sent
    */
-  public boolean sendFlexRequest(long tick, Collection<UUID> entities, boolean disaggregated) {
+  public boolean sendEmData(
+      long tick,
+      Map<UUID, FlexOptionRequest> flexRequests,
+      Map<UUID, List<FlexOptions>> flexOptions,
+      Map<UUID, EmSetPoint> setPoints) {
     // send message only if at least one value is present
-    if (!entities.isEmpty()) {
-      sendExtMsg(new RequestEmFlexResults(tick, new ArrayList<>(entities), disaggregated));
+    if (!flexRequests.isEmpty() || !flexOptions.isEmpty() || !setPoints.isEmpty()) {
+      sendExtMsg(new ProvideEmData(tick, flexRequests, flexOptions, setPoints));
       return true;
     }
     return false;
@@ -79,33 +77,13 @@ public boolean sendFlexRequest(long tick, Collection<UUID> entities, boolean dis
    *
    * @param tick current tick
    * @param emCommunicationMessages that should be sent
-   * @param maybeNextTick an option for the next tick
    * @return true, if data was sent
    */
   public boolean sendCommunicationMessage(
-      long tick,
-      List<EmCommunicationMessage<?>> emCommunicationMessages,
-      Optional<Long> maybeNextTick) {
+      long tick, List<EmCommunicationMessage<?>> emCommunicationMessages) {
     // send message only if at least one value is present
     if (!emCommunicationMessages.isEmpty()) {
-      sendExtMsg(new EmCommunicationMessages(tick, emCommunicationMessages, maybeNextTick));
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Tries to send the em set points to SIMONA.
-   *
-   * @param tick current tick
-   * @param setPoints receiver to set point, that should be sent to SIMONA
-   * @param maybeNextTick option for the next tick in the simulation
-   * @return true, if data was sent
-   */
-  public boolean sendSetPoints(
-      long tick, Map<UUID, EmSetPoint> setPoints, Optional<Long> maybeNextTick) {
-    if (!setPoints.isEmpty()) {
-      sendExtMsg(new ProvideEmSetPointData(tick, setPoints, maybeNextTick));
+      sendExtMsg(new EmCommunicationMessages(tick, emCommunicationMessages));
       return true;
     }
     return false;
@@ -115,13 +93,18 @@ public boolean sendSetPoints(
    * Method to request em flexibility options from SIMONA.
    *
    * @param tick for which set points are requested
-   * @param emEntities for which set points are requested
-   * @return an {@link FlexOptionsResponse} message
+   * @param entities for which set points are requested
+   * @return a map: uuid to list of flex options
    * @throws InterruptedException - on interruptions
    */
-  public Map<UUID, ExtendedFlexOptionsResult> requestEmFlexResults(
-      long tick, List<UUID> emEntities, boolean disaggregated) throws InterruptedException {
-    sendExtMsg(new RequestEmFlexResults(tick, emEntities, disaggregated));
+  public Map<UUID, List<FlexOptions>> requestEmFlexResults(
+      long tick, List<UUID> entities, boolean disaggregated) throws InterruptedException {
+    // create requests
+    Map<UUID, FlexOptionRequest> requests = new HashMap<>();
+    entities.forEach(
+        emEntity -> requests.put(emEntity, new FlexOptionRequest(emEntity, disaggregated)));
+
+    sendExtMsg(new ProvideEmData(tick, requests, Collections.emptyMap(), Collections.emptyMap()));
     return receiveWithType(FlexOptionsResponse.class).receiverToFlexOptions();
   }
 

src/main/java/edu/ie3/simona/api/data/connection/ExtOutputDataConnection.java

@@ -15,7 +15,7 @@
  * @param <T> type of response messages to ext
  */
 public sealed interface ExtOutputDataConnection<T extends DataResponseMessageToExt>
-    permits BiDirectional, ExtResultListener {
+    extends ExtDataConnection permits BiDirectional, ExtResultListener {
 
   /** Queues message from SIMONA that should be handled by the external simulation. */
   void queueExtResponseMsg(T msg) throws InterruptedException;

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

@@ -10,14 +10,13 @@
 import java.time.ZonedDateTime;
 import java.util.*;
 import javax.measure.quantity.Power;
-import org.slf4j.Logger;
 import tech.units.indriya.ComparableQuantity;
 
 /**
  * Extended {@link FlexOptionsResult}, that contains the receiver of the flex options. This models
  * may also contain a disaggregation of the total flex options.
  */
-public final class ExtendedFlexOptionsResult extends FlexOptionsResult implements EmData {
+public final class ExtendedFlexOptionsResult extends FlexOptionsResult {
 
   /** The disaggregated flex option results. */
   private final Map<UUID, FlexOptionsResult> disaggregated;
@@ -49,6 +48,7 @@ public ExtendedFlexOptionsResult(
    * @param pRef active power that was suggested for regular usage by the system participant
    * @param pMin active minimal power that was determined by the system participant
    * @param pMax active maximum power that was determined by the system participant
+   * @param disaggregated a map: uuid to disaggregated flex options
    */
   public ExtendedFlexOptionsResult(
       ZonedDateTime time,
@@ -64,9 +64,6 @@ public ExtendedFlexOptionsResult(
   /**
    * 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
    */
@@ -89,69 +86,6 @@ 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/main/java/edu/ie3/simona/api/data/model/em/FlexOptions.java

@@ -6,5 +6,19 @@
 
 package edu.ie3.simona.api.data.model.em;
 
+import java.util.UUID;
+
 /** Interface that defines flex options. */
-public interface FlexOptions extends EmData {}
+public interface FlexOptions extends EmData {
+
+  /** Returns the receiver of this flex options. */
+  UUID receiver();
+
+  /**
+   * Enriches the flex option with disaggregated flex options.
+   *
+   * @param model of the flex options
+   * @param flexOptions to include
+   */
+  void addDisaggregated(UUID model, FlexOptions flexOptions);
+}

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

@@ -7,7 +7,7 @@
 package edu.ie3.simona.api.data.model.em;
 
 import edu.ie3.util.interval.ClosedInterval;
-import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 import javax.measure.quantity.Dimensionless;
@@ -25,20 +25,22 @@
  * @param etaCharge The charging losses in percent.
  * @param etaDischarge The discharging losses in percent.
  * @param tickToEnergyLimits A map: tick to energy limits.
- * @param disaggregatedFlexOptions A map: uuid to disaggregated flex options.
+ * @param disaggregated A map: uuid to disaggregated flex options.
  */
 public record GeneralFlexOptions(
+    UUID receiver,
     UUID model,
     String flexType,
     ComparableQuantity<Power> pMin,
     ComparableQuantity<Power> pMax,
     ComparableQuantity<Dimensionless> etaCharge,
     ComparableQuantity<Dimensionless> etaDischarge,
     Map<Long, ClosedInterval<ComparableQuantity<Energy>>> tickToEnergyLimits,
-    Map<UUID, FlexOptions> disaggregatedFlexOptions)
+    Map<UUID, FlexOptions> disaggregated)
     implements FlexOptions {
 
   public GeneralFlexOptions(
+      UUID receiver,
       UUID model,
       String flexType,
       ComparableQuantity<Power> pMin,
@@ -47,13 +49,19 @@ public GeneralFlexOptions(
       ComparableQuantity<Dimensionless> etaDischarge,
       Map<Long, ClosedInterval<ComparableQuantity<Energy>>> tickToEnergyLimits) {
     this(
+        receiver,
         model,
         flexType,
         pMin,
         pMax,
         etaCharge,
         etaDischarge,
         tickToEnergyLimits,
-        Collections.emptyMap());
+        new HashMap<>());
+  }
+
+  @Override
+  public void addDisaggregated(UUID model, FlexOptions flexOptions) {
+    disaggregated.put(model, flexOptions);
   }
 }

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

@@ -6,7 +6,7 @@
 
 package edu.ie3.simona.api.data.model.em;
 
-import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 import javax.measure.quantity.Power;
@@ -15,6 +15,7 @@
 /**
  * Power limit flex option that will be sent to SIMONA.
  *
+ * @param receiver The uuid of the receiver. It can be the same as the model.
  * @param model That is providing this flex options.
  * @param pRef Active power (might be negative, thus feed-in) that was suggested for regular usage.
  * @param pMin Minimal active power to which the sender can be reduced (might be negative, thus
@@ -23,8 +24,10 @@
  * @param pMax Maximum active power to which the sender can be increased (might be negative, thus
  *     feed-in), that was determined by the system. Therefore, equates to upper bound of possible
  *     flexibility provision.
+ * @param disaggregated A map: uuid to disaggregated flex options.
  */
 public record PowerLimitFlexOptions(
+    UUID receiver,
     UUID model,
     ComparableQuantity<Power> pRef,
     ComparableQuantity<Power> pMin,
@@ -33,10 +36,16 @@ public record PowerLimitFlexOptions(
     implements FlexOptions {
 
   public PowerLimitFlexOptions(
+      UUID receiver,
       UUID model,
       ComparableQuantity<Power> pRef,
       ComparableQuantity<Power> pMin,
       ComparableQuantity<Power> pMax) {
-    this(model, pRef, pMin, pMax, Collections.emptyMap());
+    this(receiver, model, pRef, pMin, pMax, new HashMap<>());
+  }
+
+  @Override
+  public void addDisaggregated(UUID model, FlexOptions flexOptions) {
+    disaggregated.put(model, flexOptions);
   }
 }