Correct cost calculations and storage operation

assume/common/base.py

@@ -225,6 +225,17 @@
                     cashflow * hours
                 )
 
+    def get_starting_costs(self, op_time: int):
+        """
+        op_time is hours running from get_operation_time
+        returns the costs if start_up is planned
+        :param op_time: operation time
+        :type op_time: int
+        :return: start_costs
+        :rtype: float
+        """
+        return 0
+
 
 class SupportsMinMax(BaseUnit):
     """
@@ -368,6 +379,75 @@
             runn += 1
         return (-1) ** is_off * runn
 
+    def get_average_operation_times(self, start: datetime):
+        """
+        calculates the average uninterupted operation time
+        :param start: the current time
+        :type start: datetime
+        :return: avg_op_time
+        :rtype: float
+        :return: avg_down_time
+        :rtype: float
+        """
+        op_series = []
+
+        before = start - self.index.freq
+        arr = self.outputs["energy"][self.index[0] : before][::-1] > 0
+
+        if len(arr) < 1:
+            # before start of index
+            return self.min_operating_time, self.min_down_time
+
+        op_series = []
+        status = arr.iloc[0]
+        runn = 0
+        for val in arr:
+            if val == status:
+                runn += 1
+            else:
+                op_series.append(-((-1) ** status) * runn)
+                runn = 0
+                status = val
+        op_series.append(-((-1) ** status) * runn)
+
+        op_times = [operation for operation in op_series if operation > 0]
+        if op_times == []:
+            avg_op_time = self.min_operating_time
+        else:
+            avg_op_time = sum(op_times) / len(op_times)
+
+        down_times = [operation for operation in op_series if operation < 0]
+        if down_times == []:
+            avg_down_time = self.min_down_time
+        else:
+            avg_down_time = abs(sum(down_times) / len(down_times))
+
+        return max(1, avg_op_time), max(1, avg_down_time)
+
+    def get_starting_costs(self, op_time: int):
+        """
+        op_time is hours running from get_operation_time
+        returns the costs if start_up is planned
+        :param op_time: operation time
+        :type op_time: int
+        :return: start_costs
+        :rtype: float
+        """
+        if op_time > 0:
+            # unit is running
+            return 0
+
+        if self.downtime_hot_start is not None and self.hot_start_cost is not None:
+            if -op_time <= self.downtime_hot_start:
+                return self.hot_start_cost
+        if self.downtime_warm_start is not None and self.warm_start_cost is not None:
+            if -op_time <= self.downtime_warm_start:
+                return self.warm_start_cost
+        if self.cold_start_cost is not None:
+            return self.cold_start_cost
+
+        return 0
+
 
 class SupportsMinMaxCharge(BaseUnit):
     """
@@ -473,7 +553,7 @@
         :return: the SoC before the given datetime
         :rtype: float
         """
-        if dt - self.index.freq < self.index[0]:
+        if dt - self.index.freq <= self.index[0]:
             return self.initial_soc
         else:
             return self.outputs["soc"].at[dt - self.index.freq]
@@ -493,7 +573,7 @@
 
     def calculate_ramp_discharge(
         self,
-        previous_soc: float,
+        soc: float,
         previous_power: float,
         power_discharge: float,
         current_power: float = 0,
@@ -539,7 +619,7 @@
 
     def calculate_ramp_charge(
         self,
-        previous_soc: float,
+        soc: float,
         previous_power: float,
         power_charge: float,
         current_power: float = 0,

assume/common/forecasts.py

@@ -328,7 +328,7 @@ def __getitem__(self, column: str) -> pd.Series:
             value = self.fuel_price
         elif "demand" in column:
             value = self.demand
-        elif column == "price_forecast":
+        elif column == "price_EOM":
             value = self.price_forecast
         else:
             value = 0

assume/common/units_operator.py

@@ -220,12 +220,13 @@ def write_actual_dispatch(self):
             current_dispatch.name = "power"
             data = pd.DataFrame(current_dispatch)
             data["soc"] = unit.outputs["soc"][start:end]
-            # TODO make that right for all products
+
             for key in unit.outputs.keys():
-                if "energy_cashflow" in key:
+                if "cashflow" in key:
                     data[key] = unit.outputs[key][start:end]
-
-                if "energy_marginal_costs" in key:
+                if "marginal_costs" in key:
+                    data[key] = unit.outputs[key][start:end]
+                if "total_costs" in key:
                     data[key] = unit.outputs[key][start:end]
 
             data["unit"] = unit_id

assume/markets/clearing_algorithms/complex_clearing.py

@@ -322,8 +322,8 @@ def extract_results(
         meta.append(
             {
                 "supply_volume": supply_volume,
-                "demand_volume": demand_volume,
-                "demand_volume_energy": demand_volume * duration_hours,
+                "demand_volume": -demand_volume,
+                "demand_volume_energy": -demand_volume * duration_hours,
                 "supply_volume_energy": supply_volume * duration_hours,
                 "price": clear_price,
                 "max_price": clear_price,

assume/strategies/dmas_powerplant.py

@@ -538,7 +538,7 @@ def calculate_bids(
         hour_count = len(product_tuples)
         hour_count2 = hour_count * 2
 
-        base_price = unit.forecaster["price_forecast"][
+        base_price = unit.forecaster["price_EOM"][
             start : start + timedelta(hours=hour_count2 - 1)
         ]
         e_price = unit.forecaster.get_price("co2")[

assume/strategies/dmas_storage.py

@@ -188,12 +188,12 @@ def optimize_result(self, unit: SupportsMinMaxCharge, committed_power: np.array)
             )
         abs_difference = [self.model.plus[t] + self.model.minus[t] for t in time_range]
         costs = [
-            abs_difference[t] * np.abs(unit.forecaster["price_forecast"][t] * 2)
+            abs_difference[t] * np.abs(unit.forecaster["price_EOM"][t] * 2)
             for t in time_range
         ]
 
         profit = [
-            -self.power[t] * unit.forecaster["price_forecast"][t] - costs[t]
+            -self.power[t] * unit.forecaster["price_EOM"][t] - costs[t]
             for t in time_range
         ]
         self.model.obj = Objective(
@@ -223,7 +223,7 @@ def optimize(
         opt_results = {key: np.zeros(hour_count) for key in PRICE_FUNCS.keys()}
         time_range = range(hour_count)
 
-        base_price = unit.forecaster["price_forecast"][
+        base_price = unit.forecaster["price_EOM"][
             start : start + timedelta(hours=hour_count)
         ]
 
@@ -286,7 +286,7 @@ def calculate_bids(
         opt_results = self.optimize(unit, start, hour_count)
         total_orders = {}
         block_id = 0
-        power_prices = unit.forecaster["price_forecast"][
+        power_prices = unit.forecaster["price_EOM"][
             start : start + timedelta(hours=hour_count)
         ]
         for key, power in opt_results.items():