DBFS with multiple connections between sub grids

CHANGELOG.md

@@ -54,6 +54,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix breaking SIMONA caused by introducing temperature dependant load profiles in PSDM [#255](https://github.com/ie3-institute/simona/issues/255)
 - Respect for voltage angle in DBFS slack voltage exchange protocol [#69](https://github.com/ie3-institute/simona/issues/69)
 - Adapted to changed time series interfaces in PSDM [#296](https://github.com/ie3-institute/simona/issues/296)
+- Fix handling of multiple connections between subgrids [#22](https://github.com/ie3-institute/simona/issues/22)
+  - Consolidate request replies for different sub grid gates in one message
+  - Await and send responses for distinct pairs of sender reference and target node
 
 ### Removed
 - Remove workaround for tscfg tmp directory [#178](https://github.com/ie3-institute/simona/issues/178)

src/main/scala/edu/ie3/simona/agent/grid/GridAgentData.scala

@@ -14,13 +14,14 @@ import edu.ie3.powerflow.model.PowerFlowResult
 import edu.ie3.powerflow.model.PowerFlowResult.SuccessFullPowerFlowResult.ValidNewtonRaphsonPFResult
 import edu.ie3.simona.agent.grid.ReceivedValues.{
   ReceivedPowerValues,
-  ReceivedSlackValues
+  ReceivedSlackVoltageValues
 }
 import edu.ie3.simona.agent.grid.ReceivedValuesStore.NodeToReceivedPower
 import edu.ie3.simona.model.grid.{GridModel, RefSystem}
 import edu.ie3.simona.ontology.messages.PowerMessage.{
   FailedPowerFlow,
   PowerResponseMessage,
+  ProvideGridPowerMessage,
   ProvidePowerMessage
 }
 
@@ -53,9 +54,9 @@ object GridAgentData {
       refSystem: RefSystem
   ) extends GridAgentData
       with GridAgentDataHelper {
-    override protected val subnetGates: Vector[SubGridGate] =
+    override protected val subgridGates: Vector[SubGridGate] =
       subGridGateToActorRef.keys.toVector
-    override protected val subnetId: Int = subGridContainer.getSubnet
+    override protected val subgridId: Int = subGridContainer.getSubnet
   }
 
   /** State data indicating that a power flow has been executed.
@@ -64,12 +65,30 @@ object GridAgentData {
     *   the base data of the [[GridAgent]]
     * @param powerFlowResult
     *   result of the executed power flow
+    * @param pendingRequestAnswers
+    *   Set of subgrid numbers of [[GridAgent]]s that don't have their request
+    *   answered, yet
     */
-  final case class PowerFlowDoneData(
+  final case class PowerFlowDoneData private (
       gridAgentBaseData: GridAgentBaseData,
-      powerFlowResult: PowerFlowResult
+      powerFlowResult: PowerFlowResult,
+      pendingRequestAnswers: Set[Int]
   ) extends GridAgentData
 
+  object PowerFlowDoneData {
+    def apply(
+        gridAgentBaseData: GridAgentBaseData,
+        powerFlowResult: PowerFlowResult
+    ): PowerFlowDoneData = {
+      /* Determine the subgrid numbers of all superior grids */
+      val superiorSubGrids = gridAgentBaseData.gridEnv.subgridGateToActorRef
+        .map { case (subGridGate, _) => subGridGate.getSuperiorNode.getSubnet }
+        .filterNot(_ == gridAgentBaseData.gridEnv.gridModel.subnetNo)
+        .toSet
+      PowerFlowDoneData(gridAgentBaseData, powerFlowResult, superiorSubGrids)
+    }
+  }
+
   /** The base data that is mainly used by the [[GridAgent]]. This data has to
     * be copied several times at several places for each state transition with
     * updated data. So be careful in adding more data on it!
@@ -78,7 +97,7 @@ object GridAgentData {
 
     def apply(
         gridModel: GridModel,
-        subnetGateToActorRef: Map[SubGridGate, ActorRef],
+        subgridGateToActorRef: Map[SubGridGate, ActorRef],
         nodeToAssetAgents: Map[UUID, Set[ActorRef]],
         superiorGridNodeUuids: Vector[UUID],
         inferiorGridGates: Vector[SubGridGate],
@@ -93,11 +112,11 @@ object GridAgentData {
           Int,
           SweepValueStore
         ] // initialization is assumed to be always with no sweep data
-      val inferiorGridGateToActorRef = subnetGateToActorRef.filter {
+      val inferiorGridGateToActorRef = subgridGateToActorRef.filter {
         case (gate, _) => inferiorGridGates.contains(gate)
       }
       GridAgentBaseData(
-        GridEnvironment(gridModel, subnetGateToActorRef, nodeToAssetAgents),
+        GridEnvironment(gridModel, subgridGateToActorRef, nodeToAssetAgents),
         powerFlowParams,
         currentSweepNo,
         ReceivedValuesStore.empty(
@@ -135,7 +154,7 @@ object GridAgentData {
       gridAgentBaseData.copy(
         receivedValueStore = ReceivedValuesStore.empty(
           gridAgentBaseData.gridEnv.nodeToAssetAgents,
-          gridAgentBaseData.gridEnv.subnetGateToActorRef.filter {
+          gridAgentBaseData.gridEnv.subgridGateToActorRef.filter {
             case (gate, _) => inferiorGridGates.contains(gate)
           },
           superiorGridNodeUuids
@@ -176,9 +195,9 @@ object GridAgentData {
   ) extends GridAgentData
       with GridAgentDataHelper {
 
-    override protected val subnetGates: Vector[SubGridGate] =
-      gridEnv.subnetGateToActorRef.keys.toVector
-    override protected val subnetId: Int = gridEnv.gridModel.subnetNo
+    override protected val subgridGates: Vector[SubGridGate] =
+      gridEnv.subgridGateToActorRef.keys.toVector
+    override protected val subgridId: Int = gridEnv.gridModel.subnetNo
 
     val allRequestedDataReceived: Boolean = {
       // we expect power values from inferior grids and assets
@@ -221,10 +240,33 @@ object GridAgentData {
       val updatedNodeToReceivedPowersMap = receivedPowerValues.values.foldLeft(
         receivedValueStore.nodeToReceivedPower
       ) {
+        case (
+              nodeToReceivedPowerValuesMapWithAddedPowerResponse,
+              (
+                senderRef,
+                provideGridPowerMessage: ProvideGridPowerMessage
+              )
+            ) =>
+          /* Go over all includes messages and add them. */
+          provideGridPowerMessage.nodalResidualPower.foldLeft(
+            nodeToReceivedPowerValuesMapWithAddedPowerResponse
+          ) {
+            case (
+                  nodeToReceivedPowerValuesMapWithAddedExchangedPower,
+                  exchangedPower
+                ) =>
+              updateNodalReceivedPower(
+                exchangedPower,
+                nodeToReceivedPowerValuesMapWithAddedExchangedPower,
+                senderRef,
+                replace
+              )
+          }
         case (
               nodeToReceivedPowerValuesMapWithAddedPowerResponse,
               (senderRef, powerResponseMessage)
             ) =>
+          // some other singular power response message
           updateNodalReceivedPower(
             powerResponseMessage,
             nodeToReceivedPowerValuesMapWithAddedPowerResponse,
@@ -328,8 +370,8 @@ object GridAgentData {
         }
         .map { case (uuid, _) => uuid }
 
-    /** Update this [[GridAgentBaseData]] with [[ReceivedSlackValues]] and
-      * return a copy of this [[GridAgentBaseData]] for further processing
+    /** Update this [[GridAgentBaseData]] with [[ReceivedSlackVoltageValues]]
+      * and return a copy of this [[GridAgentBaseData]] for further processing
       *
       * @param receivedSlackValues
       *   the slack voltage values that should be used for the update
@@ -338,33 +380,27 @@ object GridAgentData {
       *   receivedSlackValues
       */
     def updateWithReceivedSlackVoltages(
-        receivedSlackValues: ReceivedSlackValues
+        receivedSlackValues: ReceivedSlackVoltageValues
     ): GridAgentBaseData = {
       val updatedNodeToReceivedSlackVoltageValuesMap =
-        receivedSlackValues.values.foldLeft(
-          receivedValueStore.nodeToReceivedSlackVoltage
-        ) {
-          case (
-                nodeToSlackVoltageUpdated,
-                (senderRef, slackValues)
-              ) =>
-            val nodeUuid: UUID = slackValues.nodeUuid
-
+        receivedSlackValues.values.flatMap { case (senderRef, slackValues) =>
+          slackValues.nodalSlackVoltages.map { exchangeVoltage =>
             receivedValueStore.nodeToReceivedSlackVoltage
-              .get(nodeUuid) match {
+              .get(exchangeVoltage.nodeUuid) match {
               case Some(None) =>
                 /* Slack voltage is expected and not yet received */
-                nodeToSlackVoltageUpdated + (nodeUuid -> Some(slackValues))
+                exchangeVoltage.nodeUuid -> Some(exchangeVoltage)
               case Some(Some(_)) =>
                 throw new RuntimeException(
-                  s"Already received slack value for node $nodeUuid!"
+                  s"Already received slack value for node ${exchangeVoltage.nodeUuid}!"
                 )
               case None =>
                 throw new RuntimeException(
-                  s"Received slack value for node $nodeUuid from $senderRef which is not in my slack values nodes list!"
+                  s"Received slack value for node ${exchangeVoltage.nodeUuid} from $senderRef which is not in my slack values nodes list!"
                 )
             }
-        }
+          }
+        }.toMap
       this.copy(
         receivedValueStore = receivedValueStore.copy(
           nodeToReceivedSlackVoltage =
@@ -406,7 +442,7 @@ object GridAgentData {
         sweepValueStores = updatedSweepValueStore,
         receivedValueStore = ReceivedValuesStore.empty(
           gridEnv.nodeToAssetAgents,
-          gridEnv.subnetGateToActorRef.filter { case (gate, _) =>
+          gridEnv.subgridGateToActorRef.filter { case (gate, _) =>
             inferiorGridGates.contains(gate)
           },
           superiorGridNodeUuids

src/main/scala/edu/ie3/simona/agent/grid/GridAgentDataHelper.scala

@@ -15,43 +15,43 @@ import edu.ie3.datamodel.graph.SubGridGate
   */
 private[grid] trait GridAgentDataHelper {
 
-  protected val subnetGates: Vector[SubGridGate]
-  protected val subnetId: Int
+  protected val subgridGates: Vector[SubGridGate]
+  protected val subgridId: Int
 
   // methods definition
   def superiorGridIds: Vector[String] =
-    subnetGates.collect {
-      case gate: SubGridGate if gate.getInferiorSubGrid == subnetId =>
+    subgridGates.collect {
+      case gate: SubGridGate if gate.getInferiorSubGrid == subgridId =>
         gate.getSuperiorSubGrid.toString
     }
 
   def inferiorGridIds: Vector[String] =
-    subnetGates.collect {
-      case gate: SubGridGate if gate.getSuperiorSubGrid == subnetId =>
+    subgridGates.collect {
+      case gate: SubGridGate if gate.getSuperiorSubGrid == subgridId =>
         gate.getInferiorSubGrid.toString
     }
 
   def superiorGridNodeUuids: Vector[UUID] =
-    subnetGates.collect {
-      case gate: SubGridGate if gate.getInferiorSubGrid == subnetId =>
+    subgridGates.collect {
+      case gate: SubGridGate if gate.getInferiorSubGrid == subgridId =>
         gate.getSuperiorNode.getUuid
     }
 
   def inferiorGridNodeUuids: Vector[UUID] =
-    subnetGates.collect {
-      case gate: SubGridGate if gate.getSuperiorSubGrid == subnetId =>
+    subgridGates.collect {
+      case gate: SubGridGate if gate.getSuperiorSubGrid == subgridId =>
         gate.getInferiorNode.getUuid
     }
 
   def superiorGridGates: Vector[SubGridGate] =
-    subnetGates.collect {
-      case gate: SubGridGate if gate.getInferiorSubGrid == subnetId =>
+    subgridGates.collect {
+      case gate: SubGridGate if gate.getInferiorSubGrid == subgridId =>
         gate
     }
 
   def inferiorGridGates: Vector[SubGridGate] =
-    subnetGates.collect {
-      case gate: SubGridGate if gate.getSuperiorSubGrid == subnetId =>
+    subgridGates.collect {
+      case gate: SubGridGate if gate.getSuperiorSubGrid == subgridId =>
         gate
     }
 

src/main/scala/edu/ie3/simona/agent/grid/GridEnvironment.scala

@@ -17,14 +17,14 @@ import edu.ie3.simona.model.grid.GridModel
   *
   * @param gridModel
   *   [[GridModel]] with all asset information
-  * @param subnetGateToActorRef
+  * @param subgridGateToActorRef
   *   a mapping of all [[SubGridGate]] s to their corresponding [[ActorRef]] s
   * @param nodeToAssetAgents
   *   a mapping of all node uuids to a set of asset [[ActorRef]] s at those
   *   nodes
   */
 final case class GridEnvironment(
     gridModel: GridModel,
-    subnetGateToActorRef: Map[SubGridGate, ActorRef],
+    subgridGateToActorRef: Map[SubGridGate, ActorRef],
     nodeToAssetAgents: Map[UUID, Set[ActorRef]]
 )