Fix hp thermal storage refill

CHANGELOG.md

@@ -31,6 +31,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Enhanced Newton-Raphson-PowerFlow failures with more information [#815](https://github.com/ie3-institute/simona/issues/815)
 - Update RTD references and bibliography [#868](https://github.com/ie3-institute/simona/issues/868)
 - Add gradle application plugin for command line execution with gradle run [#890](https://github.com/ie3-institute/simona/issues/890)
+- Additional tests to check flexibility options of thermal house and storage [#729](https://github.com/ie3-institute/simona/issues/729)
 
 ### Changed
 - Adapted to changed data source in PSDM [#435](https://github.com/ie3-institute/simona/issues/435)
@@ -76,6 +77,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Updated AUTHORS.md [#904](https://github.com/ie3-institute/simona/issues/904)
 - Updated `Gradle` to version V8.10 [#829](https://github.com/ie3-institute/simona/issues/829)
 - Updated AUTHORS.md [#905](https://github.com/ie3-institute/simona/issues/905)
+- Prepare ThermalStorageTestData for Storage without storageVolumeLvlMin [#894](https://github.com/ie3-institute/simona/issues/894)
 
 ### Fixed
 - Removed a repeated line in the documentation of vn_simona config [#658](https://github.com/ie3-institute/simona/issues/658)
@@ -100,6 +102,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed FixedFeedModelSpec [#861](https://github.com/ie3-institute/simona/issues/861)
 - Fixing duration calculation in result events [#801](https://github.com/ie3-institute/simona/issues/801)
 - Handle MobSim requests for current prices [#892](https://github.com/ie3-institute/simona/issues/892)
+- Fixed Hp results leading to overheating house and other effects [#827](https://github.com/ie3-institute/simona/issues/827)
+- Fixed thermal storage getting recharged when empty [#827](https://github.com/ie3-institute/simona/issues/827)
 
 ## [3.0.0] - 2023-08-07
 

docs/readthedocs/models.md

@@ -16,6 +16,7 @@ models/two_winding_transformer_model
 models/three_winding_transformer_model
 models/reference_system
 models/thermal_grid_model
+models/thermal_house_model
 ```
 
 ## System Participant Related Models

docs/readthedocs/models/thermal_grid_model.md

@@ -3,6 +3,8 @@
 
 The Thermal Grid Model introduces a coupling point to thermal system, equivalent to an electrical node. It can be used to interconnect thermal units to a thermal heat network.
 
+A Thermal Grid Model consists of a {ref}`thermal_house_model` and / or a {ref}`cts_model` which are supplied by a thermal source like a {ref}`hp_model`.
+
 ## Attributes, Units and Remarks
 
 Please refer to {doc}`PowerSystemDataModel - Thermal Bus <psdm:models/input/thermal/thermalbus>` for Attributes and Units used in this Model.

docs/readthedocs/models/thermal_house_model.md

@@ -0,0 +1,13 @@
+(thermal_house_model)=
+
+# Thermal House Model
+
+This page documents the functionality of the thermal house available in SIMONA.
+
+## Behaviour
+
+This house model represents the thermal behaviour of a building. This reflects a simple shoe box with a thermal capacity and with transmission losses.
+
+## Attributes, Units and Remarks
+
+Please refer to  {doc}`PowerSystemDataModel - Thermal House Model <psdm:models/input/thermal/thermalhouse>` for Attributes and Units used in this Model.

src/main/scala/edu/ie3/simona/agent/ValueStore.scala

@@ -22,7 +22,7 @@ import scala.collection.SortedMap
   */
 final case class ValueStore[+D](
     maxTickSpan: Long,
-    private val store: SortedMap[Long, D] = SortedMap.empty[Long, D],
+    store: SortedMap[Long, D] = SortedMap.empty[Long, D],
 ) {
 
   /** Determine the lastly known data tick, if available. Includes the given

src/main/scala/edu/ie3/simona/agent/participant/hp/HpAgentFundamentals.scala

@@ -261,8 +261,26 @@
       currentTick,
       updatedState,
     )
-    val updatedBaseStateData =
-      baseStateData.copy(stateDataStore = updatedStateDataStore)
+
+    val updatedBaseStateData = {
+      updatedState.maybeThermalThreshold match {
+        case Some(nextThreshold)
+            if baseStateData.foreseenDataTicks.headOption.exists {
+              case (_, Some(tick)) => nextThreshold.tick < tick
+              case _               => false
+            } =>
+          baseStateData.copy(
+            stateDataStore = updatedStateDataStore,
+            additionalActivationTicks =
+              baseStateData.additionalActivationTicks + nextThreshold.tick,
+          )
+        case _ =>
+          baseStateData.copy(
+            stateDataStore = updatedStateDataStore
+          )
+      }
+    }
+
     updateValueStoresInformListenersAndGoToIdleWithUpdatedBaseStateData(
       scheduler,
       updatedBaseStateData,
@@ -293,7 +311,11 @@
       calcRelevantData: HpRelevantData,
       nodalVoltage: squants.Dimensionless,
       model: HpModel,
-  ): HpState = model.determineState(modelState, calcRelevantData)
+  ): HpState = {
+    val (canOperate, canBeOutOfOperation, state) =
+      model.determineState(modelState, calcRelevantData)
+    state
+  }
 
   /** Abstract definition, individual implementations found in individual agent
     * fundamental classes
@@ -385,25 +407,44 @@
       tick: Long,
   ): HpRelevantData = {
     /* extract weather data from secondary data, which should have been requested and received before */
-    val weatherData =
-      baseStateData.receivedSecondaryDataStore
+    val weatherData = {
+      val currentWeatherData = baseStateData.receivedSecondaryDataStore
         .last(tick)
         .flatMap { case (receivedTick, receivedValues) =>
-          if (receivedTick != tick)
-            log.debug(
-              s"The model ${baseStateData.model.getUuid} needs to do calculations with values received " +
-                s"in tick $receivedTick, as no weather data has been received in tick $tick."
-            )
-          receivedValues.collectFirst {
-            // filter secondary data for weather data
-            case (_, data: WeatherData) => data
+          if (receivedTick == tick) {
+            receivedValues.collectFirst { case (_, data: WeatherData) =>
+              data
+            }
+          } else None
+        }
+
+      // If current weather data is not found, fallback to the latest entry where the map is not empty
+      currentWeatherData
+        .orElse {
+          val latestEntry =
+            baseStateData.receivedSecondaryDataStore.store.toSeq.findLast {
+              case (_, receivedValues) => receivedValues.nonEmpty
+            }
+
+          latestEntry.flatMap { case (receivedTick, receivedValues) =>
+            if (tick - receivedTick > 3600) {
+              log.warning(
+                s"The model ${baseStateData.model.getUuid} is using weather data from tick $receivedTick, " +
+                  s"but there is a discrepancy of ${tick - receivedTick} seconds compared to the current tick $tick."
+              )
+            }
+
+            receivedValues.collectFirst { case (_, data: WeatherData) =>
+              data
+            }
           }
         }
-        .getOrElse(
+        .getOrElse {
           throw new InconsistentStateException(
             s"The model ${baseStateData.model} was not provided with needed weather data."
           )
-        )
+        }
+    }
 
     HpRelevantData(
       tick,

src/main/scala/edu/ie3/simona/model/participant/HpModel.scala

@@ -11,15 +11,17 @@ import edu.ie3.simona.agent.participant.data.Data.PrimaryData.ApparentPowerAndHe
 import edu.ie3.simona.model.SystemComponent
 import edu.ie3.simona.model.participant.HpModel.{HpRelevantData, HpState}
 import edu.ie3.simona.model.participant.control.QControl
-import edu.ie3.simona.model.thermal.ThermalGrid.ThermalGridState
+import edu.ie3.simona.model.thermal.ThermalGrid.{
+  ThermalEnergyDemand,
+  ThermalGridState,
+}
 import edu.ie3.simona.model.thermal.{ThermalGrid, ThermalThreshold}
 import edu.ie3.simona.ontology.messages.flex.FlexibilityMessage.ProvideFlexOptions
 import edu.ie3.simona.ontology.messages.flex.MinMaxFlexibilityMessage.ProvideMinMaxFlexOptions
 import edu.ie3.util.quantities.PowerSystemUnits
 import edu.ie3.util.scala.OperationInterval
-import edu.ie3.util.scala.quantities.DefaultQuantities
 import edu.ie3.util.scala.quantities.DefaultQuantities._
-import squants.energy.Kilowatts
+import squants.energy.{Energy, KilowattHours, Kilowatts}
 import squants.{Power, Temperature}
 
 import java.time.ZonedDateTime
@@ -116,19 +118,23 @@ final case class HpModel(
     * function calculates the heat pump's next state to get the actual active
     * power of this state use [[calculateActivePower]] with the generated state
     *
-    * @param state
-    *   Current state of the heat pump
+    * @param lastState
+    *   Last state of the heat pump
     * @param relevantData
     *   data of heat pump including
     * @return
-    *   next [[HpState]]
+    *   Booleans if Hp can operate and can be out of operation plus next
+    *   [[HpState]]
     */
   def determineState(
-      state: HpState,
+      lastState: HpState,
       relevantData: HpRelevantData,
-  ): HpState = {
-    val turnOn = operatesInNextState(state, relevantData)
-    calcState(state, relevantData, turnOn)
+  ): (Boolean, Boolean, HpState) = {
+    val (turnOn, canOperate, canBeOutOfOperation, houseDemand, storageDemand) =
+      operatesInNextState(lastState, relevantData)
+    val updatedState =
+      calcState(lastState, relevantData, turnOn, houseDemand, storageDemand)
+    (canOperate, canBeOutOfOperation, updatedState)
   }
 
   /** Depending on the input, this function decides whether the heat pump will
@@ -142,18 +148,42 @@ final case class HpModel(
     * @param relevantData
     *   Relevant (external) data
     * @return
-    *   boolean defining if heat pump runs in next time step
+    *   boolean defining if heat pump runs in next time step, if it can be in
+    *   operation and out of operation plus the demand of house and storage
     */
   private def operatesInNextState(
       state: HpState,
       relevantData: HpRelevantData,
-  ): Boolean = {
-    val demand = thermalGrid.energyDemand(
-      relevantData.currentTick,
-      relevantData.ambientTemperature,
-      state.thermalGridState,
+  ): (Boolean, Boolean, Boolean, ThermalEnergyDemand, ThermalEnergyDemand) = {
+    val (demandHouse, demandStorage, updatedState) =
+      thermalGrid.energyDemandAndUpdatedState(
+        relevantData.currentTick,
+        relevantData.ambientTemperature,
+        state.thermalGridState,
+      )
+    implicit val tolerance: Energy = KilowattHours(1e-3)
+    val noStorageOrStorageIsEmpty: Boolean =
+      updatedState.storageState.isEmpty || updatedState.storageState.exists(
+        _.storedEnergy =~ zeroKWH
+      )
+
+    val turnHpOn: Boolean = {
+      (demandHouse.hasRequiredDemand && noStorageOrStorageIsEmpty) || demandStorage.hasRequiredDemand || (state.isRunning && demandHouse.hasAdditionalDemand) || (state.isRunning && demandStorage.hasAdditionalDemand)
+    }
+
+    val canOperate =
+      demandHouse.hasRequiredDemand || demandHouse.hasAdditionalDemand ||
+        demandStorage.hasRequiredDemand || demandStorage.hasAdditionalDemand
+    val canBeOutOfOperation =
+      !(demandHouse.hasRequiredDemand && noStorageOrStorageIsEmpty)
+
+    (
+      turnHpOn,
+      canOperate,
+      canBeOutOfOperation,
+      demandHouse,
+      demandStorage,
     )
-    demand.hasRequiredDemand || (state.isRunning && demand.hasAdditionalDemand)
   }
 
   /** Calculate state depending on whether heat pump is needed or not. Also
@@ -166,18 +196,30 @@ final case class HpModel(
     *   data of heat pump including state of the heat pump
     * @param isRunning
     *   determines whether the heat pump is running or not
+    * @param houseDemand
+    *   determines if the thermal house has heat demand
+    * @param storageDemand
+    *   determines if the thermal storage has heat demand
     * @return
     *   next [[HpState]]
     */
   private def calcState(
       state: HpState,
       relevantData: HpRelevantData,
       isRunning: Boolean,
+      houseDemand: ThermalEnergyDemand,
+      storageDemand: ThermalEnergyDemand,
   ): HpState = {
+    val lastStateStorageqDot = state.thermalGridState.storageState
+      .map(_.qDot)
+      .getOrElse(zeroKW)
+
     val (newActivePower, newThermalPower) =
       if (isRunning)
         (pRated, pThermal)
-      else (DefaultQuantities.zeroKW, DefaultQuantities.zeroKW)
+      else if (lastStateStorageqDot < zeroKW)
+        (zeroKW, lastStateStorageqDot * (-1))
+      else (zeroKW, zeroKW)
 
     /* Push thermal energy to the thermal grid and get its updated state in return */
     val (thermalGridState, maybeThreshold) =
@@ -186,6 +228,8 @@ final case class HpModel(
         state.thermalGridState,
         state.ambientTemperature.getOrElse(relevantData.ambientTemperature),
         newThermalPower,
+        houseDemand,
+        storageDemand,
       )
 
     HpState(
@@ -204,23 +248,14 @@ final case class HpModel(
       lastState: HpState,
   ): ProvideFlexOptions = {
     /* Determine the operating state in the given tick */
-    val updatedState = determineState(lastState, data)
-
-    /* Determine the options we have */
-    val thermalEnergyDemand = thermalGrid.energyDemand(
-      data.currentTick,
-      data.ambientTemperature,
-      lastState.thermalGridState,
-    )
-    val canOperate =
-      thermalEnergyDemand.hasRequiredDemand || thermalEnergyDemand.hasAdditionalDemand
-    val canBeOutOfOperation = !thermalEnergyDemand.hasRequiredDemand
+    val (canOperate, canBeOutOfOperation, updatedHpState)
+        : (Boolean, Boolean, HpState) = determineState(lastState, data)
 
     val lowerBoundary =
       if (canBeOutOfOperation)
         zeroKW
       else
-        updatedState.activePower
+        updatedHpState.activePower
     val upperBoundary =
       if (canOperate)
         sRated * cosPhiRated
@@ -229,7 +264,7 @@ final case class HpModel(
 
     ProvideMinMaxFlexOptions(
       uuid,
-      updatedState.activePower,
+      updatedHpState.activePower,
       lowerBoundary,
       upperBoundary,
     )
@@ -259,13 +294,32 @@ final case class HpModel(
   ): (HpState, FlexChangeIndicator) = {
     /* If the setpoint value is above 50 % of the electrical power, turn on the heat pump otherwise turn it off */
     val turnOn = setPower > (sRated * cosPhiRated * 0.5)
-    val updatedState = calcState(lastState, data, turnOn)
+
+    val (
+      thermalEnergyDemandHouse,
+      thermalEnergyDemandStorage,
+      updatedThermalGridState,
+    ) =
+      thermalGrid.energyDemandAndUpdatedState(
+        data.currentTick,
+        data.ambientTemperature,
+        lastState.thermalGridState,
+      )
+
+    val updatedHpState: HpState =
+      calcState(
+        lastState,
+        data,
+        turnOn,
+        thermalEnergyDemandHouse,
+        thermalEnergyDemandStorage,
+      )
 
     (
-      updatedState,
+      updatedHpState,
       FlexChangeIndicator(
         changesAtNextActivation = true,
-        updatedState.maybeThermalThreshold.map(_.tick),
+        updatedHpState.maybeThermalThreshold.map(_.tick),
       ),
     )
   }