Including reviewer's comments.

Author: staudtMarius

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

@@ -32,29 +32,6 @@ public List<UUID> getControlledEms() {
     return new ArrayList<>(controlled);
   }
 
-  /**
-   * Tries to send flex option requests to SIMONA. A message is sent, if at least one entity is
-   * given.
-   *
-   * @param tick current tick
-   * @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 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 (!entities.isEmpty()) {
-      sendExtMsg(new ProvideEmData(tick, requests, Collections.emptyMap(), Collections.emptyMap()));
-      return true;
-    }
-    return false;
-  }
-
   /**
    * Tries to send em data to SIMONA. A message is sent, if the map is not empty.
    *
@@ -116,13 +93,18 @@ public boolean sendCommunicationMessage(
    * Method to request em flexibility options from SIMONA.
    *
    * @param tick for which set points are requested
-   * @param emEntities for which set points are requested
+   * @param entities for which set points are requested
    * @return a map: uuid to list of flex options
    * @throws InterruptedException - on interruptions
    */
   public Map<UUID, List<FlexOptions>> requestEmFlexResults(
-      long tick, List<UUID> emEntities, boolean disaggregated) throws InterruptedException {
-    sendFlexRequest(tick, emEntities, disaggregated);
+      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/model/em/GeneralFlexOptions.java

@@ -60,11 +60,6 @@ public GeneralFlexOptions(
         new HashMap<>());
   }
 
