Ms/re co de

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/ExtDataContainerQueue.java

@@ -21,6 +21,13 @@ public int size() {
     return receiverTriggerDeque.size();
   }
 
+    /**
+     * Method for clearing this queue.
+     */
+  public void clear() {
+      receiverTriggerDeque.clear();
+  }
+
   /**
    * Method for adding an {@link ExtDataContainer} to the queue.
    *

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

@@ -9,6 +9,9 @@
 import edu.ie3.simona.api.exceptions.UnexpectedResponseMessageException;
 import edu.ie3.simona.api.ontology.DataMessageFromExt;
 import edu.ie3.simona.api.ontology.DataResponseMessageToExt;
+
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.LinkedBlockingQueue;
 
 /**
@@ -38,6 +41,12 @@ public final R receiveAny() throws InterruptedException {
     return receiveTriggerQueue.take();
   }
 
+  public final List<R> receiveAll() {
+      List<R> result = new ArrayList<>();
+      receiveTriggerQueue.drainTo(result);
+      return result;
+  }
+
   @Override
   @SuppressWarnings("unchecked")
   public final <T extends R> T receiveWithType(Class<T> expectedMessageClass)

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,80 +33,80 @@ 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 flex option requests to SIMONA. A message is sent, if at least one entity is
+   * given.
    *
    * @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 entities for which flex options should be requested
+   * @param disaggregated if disaggregated flex option should be returned
    * @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 sendFlexRequest(long tick, Collection<UUID> entities, boolean disaggregated) {
+    // create requests
+    Map<UUID, FlexOptionRequest> requests = new HashMap<>();
+    entities.forEach(
+        emEntity -> requests.put(emEntity, new FlexOptionRequest(emEntity, disaggregated)));
+
     // 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 (!entities.isEmpty()) {
+      sendExtMsg(new ProvideEmData(tick, requests, Collections.emptyMap(), Collections.emptyMap()));
       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 the 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 emData a map: receiver to em data
+   * @param log logger for logging warnings
    * @return true, if data was sent
    */
-  public boolean sendFlexRequest(long tick, Collection<UUID> entities, boolean disaggregated) {
+  public boolean sendEmData(long tick, Map<UUID, ? extends EmData> emData, Logger log) {
     // send message only if at least one value is present
-    if (!entities.isEmpty()) {
-      sendExtMsg(new RequestEmFlexResults(tick, new ArrayList<>(entities), disaggregated));
+    if (!emData.isEmpty()) {
+      sendExtMsg(ProvideEmData.create(tick, emData, log));
       return true;
     }
     return false;
   }
 
   /**
-   * Tries to send communication messages to SIMONA. A message is sent, if at least one message 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 emCommunicationMessages that should be sent
-   * @param maybeNextTick an option for the next tick
+   * @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 sendCommunicationMessage(
+  public boolean sendEmData(
       long tick,
-      List<EmCommunicationMessage<?>> emCommunicationMessages,
-      Optional<Long> maybeNextTick) {
+      Map<UUID, FlexOptionRequest> flexRequests,
+      Map<UUID, List<FlexOptions>> flexOptions,
+      Map<UUID, EmSetPoint> setPoints) {
     // send message only if at least one value is present
-    if (!emCommunicationMessages.isEmpty()) {
-      sendExtMsg(new EmCommunicationMessages(tick, emCommunicationMessages, maybeNextTick));
+    if (!flexRequests.isEmpty() || !flexOptions.isEmpty() || !setPoints.isEmpty()) {
+      sendExtMsg(new ProvideEmData(tick, flexRequests, flexOptions, setPoints));
       return true;
     }
     return false;
   }
 
   /**
-   * Tries to send the em set points to SIMONA.
+   * Tries to send communication messages to SIMONA. A message is sent, if at least one message is
+   * given.
    *
    * @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
+   * @param emCommunicationMessages that should be sent
    * @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));
+  public boolean sendCommunicationMessage(
+      long tick, List<EmCommunicationMessage<?>> emCommunicationMessages) {
+    // send message only if at least one value is present
+    if (!emCommunicationMessages.isEmpty()) {
+      sendExtMsg(new EmCommunicationMessages(tick, emCommunicationMessages));
       return true;
     }
     return false;
@@ -116,12 +117,12 @@ public boolean sendSetPoints(
    *
    * @param tick for which set points are requested
    * @param emEntities for which set points are requested
-   * @return an {@link FlexOptionsResponse} message
+   * @return a map: uuid to list of flex options
    * @throws InterruptedException - on interruptions
    */
-  public Map<UUID, ExtendedFlexOptionsResult> requestEmFlexResults(
+  public Map<UUID, List<FlexOptions>> requestEmFlexResults(
       long tick, List<UUID> emEntities, boolean disaggregated) throws InterruptedException {
-    sendExtMsg(new RequestEmFlexResults(tick, emEntities, disaggregated));
+    sendFlexRequest(tick, emEntities, disaggregated);
     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/container/ExtInputContainer.java

@@ -201,4 +201,17 @@ public String flexOptionsString() {
   public String setPointsString() {
     return setPoints.toString();
   }
+
+    @Override
+    public String toString() {
+        return "ExtInputContainer{" +
+                "tick=" + tick +
+                ", maybeNextTick=" + maybeNextTick +
+                ", primaryData=" + primaryData +
+                ", flexRequests=" + flexRequests +
+                ", flexOptions=" + flexOptions +
+                ", setPoints=" + setPoints +
+                ", emMessages=" + emMessages +
+                '}';
+    }
 }

src/main/java/edu/ie3/simona/api/data/container/ExtOutputContainer.java

@@ -135,4 +135,14 @@ public List<ResultEntity> getResult(UUID assetId) {
   public List<EmData> getEmData(UUID assetId) {
     return emDataMap.getOrDefault(assetId, Collections.emptyList());
   }
+
+    @Override
+    public String toString() {
+        return "ExtOutputContainer{" +
+                "tick=" + tick +
+                ", maybeNextTick=" + maybeNextTick +
+                ", resultMap=" + resultMap +
+                ", emDataMap=" + emDataMap +
+                '}';
+    }
 }

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);
+}