Improve fit_to_model_coords

FBumann · FBumann · commit 1ad03c9cd48c · 2025-08-13T20:07:58.000+02:00
diff --git a/flixopt/components.py b/flixopt/components.py
@@ -223,29 +223,29 @@ def transform_data(self, flow_system: 'FlowSystem') -> None:
         )
         if not isinstance(self.initial_charge_state, str):
             self.initial_charge_state = flow_system.fit_to_model_coords(
-                f'{self.label_full}|initial_charge_state', self.initial_charge_state, has_time_dim=False
+                f'{self.label_full}|initial_charge_state', self.initial_charge_state, dims=['year', 'scenario']
             )
         self.minimal_final_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimal_final_charge_state', self.minimal_final_charge_state, has_time_dim=False
+            f'{self.label_full}|minimal_final_charge_state', self.minimal_final_charge_state, dims=['year', 'scenario']
         )
         self.maximal_final_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximal_final_charge_state', self.maximal_final_charge_state, has_time_dim=False
+            f'{self.label_full}|maximal_final_charge_state', self.maximal_final_charge_state, dims=['year', 'scenario']
         )
         self.relative_minimum_final_charge_state = flow_system.fit_to_model_coords(
             f'{self.label_full}|relative_minimum_final_charge_state',
             self.relative_minimum_final_charge_state,
-            has_time_dim=False,
+            dims=['year', 'scenario'],
         )
         self.relative_maximum_final_charge_state = flow_system.fit_to_model_coords(
             f'{self.label_full}|relative_maximum_final_charge_state',
             self.relative_maximum_final_charge_state,
-            has_time_dim=False,
+            dims=['year', 'scenario'],
         )
         if isinstance(self.capacity_in_flow_hours, InvestParameters):
             self.capacity_in_flow_hours.transform_data(flow_system, f'{self.label_full}|InvestParameters')
         else:
             self.capacity_in_flow_hours = flow_system.fit_to_model_coords(
-                f'{self.label_full}|capacity_in_flow_hours', self.capacity_in_flow_hours, has_time_dim=False
+                f'{self.label_full}|capacity_in_flow_hours', self.capacity_in_flow_hours, dims=['year', 'scenario']
             )
 
     def _plausibility_checks(self) -> None:
diff --git a/flixopt/effects.py b/flixopt/effects.py
@@ -105,27 +105,30 @@ def transform_data(self, flow_system: 'FlowSystem'):
         )
 
         self.minimum_operation = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimum_operation', self.minimum_operation, has_time_dim=False
+            f'{self.label_full}|minimum_operation', self.minimum_operation, dims=['year', 'scenario']
         )
         self.maximum_operation = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_operation', self.maximum_operation, has_time_dim=False
+            f'{self.label_full}|maximum_operation', self.maximum_operation, dims=['year', 'scenario']
         )
         self.minimum_invest = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimum_invest', self.minimum_invest, has_time_dim=False
+            f'{self.label_full}|minimum_invest', self.minimum_invest, dims=['year', 'scenario']
         )
         self.maximum_invest = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_invest', self.maximum_invest, has_time_dim=False
+            f'{self.label_full}|maximum_invest', self.maximum_invest, dims=['year', 'scenario']
         )
         self.minimum_total = flow_system.fit_to_model_coords(
             f'{self.label_full}|minimum_total',
             self.minimum_total,
-            has_time_dim=False,
+            dims=['year', 'scenario'],
         )
         self.maximum_total = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_total', self.maximum_total, has_time_dim=False
+            f'{self.label_full}|maximum_total', self.maximum_total, dims=['year', 'scenario']
         )
         self.specific_share_to_other_effects_invest = flow_system.fit_effects_to_model_coords(
-            f'{self.label_full}|invest->', self.specific_share_to_other_effects_invest, 'invest', has_time_dim=False
+            f'{self.label_full}|invest->',
+            self.specific_share_to_other_effects_invest,
+            'invest',
+            dims=['year', 'scenario'],
         )
 
     def create_model(self, model: FlowSystemModel) -> 'EffectModel':