-  @Override
-  public UUID receiver() {
-    return receiver;
-  }
-
   @Override
   public void addDisaggregated(UUID model, FlexOptions flexOptions) {
     disaggregated.put(model, flexOptions);

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

@@ -44,11 +44,6 @@ public PowerLimitFlexOptions(
     this(receiver, model, pRef, pMin, pMax, new HashMap<>());
   }
 
-  @Override
-  public UUID receiver() {
-    return receiver;
-  }
-
   @Override
   public void addDisaggregated(UUID model, FlexOptions flexOptions) {
     disaggregated.put(model, flexOptions);

src/main/java/edu/ie3/simona/api/simulation/ExtCoSimulation.java

@@ -14,7 +14,6 @@
 import edu.ie3.simona.api.data.connection.ExtResultDataConnection;
 import edu.ie3.simona.api.data.container.ExtInputContainer;
 import edu.ie3.simona.api.data.container.ExtOutputContainer;
-import edu.ie3.simona.api.data.model.em.EmSetPoint;
 import edu.ie3.simona.api.exceptions.ExtDataConnectionException;
 import java.util.List;
 import java.util.Map;
@@ -131,49 +130,6 @@ protected void sendPrimaryDataToSimona(
     log.debug("Provided Primary Data to SIMONA!");
   }
 
-  // energy management data methods
-
-  /**
-   * Function to send em set point data to SIMONA using the given {@link ExtEmDataConnection}. This
-   * method will take a value from the {@link #queueToSimona}.
-   *
-   * <p>{@code nextTick} is necessary, because the em agents have an own scheduler that should know,
-   * when the next set point arrives.
-   *
-   * @param extEmDataConnection the connection to SIMONA
-   * @param tick for which data is sent
-   * @param log logger
-   * @throws InterruptedException if the fetching of data is interrupted
-   */
-  protected void sendEmSetPointsToSimona(
-      ExtEmDataConnection extEmDataConnection, long tick, Logger log) throws InterruptedException {
-    Map<UUID, EmSetPoint> inputData = queueToSimona.takeData(ExtInputContainer::extractSetPoints);
-
-    sendEmSetPointsToSimona(extEmDataConnection, tick, inputData, log);
-  }
-
-  /**
-   * Function to send em data to SIMONA using ExtPrimaryData nextTick is necessary, because the em
-   * agents have an own scheduler that should know, when the next set point arrives.
-   *
-   * @param extEmDataConnection the connection to SIMONA
-   * @param tick for which data is sent
-   * @param setPoints map: id to set point
-   * @param log logger
-   */
-  protected void sendEmSetPointsToSimona(
-      ExtEmDataConnection extEmDataConnection,
-      long tick,
-      Map<UUID, EmSetPoint> setPoints,
-      Logger log) {
-    log.debug("Received em set points from {}", extSimulatorName);
-    boolean wasSent = extEmDataConnection.sendEmData(tick, setPoints, log);
-    if (!wasSent) {
-      log.debug("No set point data was sent to SIMONA!");
-    }
-    log.debug("Provided em set points to SIMONA!");
-  }
-
   // result data methods
 
   /**

src/test/groovy/edu/ie3/simona/api/data/connection/ExtEmDataConnectionTest.groovy

@@ -2,6 +2,7 @@ package edu.ie3.simona.api.data.connection
 
 import edu.ie3.simona.api.data.connection.ExtEmDataConnection.EmMode
 import edu.ie3.simona.api.data.model.em.EmCommunicationMessage
+import edu.ie3.simona.api.data.model.em.EmSetPoint
 import edu.ie3.simona.api.data.model.em.FlexOptionRequest
 import edu.ie3.simona.api.data.model.em.PowerLimitFlexOptions
 import edu.ie3.simona.api.ontology.DataMessageFromExt
@@ -72,24 +73,6 @@ class ExtEmDataConnectionTest extends Specification implements DataServiceTestDa
         extSimAdapter.expectMessage(new ScheduleDataServiceMessage(dataService.ref()))
     }
 
-    def "ExtEmDataConnection should send no message, if no flex requests are given"() {
-        given:
-        def dataService = testKit.createTestProbe(DataMessageFromExt)
-        def extSimAdapter = testKit.createTestProbe(ScheduleDataServiceMessage)
-        def extEmDataConnection = new ExtEmDataConnection(controlled, EmMode.BASE)
-        extEmDataConnection.setActorRefs(
-                dataService.ref(),
-                extSimAdapter.ref()
-        )
-
-        when:
-        def wasSent = extEmDataConnection.sendEmData(0L, [:], [:], [:])
-
-        then:
-        !wasSent
-        dataService.expectNoMessage()
-    }
-
     def "ExtEmDataConnection should provide em flex options correctly"() {
         given:
         def dataService = testKit.createTestProbe(DataMessageFromExt)
@@ -111,7 +94,7 @@ class ExtEmDataConnectionTest extends Specification implements DataServiceTestDa
         extSimAdapter.expectMessage(new ScheduleDataServiceMessage(dataService.ref()))
     }
 
-    def "ExtEmDataConnection should send no message, if no flex options are given"() {
+    def "ExtEmDataConnection should provide em set points correctly"() {
         given:
         def dataService = testKit.createTestProbe(DataMessageFromExt)
         def extSimAdapter = testKit.createTestProbe(ScheduleDataServiceMessage)
@@ -121,15 +104,18 @@ class ExtEmDataConnectionTest extends Specification implements DataServiceTestDa
                 extSimAdapter.ref()
         )
 
+        def emData = Map.of(inputUuid, new EmSetPoint(inputUuid, power))
+
         when:
-        def wasSent = extEmDataConnection.sendEmData(0L, [:], [:], [:])
+        def wasSent = extEmDataConnection.sendEmData(0L, [:], [:], emData)
 
         then:
-        !wasSent
-        dataService.expectNoMessage()
+        wasSent
+        dataService.expectMessage(new ProvideEmData(0, [:], [:], emData))
+        extSimAdapter.expectMessage(new ScheduleDataServiceMessage(dataService.ref()))
     }
 
-    def "ExtEmDataConnection should provide flex option requests correctly"() {
+    def "ExtEmDataConnection should send no message, if no em data is given"() {
         given:
         def dataService = testKit.createTestProbe(DataMessageFromExt)
         def extSimAdapter = testKit.createTestProbe(ScheduleDataServiceMessage)
@@ -140,12 +126,11 @@ class ExtEmDataConnectionTest extends Specification implements DataServiceTestDa
         )
 
         when:
-        def wasSent = extEmDataConnection.sendFlexRequest(0L, [inputUuid], true)
+        def wasSent = extEmDataConnection.sendEmData(0L, [:], [:], [:])
 
         then:
-        wasSent
-        dataService.expectMessage( new ProvideEmData(0, [(inputUuid): new FlexOptionRequest(inputUuid, true)], [:], [:]))
-        extSimAdapter.expectMessage(new ScheduleDataServiceMessage(dataService.ref()))
+        !wasSent
+        dataService.expectNoMessage()
     }
 
     def "ExtEmDataConnection should provide communication messages correctly"() {

src/test/groovy/edu/ie3/simona/api/simulation/ExtCoSimulationTest.groovy

@@ -133,45 +133,4 @@ class ExtCoSimulationTest extends Specification {
         ex.message == "The external data connection 'ExtResultDataConnection' could not be build!"
     }
 
-    def "An ExtCoSimulation should sent em set point data correctly"() {
-        given:
-        def extEmDataConnection = new ExtEmDataConnection([], EmMode.BASE)
-        def dataService = testKit.createTestProbe(DataMessageFromExt)
-
-        def extSimAdapter = testKit.createTestProbe(ScheduleDataServiceMessage)
-        extEmDataConnection.setActorRefs(
-                dataService.ref(),
-                extSimAdapter.ref()
-        )
-
-        def data = [(UUID.randomUUID()): new EmSetPoint(UUID.randomUUID())]
-
-        when:
-        sim.sendEmSetPointsToSimona(extEmDataConnection, 0L, data, log)
-
-        then:
-        dataService.expectMessage(new ProvideEmData(0L, [:], [:], data))
-    }
-
-    def "An ExtCoSimulation should not sent empty em set point data"() {
-        given:
-        def extEmDataConnection = new ExtEmDataConnection([], EmMode.BASE)
-        def dataService = testKit.createTestProbe(DataMessageFromExt)
-
-        def extSimAdapter = testKit.createTestProbe(ScheduleDataServiceMessage)
-        extEmDataConnection.setActorRefs(
-                dataService.ref(),
-                extSimAdapter.ref()
-        )
-
-        def data = [:]
-
-        when:
-        sim.sendEmSetPointsToSimona(extEmDataConnection, 0L, data, log)
-
-        then:
-        dataService.expectNoMessage()
-        extSimAdapter.expectNoMessage()
-    }
-
 }