The Weights API is now used in the modeling equations:

  Changes made:

  1. elements.py - Flow tracking:
  # Before:
  flow_hours = self.flow_rate * self._model.timestep_duration
  weighted_flow_hours = flow_hours * self._model.cluster_weight
  tracked_expression=weighted_flow_hours.sum(self._model.temporal_dims)

  # After:
  tracked_expression=self._model.weights.sum_temporal(self.flow_rate)
  2. elements.py - Load factor total hours:
  # Before:
  total_hours = (self._model.timestep_duration * self._model.cluster_weight).sum(self._model.temporal_dims)

  # After:
  total_hours = self._model.weights.temporal.sum(self._model.weights.temporal_dims)
  3. features.py - Status tracking:
  # Before:
  active_hours = self.status * self._model.timestep_duration
  weighted_active_hours = active_hours * self._model.cluster_weight
  tracked_expression=weighted_active_hours.sum(self._model.temporal_dims)

  # After:
  tracked_expression=self._model.weights.sum_temporal(self.status)
  4. features.py - Temporal effects summing (only needs cluster weight since already per-timestep):
  # Before:
  weighted_per_timestep = self.total_per_timestep * self._model.cluster_weight
  temporal_dims = [d for d in self.total_per_timestep.dims if d not in ('period', 'scenario')]

  # After:
  weighted_per_timestep = self.total_per_timestep * self._model.weights.cluster
  self._eq_total.lhs -= weighted_per_timestep.sum(dim=self._model.weights.temporal_dims)

Author: FBumann

flixopt/elements.py

@@ -677,13 +677,10 @@ def _do_modeling(self):
         self._constraint_flow_rate()
 
         # Total flow hours tracking (per period)
-        # Sum over temporal dimensions, weighted by cluster_weight
-        flow_hours = self.flow_rate * self._model.timestep_duration
-        weighted_flow_hours = flow_hours * self._model.cluster_weight
         ModelingPrimitives.expression_tracking_variable(
             model=self,
             name=f'{self.label_full}|total_flow_hours',
-            tracked_expression=weighted_flow_hours.sum(self._model.temporal_dims),
+            tracked_expression=self._model.weights.sum_temporal(self.flow_rate),
             bounds=(
                 self.element.flow_hours_min if self.element.flow_hours_min is not None else 0,
                 self.element.flow_hours_max if self.element.flow_hours_max is not None else None,
@@ -840,8 +837,8 @@ def _create_bounds_for_load_factor(self):
         # Get the size (either from element or investment)
         size = self.investment.size if self.with_investment else self.element.size
 
-        # Sum over temporal dimensions, weighted by cluster_weight
-        total_hours = (self._model.timestep_duration * self._model.cluster_weight).sum(self._model.temporal_dims)
+        # Total hours in the period (sum of temporal weights)
+        total_hours = self._model.weights.temporal.sum(self._model.weights.temporal_dims)
 
         # Maximum load factor constraint
         if self.element.load_factor_max is not None:

flixopt/features.py

@@ -196,14 +196,11 @@ def _do_modeling(self):
             inactive = self.add_variables(binary=True, short_name='inactive', coords=self._model.get_coords())
             self.add_constraints(self.status + inactive == 1, short_name='complementary')
 
-        # 3. Total duration tracking using existing pattern
-        # Sum over temporal dimensions, weighted by cluster_weight
-        active_hours = self.status * self._model.timestep_duration
-        weighted_active_hours = active_hours * self._model.cluster_weight
-        total_hours = (self._model.timestep_duration * self._model.cluster_weight).sum(self._model.temporal_dims)
+        # 3. Total duration tracking
+        total_hours = self._model.weights.temporal.sum(self._model.weights.temporal_dims)
         ModelingPrimitives.expression_tracking_variable(
             self,
-            tracked_expression=weighted_active_hours.sum(self._model.temporal_dims),
+            tracked_expression=self._model.weights.sum_temporal(self.status),
             bounds=(
                 self.parameters.active_hours_min if self.parameters.active_hours_min is not None else 0,
                 self.parameters.active_hours_max
@@ -630,10 +627,8 @@ def _do_modeling(self):
 
             # Add it to the total (cluster_weight handles cluster representation, defaults to 1.0)
             # Sum over all temporal dimensions (time, and cluster if present)
-            weighted_per_timestep = self.total_per_timestep * self._model.cluster_weight
-            # Get temporal_dims from total_per_timestep (linopy Variable) - its coords are the actual dims
-            temporal_dims = [d for d in self.total_per_timestep.dims if d not in ('period', 'scenario')]
-            self._eq_total.lhs -= weighted_per_timestep.sum(dim=temporal_dims)
+            weighted_per_timestep = self.total_per_timestep * self._model.weights.cluster
+            self._eq_total.lhs -= weighted_per_timestep.sum(dim=self._model.weights.temporal_dims)
 
     def add_share(
         self,