Feature/gsye 891

src/gsy_e/constants.py

@@ -107,3 +107,20 @@ class HeatPumpSettingsDefaultParameters:
 
 # Set the precision of the decimal numbers used in the simulation.
 getcontext().prec = 12
+
+
+class SorTesConfiguration:
+    """Collection of SorTes heat tank configuration parameters."""
+
+    MINUTES_BEFORE_SWITCH_ALLOWED = 1 * 60
+    MINUTES_TIME_HORIZONT_LOW_RATES = 1 * 60
+    PREFERRED_BUYING_RATE = 20
+    MIN_SOC_TOLERANCE = 10
+    MAX_SOC_TOLERANCE = 90
+    CAPACITY_KWH = 25
+    COP_HEAT_SOURCE = 1
+    COP_CONDENSER = 35  # nominal value for SHSL-D1-005-1x350
+    COP_EVAPORATOR = 1
+    CONVERSION_CHARGE_CONDENSER_POWER = 1 / 1.2
+    CONVERSION_DISCHARGE_EVAPORATOR_POWER = 1 / 1.2
+    AMBIENT_TEMPERATURE_CORRECTION = 5

src/gsy_e/gsy_e_core/sim_results/file_export_endpoints.py

@@ -16,7 +16,7 @@
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-# pylint: disable=too-many-return-statements, broad-exception-raised
+# pylint: disable=too-many-return-statements, broad-exception-raised, too-many-locals
 from abc import ABC, abstractmethod
 from typing import Dict, List
 
@@ -33,6 +33,7 @@
     MultipleTankHeatPumpStrategy,
     HeatPumpStrategyWithoutTanks,
 )
+from gsy_e.models.strategy.heatpump_with_sortes_tank import HeatPumpWithSorTesTankStrategy
 from gsy_e.models.strategy.load_hours import LoadHoursStrategy
 from gsy_e.models.strategy.pv import PVStrategy
 from gsy_e.models.strategy.storage import StorageStrategy
@@ -50,6 +51,14 @@ def is_heatpump_strategy_without_tanks(area: Area):
     )
 
 