diff --git a/flixopt/elements.py b/flixopt/elements.py
@@ -252,24 +252,24 @@ def transform_data(self, flow_system: 'FlowSystem'):
             self.label_full, self.effects_per_flow_hour, 'per_flow_hour'
         )
         self.flow_hours_total_max = flow_system.fit_to_model_coords(
-            f'{self.label_full}|flow_hours_total_max', self.flow_hours_total_max, has_time_dim=False
+            f'{self.label_full}|flow_hours_total_max', self.flow_hours_total_max, dims=['year', 'scenario']
         )
         self.flow_hours_total_min = flow_system.fit_to_model_coords(
-            f'{self.label_full}|flow_hours_total_min', self.flow_hours_total_min, has_time_dim=False
+            f'{self.label_full}|flow_hours_total_min', self.flow_hours_total_min, dims=['year', 'scenario']
         )
         self.load_factor_max = flow_system.fit_to_model_coords(
-            f'{self.label_full}|load_factor_max', self.load_factor_max, has_time_dim=False
+            f'{self.label_full}|load_factor_max', self.load_factor_max, dims=['year', 'scenario']
         )
         self.load_factor_min = flow_system.fit_to_model_coords(
-            f'{self.label_full}|load_factor_min', self.load_factor_min, has_time_dim=False
+            f'{self.label_full}|load_factor_min', self.load_factor_min, dims=['year', 'scenario']
         )
 
         if self.on_off_parameters is not None:
             self.on_off_parameters.transform_data(flow_system, self.label_full)
         if isinstance(self.size, InvestParameters):
             self.size.transform_data(flow_system, self.label_full)
         else:
-            self.size = flow_system.fit_to_model_coords(f'{self.label_full}|size', self.size, has_time_dim=False)
+            self.size = flow_system.fit_to_model_coords(f'{self.label_full}|size', self.size, dims=['year', 'scenario'])
 
     def _plausibility_checks(self) -> None:
         # TODO: Incorporate into Variable? (Lower_bound can not be greater than upper bound
diff --git a/flixopt/flow_system.py b/flixopt/flow_system.py
@@ -427,7 +427,7 @@ def connect_and_transform(self):
             logger.debug('FlowSystem already connected and transformed')
             return
 
-        self.weights = self.fit_to_model_coords('weights', self.weights, has_time_dim=False)
+        self.weights = self.fit_to_model_coords('weights', self.weights, dims=['year', 'scenario'])
         if self.weights is not None and self.weights.sum() != 1:
             logger.warning(
                 f'Scenario weights are not normalized to 1. This is recomended for a better scaled model. '
diff --git a/flixopt/interface.py b/flixopt/interface.py
@@ -33,8 +33,9 @@ def __init__(self, start: TemporalDataUser, end: TemporalDataUser):
         self.has_time_dim = False
 
     def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
-        self.start = flow_system.fit_to_model_coords(f'{name_prefix}|start', self.start, has_time_dim=self.has_time_dim)
-        self.end = flow_system.fit_to_model_coords(f'{name_prefix}|end', self.end, has_time_dim=self.has_time_dim)
+        dims = None if self.has_time_dim else ['year', 'scenario']
+        self.start = flow_system.fit_to_model_coords(f'{name_prefix}|start', self.start, dims=dims)
+        self.end = flow_system.fit_to_model_coords(f'{name_prefix}|end', self.end, dims=dims)
 
 
 @register_class_for_io
@@ -189,33 +190,33 @@ def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
             label_prefix=name_prefix,
             effect_values=self.fix_effects,
             label_suffix='fix_effects',
-            has_time_dim=False,
+            dims=['year', 'scenario'],
         )
         self.divest_effects = flow_system.fit_effects_to_model_coords(
             label_prefix=name_prefix,
             effect_values=self.divest_effects,
             label_suffix='divest_effects',
-            has_time_dim=False,
+            dims=['year', 'scenario'],
         )
         self.specific_effects = flow_system.fit_effects_to_model_coords(
             label_prefix=name_prefix,
             effect_values=self.specific_effects,
             label_suffix='specific_effects',
-            has_time_dim=False,
+            dims=['year', 'scenario'],
         )
         if self.piecewise_effects is not None:
             self.piecewise_effects.has_time_dim = False
             self.piecewise_effects.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects')
 
         self.minimum_size = flow_system.fit_to_model_coords(
-            f'{name_prefix}|minimum_size', self.minimum_size, has_time_dim=False
+            f'{name_prefix}|minimum_size', self.minimum_size, dims=['year', 'scenario']
         )
         self.maximum_size = flow_system.fit_to_model_coords(
-            f'{name_prefix}|maximum_size', self.maximum_size, has_time_dim=False
+            f'{name_prefix}|maximum_size', self.maximum_size, dims=['year', 'scenario']
         )
         if self.fixed_size is not None:
             self.fixed_size = flow_system.fit_to_model_coords(
-                f'{name_prefix}|fixed_size', self.fixed_size, has_time_dim=False
+                f'{name_prefix}|fixed_size', self.fixed_size, dims=['year', 'scenario']
             )
 
     def _plausibility_checks(self, flow_system):