+def is_heatpump_strategy_with_sortes_tank(area: Area):
+    """Return if area has a heat pump strategy with Sortes tanks connected."""
+    return isinstance(
+        area.strategy,
+        HeatPumpWithSorTesTankStrategy,
+    )
+
+
 def is_heatpump_strategy_with_tanks(area: Area):
     """Return if area has a heat pump strategy."""
     return isinstance(
@@ -407,6 +416,49 @@ def _row(self, slot, market):
         return rows
 
 
+class HeatPumpWithSortesTankDataExporter(BaseDataExporter):
+    """Data exporter dedicated to heat pump areas"""
+
+    def __init__(self, area, past_markets):
+        assert is_heatpump_strategy_with_sortes_tank(area)
+        self.area = area
+        self.past_markets = past_markets
+
+    @property
+    def labels(self) -> List:
+        return [
+            "slot",
+            "energy traded [kWh]",
+            "COP",
+            "heat demand [kJ]",
+            "SOC",
+            "auxiliary_energy_kWh",
+            "energy_used_for_dis_charging_kWh",
+        ]
+
+    @property
+    def rows(self) -> List:
+        return [self._row(market.time_slot, market) for market in self.past_markets]
+
+    def _traded(self, market):
+        return (
+            market.traded_energy[self.area.name] if self.area.name in market.traded_energy else 0
+        )
+
+    def _row(self, slot, market):
+        rows = [slot]
+        hp_stats = self.area.strategy.state.get_results_dict(slot)
+        rows += [
+            round(self._traded(market), ROUND_TOLERANCE_EXPORT),
+            round(hp_stats["cop"], ROUND_TOLERANCE_EXPORT),
+            round(hp_stats["heat_demand_kJ"], ROUND_TOLERANCE_EXPORT),
+            round(hp_stats["soc"], ROUND_TOLERANCE_EXPORT),
+            round(hp_stats["auxiliary_energy_kWh"], 4),
+            round(hp_stats["energy_used_for_dis_charging_kWh"], 4),
+        ]
+        return rows
+
+
 class FileExportEndpoints:
     """Handle data preparation for csv-file and plot export."""
 
@@ -439,6 +491,8 @@ def export_data_factory(
                 return HeatPumpDataExporter(area, area.parent.past_markets)
             if is_heatpump_strategy_without_tanks(area):
                 return HeatPumpWithoutTanksDataExporter(area, area.parent.past_markets)
+            if is_heatpump_strategy_with_sortes_tank(area):
+                return HeatPumpWithSortesTankDataExporter(area, area.parent.past_markets)
             return LeafDataExporter(area, area.parent.past_markets)
         if past_market_type == AvailableMarketTypes.BALANCING:
             return BalancingDataExporter(area.past_balancing_markets)

src/gsy_e/models/strategy/energy_parameters/heatpump/heat_pump.py

@@ -383,7 +383,8 @@ def combined_state(self) -> CombinedHeatpumpTanksState:
         """Combined heatpump and tanks state."""
         return self._state
 
-    def last_time_slot(self, current_market_slot: DateTime) -> DateTime:
+    @staticmethod
+    def last_time_slot(current_market_slot: DateTime) -> DateTime:
         """Calculate the previous time slot from the current one."""
         return current_market_slot - GlobalConfig.slot_length
 

src/gsy_e/models/strategy/heat_pump.py

@@ -2,8 +2,7 @@
 from typing import Dict, TYPE_CHECKING, Optional, Union, List
 from decimal import Decimal
 
-from gsy_framework.constants_limits import ConstSettings
-from gsy_framework.constants_limits import FLOATING_POINT_TOLERANCE
+from gsy_framework.constants_limits import ConstSettings, FLOATING_POINT_TOLERANCE
 from gsy_framework.data_classes import Trade, TraderDetails
 from gsy_framework.enums import AvailableMarketTypes
 from gsy_framework.exceptions import GSyException
@@ -272,8 +271,7 @@ def __init__(
         )
 
     def _init_price_params(self, order_updater_parameters, preferred_buying_rate):
-        self.use_default_updater_params: bool = not order_updater_parameters
-        if self.use_default_updater_params:
+        if not order_updater_parameters:
             order_updater_parameters = {
                 AvailableMarketTypes.SPOT: HeatPumpOrderUpdaterParameters()
             }
@@ -423,8 +421,7 @@ def serialize(self):
         }
 
     def _init_price_params(self, order_updater_parameters):
-        self.use_default_updater_params: bool = not order_updater_parameters
-        if self.use_default_updater_params:
+        if not order_updater_parameters:
             order_updater_parameters = {
                 AvailableMarketTypes.SPOT: HeatPumpOrderUpdaterParameters()
             }

src/gsy_e/models/strategy/heat_pump_soc_management.py

@@ -73,7 +73,7 @@ def event_activate(self):
         else:
             assert False, "GlobalConfig.market_maker_rate was not initiated yet."
 
-    def calculate(self, time_slot: DateTime, _buy_rate: float = 0.0):
+    def calculate(self, time_slot: DateTime, buy_rate: float = 0.0):
         """
         Calculate the bid energy depending on the current state of the heat pump, the current SOC
         and whether the market maker rate is cheap or expensive compared to the average market
@@ -83,13 +83,10 @@ def calculate(self, time_slot: DateTime, _buy_rate: float = 0.0):
         if not self._is_time_for_state_change(time_slot):
             # If state change is not possible, but at the same time the soc is below the min or
             # above the max SOC value of the tank, then maintain the SOC.
-            if self._charger.get_average_soc(time_slot) >= self.MAX_SOC_TOLERANCE:
-                target_state = HeatPumpChargingState.MAINTAIN_SOC
-            if self._charger.get_average_soc(time_slot) <= self.MIN_SOC_TOLERANCE:
-                target_state = HeatPumpChargingState.MAINTAIN_SOC
+            target_state = self._handle_state_at_soc_limits(time_slot, target_state)
         else:
             # If the state change is possible, check the market maker rate to set the new state
-            target_state = self._should_charge_or_discharge(time_slot)
+            target_state = self._should_charge_or_discharge(time_slot, buy_rate)
             if self._current_state != target_state:
                 # If the target state is the same as the current state, do nothing. Otherwise,
                 # update the current state and the last switch timestamp.
@@ -98,13 +95,32 @@ def calculate(self, time_slot: DateTime, _buy_rate: float = 0.0):
 
         return self._get_energy_from_target_state(target_state, time_slot)
 
+    def _handle_state_at_soc_limits(
+        self, time_slot: DateTime, current_state: HeatPumpChargingState
+    ) -> HeatPumpChargingState:
+        # If state change is not possible, but at the same time the soc is below the min or
+        # above the max SOC value of the tank, then maintain the SOC.
+        target_state = current_state
+        if self._get_tank_soc(time_slot) >= self.MAX_SOC_TOLERANCE:
+            target_state = HeatPumpChargingState.MAINTAIN_SOC
+        if self._get_tank_soc(time_slot) <= self.MIN_SOC_TOLERANCE:
+            target_state = HeatPumpChargingState.MAINTAIN_SOC
+        return target_state
+
+    def _get_tank_soc(self, time_slot: DateTime) -> float:
+        return self._charger.get_average_soc(time_slot)
+
     def _is_time_for_state_change(self, time_slot: DateTime) -> bool:
         if not self._last_switch:
             # If the last_switch has not been set yet, the simulation is starting and no switch has
             # occurred yet. Change state if needed.
             self._last_switch = time_slot
             return True
-        if time_slot - self._last_switch < duration(minutes=self.MINUTES_BEFORE_SWITCH_ALLOWED):
+        if (
+            self._current_state != HeatPumpChargingState.MAINTAIN_SOC
+            and time_slot - self._last_switch
+            < duration(minutes=self.MINUTES_BEFORE_SWITCH_ALLOWED)
+        ):
             # If not enough time has passed since the last switch, do not allow state change.
             return False
         # Otherwise, allow the state change.
@@ -119,20 +135,26 @@ def _get_energy_from_target_state(
             return self._energy_params.get_min_energy_demand_kWh(time_slot)
         return self._energy_params.get_energy_demand_kWh(time_slot)
 
-    def _should_charge_or_discharge(self, time_slot: DateTime) -> HeatPumpChargingState:
-        if GlobalConfig.market_maker_rate[time_slot] <= self._average_rate:
+    def _should_charge_or_discharge(
+        self, time_slot: DateTime, buy_rate: float
+    ) -> HeatPumpChargingState:
+
+        if self._is_energy_affordable(time_slot, buy_rate):
             # If the market maker rate is lower than the average rate, charge except if the SOC is
             # too high.
-            if self._charger.get_average_soc(time_slot) >= self.MAX_SOC_TOLERANCE:
+            if self._get_tank_soc(time_slot) >= self.MAX_SOC_TOLERANCE:
                 return HeatPumpChargingState.MAINTAIN_SOC
             return HeatPumpChargingState.CHARGE
 
         # If the market maker rate is higher than the average rate, discharge except if the SOC
         # is too low.
-        if self._charger.get_average_soc(time_slot) > self.MIN_SOC_TOLERANCE:
+        if self._get_tank_soc(time_slot) > self.MIN_SOC_TOLERANCE:
             return HeatPumpChargingState.DISCHARGE
         return HeatPumpChargingState.MAINTAIN_SOC
 
+    def _is_energy_affordable(self, time_slot: DateTime, _buy_rate: float) -> bool:
+        return GlobalConfig.market_maker_rate[time_slot] <= self._average_rate
+
 
 def heat_pump_soc_management_factory(
     energy_params: "HeatPumpEnergyParameters", preferred_buying_rate: float