@@ -312,13 +313,13 @@ def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
             f'{name_prefix}|consecutive_off_hours_max', self.consecutive_off_hours_max
         )
         self.on_hours_total_max = flow_system.fit_to_model_coords(
-            f'{name_prefix}|on_hours_total_max', self.on_hours_total_max, has_time_dim=False
+            f'{name_prefix}|on_hours_total_max', self.on_hours_total_max, dims=['year', 'scenario']
         )
         self.on_hours_total_min = flow_system.fit_to_model_coords(
-            f'{name_prefix}|on_hours_total_min', self.on_hours_total_min, has_time_dim=False
+            f'{name_prefix}|on_hours_total_min', self.on_hours_total_min, dims=['year', 'scenario']
         )
         self.switch_on_total_max = flow_system.fit_to_model_coords(
-            f'{name_prefix}|switch_on_total_max', self.switch_on_total_max, has_time_dim=False
+            f'{name_prefix}|switch_on_total_max', self.switch_on_total_max, dims=['year', 'scenario']
         )
 
     @property
diff --git a/flixopt/structure.py b/flixopt/structure.py
@@ -178,7 +178,7 @@ def get_coords(
     def weights(self) -> Union[int, xr.DataArray]:
         """Returns the scenario weights of the FlowSystem. If None, return weights that are normalized to 1 (one)"""
         if self.flow_system.weights is None:
-            weights = self.flow_system.fit_to_model_coords('weights', 1, has_time_dim=False)
+            weights = self.flow_system.fit_to_model_coords('weights', 1, dims=['year', 'scenario'])
 
             return weights / weights.sum()
 

Original file line number	Diff line number	Diff line change
`@@ -223,29 +223,29 @@ def transform_data(self, flow_system: 'FlowSystem') -> None:`
`223`	`223`	`)`
`224`	`224`	`if not isinstance(self.initial_charge_state, str):`
`225`	`225`	`self.initial_charge_state = flow_system.fit_to_model_coords(`
`226`		`- f'{self.label_full}\|initial_charge_state', self.initial_charge_state, has_time_dim=False`
	`226`	`+ f'{self.label_full}\|initial_charge_state', self.initial_charge_state, dims=['year', 'scenario']`
`227`	`227`	`)`
`228`	`228`	`self.minimal_final_charge_state = flow_system.fit_to_model_coords(`
`229`		`- f'{self.label_full}\|minimal_final_charge_state', self.minimal_final_charge_state, has_time_dim=False`
	`229`	`+ f'{self.label_full}\|minimal_final_charge_state', self.minimal_final_charge_state, dims=['year', 'scenario']`
`230`	`230`	`)`
`231`	`231`	`self.maximal_final_charge_state = flow_system.fit_to_model_coords(`
`232`		`- f'{self.label_full}\|maximal_final_charge_state', self.maximal_final_charge_state, has_time_dim=False`
	`232`	`+ f'{self.label_full}\|maximal_final_charge_state', self.maximal_final_charge_state, dims=['year', 'scenario']`
`233`	`233`	`)`
`234`	`234`	`self.relative_minimum_final_charge_state = flow_system.fit_to_model_coords(`
`235`	`235`	`f'{self.label_full}\|relative_minimum_final_charge_state',`
`236`	`236`	`self.relative_minimum_final_charge_state,`
`237`		`- has_time_dim=False,`
	`237`	`+ dims=['year', 'scenario'],`
`238`	`238`	`)`
`239`	`239`	`self.relative_maximum_final_charge_state = flow_system.fit_to_model_coords(`
`240`	`240`	`f'{self.label_full}\|relative_maximum_final_charge_state',`
`241`	`241`	`self.relative_maximum_final_charge_state,`
`242`		`- has_time_dim=False,`
	`242`	`+ dims=['year', 'scenario'],`
`243`	`243`	`)`
`244`	`244`	`if isinstance(self.capacity_in_flow_hours, InvestParameters):`
`245`	`245`	`self.capacity_in_flow_hours.transform_data(flow_system, f'{self.label_full}\|InvestParameters')`
`246`	`246`	`else:`
`247`	`247`	`self.capacity_in_flow_hours = flow_system.fit_to_model_coords(`
`248`		`- f'{self.label_full}\|capacity_in_flow_hours', self.capacity_in_flow_hours, has_time_dim=False`
	`248`	`+ f'{self.label_full}\|capacity_in_flow_hours', self.capacity_in_flow_hours, dims=['year', 'scenario']`
`249`	`249`	`)`
`250`	`250`
`251`	`251`	`def _plausibility_checks(self) -> None:`
Original file line number	Diff line number	Diff line change
`@@ -105,27 +105,30 @@ def transform_data(self, flow_system: 'FlowSystem'):`
`105`	`105`	`)`
`106`	`106`
`107`	`107`	`self.minimum_operation = flow_system.fit_to_model_coords(`
`108`		`- f'{self.label_full}\|minimum_operation', self.minimum_operation, has_time_dim=False`
	`108`	`+ f'{self.label_full}\|minimum_operation', self.minimum_operation, dims=['year', 'scenario']`
`109`	`109`	`)`
`110`	`110`	`self.maximum_operation = flow_system.fit_to_model_coords(`
`111`		`- f'{self.label_full}\|maximum_operation', self.maximum_operation, has_time_dim=False`
	`111`	`+ f'{self.label_full}\|maximum_operation', self.maximum_operation, dims=['year', 'scenario']`
`112`	`112`	`)`
`113`	`113`	`self.minimum_invest = flow_system.fit_to_model_coords(`
`114`		`- f'{self.label_full}\|minimum_invest', self.minimum_invest, has_time_dim=False`
	`114`	`+ f'{self.label_full}\|minimum_invest', self.minimum_invest, dims=['year', 'scenario']`
`115`	`115`	`)`
`116`	`116`	`self.maximum_invest = flow_system.fit_to_model_coords(`
`117`		`- f'{self.label_full}\|maximum_invest', self.maximum_invest, has_time_dim=False`
	`117`	`+ f'{self.label_full}\|maximum_invest', self.maximum_invest, dims=['year', 'scenario']`
`118`	`118`	`)`
`119`	`119`	`self.minimum_total = flow_system.fit_to_model_coords(`
`120`	`120`	`f'{self.label_full}\|minimum_total',`
`121`	`121`	`self.minimum_total,`
`122`		`- has_time_dim=False,`
	`122`	`+ dims=['year', 'scenario'],`
`123`	`123`	`)`
`124`	`124`	`self.maximum_total = flow_system.fit_to_model_coords(`
`125`		`- f'{self.label_full}\|maximum_total', self.maximum_total, has_time_dim=False`
	`125`	`+ f'{self.label_full}\|maximum_total', self.maximum_total, dims=['year', 'scenario']`
`126`	`126`	`)`
`127`	`127`	`self.specific_share_to_other_effects_invest = flow_system.fit_effects_to_model_coords(`
`128`		`- f'{self.label_full}\|invest->', self.specific_share_to_other_effects_invest, 'invest', has_time_dim=False`
	`128`	`+ f'{self.label_full}\|invest->',`
	`129`	`+ self.specific_share_to_other_effects_invest,`
	`130`	`+ 'invest',`
	`131`	`+ dims=['year', 'scenario'],`
`129`	`132`	`)`
`130`	`133`
`131`	`134`	`def create_model(self, model: FlowSystemModel) -> 'EffectModel':`
Original file line number	Diff line number	Diff line change
`@@ -252,24 +252,24 @@ def transform_data(self, flow_system: 'FlowSystem'):`
`252`	`252`	`self.label_full, self.effects_per_flow_hour, 'per_flow_hour'`
`253`	`253`	`)`
`254`	`254`	`self.flow_hours_total_max = flow_system.fit_to_model_coords(`
`255`		`- f'{self.label_full}\|flow_hours_total_max', self.flow_hours_total_max, has_time_dim=False`
	`255`	`+ f'{self.label_full}\|flow_hours_total_max', self.flow_hours_total_max, dims=['year', 'scenario']`
`256`	`256`	`)`
`257`	`257`	`self.flow_hours_total_min = flow_system.fit_to_model_coords(`
`258`		`- f'{self.label_full}\|flow_hours_total_min', self.flow_hours_total_min, has_time_dim=False`
	`258`	`+ f'{self.label_full}\|flow_hours_total_min', self.flow_hours_total_min, dims=['year', 'scenario']`
`259`	`259`	`)`
`260`	`260`	`self.load_factor_max = flow_system.fit_to_model_coords(`
`261`		`- f'{self.label_full}\|load_factor_max', self.load_factor_max, has_time_dim=False`
	`261`	`+ f'{self.label_full}\|load_factor_max', self.load_factor_max, dims=['year', 'scenario']`
`262`	`262`	`)`
`263`	`263`	`self.load_factor_min = flow_system.fit_to_model_coords(`
`264`		`- f'{self.label_full}\|load_factor_min', self.load_factor_min, has_time_dim=False`
	`264`	`+ f'{self.label_full}\|load_factor_min', self.load_factor_min, dims=['year', 'scenario']`
`265`	`265`	`)`
`266`	`266`
`267`	`267`	`if self.on_off_parameters is not None:`
`268`	`268`	`self.on_off_parameters.transform_data(flow_system, self.label_full)`
`269`	`269`	`if isinstance(self.size, InvestParameters):`
`270`	`270`	`self.size.transform_data(flow_system, self.label_full)`
`271`	`271`	`else:`
`272`		`- self.size = flow_system.fit_to_model_coords(f'{self.label_full}\|size', self.size, has_time_dim=False)`
	`272`	`+ self.size = flow_system.fit_to_model_coords(f'{self.label_full}\|size', self.size, dims=['year', 'scenario'])`
`273`	`273`
`274`	`274`	`def _plausibility_checks(self) -> None:`
`275`	`275`	`# TODO: Incorporate into Variable? (Lower_bound can not be greater than upper bound`