Allow for fixing investments

docs/usage.rst

@@ -1279,6 +1279,33 @@ Besides the `invest` variable, new variables are introduced as well. These are:
  monthly periods, but you would need to be very careful in parameterizing your energy system and your model and also,
  this would mean monthly discounting (if applicable) as well as specifying your plants lifetimes in months.
 
+Repeated solving with fixed investment results
+----------------------------------------------
+
+You can rerun a given optimization model with fixed investments.
+Let's assume you have set up a model instance called ``model``
+containing investments and solved it by calling:
+
+.. code-block:: python
+
+ model = solph.Model(energysystem)
+ model.solve()
+
+You can now fix the investment results from the previous solving and
+only solve the dispatch-related part via a call of the method
+``fix_investments`` as well as a second solving of your model:
+
+.. code-block:: python
+
+ model.fix_investments()
+ model.solve()
+
+This will now take the investment variables as parameters. Thus, their
+values from the previous solving are parameters in the second solving. Only
+the dispatch-related variables will be optimized. This two-stage approach
+for instance may allow you to interpret dual values of balancing constraints
+which you cannot sensibly interpret in the presence of investment variables.
+
 Modelling cellular energy systems and modularizing energy system models
 -----------------------------------------------------------------------
 

docs/whatsnew/v0-5-2.rst

@@ -5,12 +5,15 @@ API changes
 ###########
 
 * New bool attribute `use_remaining_value` of `oemof.solph.EnergySystem`
+* New method `fix_investments` of `oemof.solph.Model`
 
 New features
 ############
 
 * Allow for evaluating differences in the remaining vs. the original value
  for multi-period investments.
+* Allow for fixing investment variables to the values of a previous
+ optimization run, enabling a repeated solve with fixed investments.
 
 Documentation
 #############

src/oemof/solph/_models.py

@@ -383,6 +383,7 @@ def __init__(self, energysystem, discount_rate=None, **kwargs):
  self._set_discount_rate_with_warning()
  else:
  pass
+ self._fix_investments = False
  super().__init__(energysystem, **kwargs)
 
  def _set_discount_rate_with_warning(self):
@@ -521,3 +522,24 @@ def _add_parent_block_variables(self):
  if (o, i) in self.UNIDIRECTIONAL_FLOWS:
  for p, t in self.TIMEINDEX:
  self.flow[o, i, p, t].setlb(0)
+
+ def fix_investments(self):
+ """Fix investment results of an already solved model"""
+ if self.solver_results is None:
+ msg = (
+ "Cannot fix investments as model has not yet been solved!\n"
+ "You have to first solve your model and then call method "
+ "`fix_investments()` on your model instance."
+ )
+ raise ValueError(msg)
+ self._fix_investments = True
+ if hasattr(self, "InvestmentFlowBlock"):
+ self.InvestmentFlowBlock.fix_investments_results()
+ if hasattr(self, "GenericInvestmentStorageBlock"):
+ self.GenericInvestmentStorageBlock.fix_investments_results()
+ if hasattr(self, "SinkDSMOemofInvestmentBlock"):
+ self.SinkDSMOemofInvestmentBlock.fix_investments_results()
+ if hasattr(self, "SinkDSMDIWInvestmentBlock"):
+ self.SinkDSMDIWInvestmentBlock.fix_investments_results()
+ if hasattr(self, "SinkDSMDLRInvestmentBlock"):
+ self.SinkDSMDLRInvestmentBlock.fix_investments_results()

src/oemof/solph/components/_generic_storage.py

@@ -1968,3 +1968,15 @@ def _evaluate_remaining_value_difference(
  return 0
  else:
  return 0
+
+ def fix_investments_results(self):
+ """Fix investments if `_fix_investments` is set to True for model"""
+ m = self.parent_block()
+ for n in self.INVESTSTORAGES:
+ for p in m.PERIODS:
+ self.invest[n, p].fix()
+ self.total[n, p].fix()
+ if m.es.periods is not None:
+ self.old[n, p].fix()
+ self.old_end[n, p].fix()
+ self.old_exo[n, p].fix()

src/oemof/solph/components/experimental/_sink_dsm.py

@@ -1536,6 +1536,18 @@ def _evaluate_remaining_value_difference(
  else:
  return 0
 
+ def fix_investments_results(self):
+ """Fix investments if `_fix_investments` is set to True for model"""
+ m = self.parent_block()
+ for g in self.investdsm:
+ for p in m.PERIODS:
+ self.invest[g, p].fix()
+ self.total[g, p].fix()
+ if m.es.periods is not None:
+ self.old[g, p].fix()
+ self.old_end[g, p].fix()
+ self.old_exo[g, p].fix()
+
 
 class SinkDSMDIWBlock(ScalarBlock):
  r"""Constraints for SinkDSM with "DIW" approach
@@ -3390,6 +3402,18 @@ def _evaluate_remaining_value_difference(
  else:
  return 0
 
+ def fix_investments_results(self):
+ """Fix investments if `_fix_investments` is set to True for model"""
+ m = self.parent_block()
+ for g in self.investdsm:
+ for p in m.PERIODS:
+ self.invest[g, p].fix()
+ self.total[g, p].fix()
+ if m.es.periods is not None:
+ self.old[g, p].fix()
+ self.old_end[g, p].fix()
+ self.old_exo[g, p].fix()
+
 
 class SinkDSMDLRBlock(ScalarBlock):
  r"""Constraints for SinkDSM with "DLR" approach
@@ -5888,3 +5912,15 @@ def _evaluate_remaining_value_difference(
  return 0
  else:
  return 0
+
+ def fix_investments_results(self):
+ """Fix investments if `_fix_investments` is set to True for model"""
+ m = self.parent_block()
+ for g in self.INVESTDR:
+ for p in m.PERIODS:
+ self.invest[g, p].fix()
+ self.total[g, p].fix()
+ if m.es.periods is not None:
+ self.old[g, p].fix()
+ self.old_end[g, p].fix()
+ self.old_exo[g, p].fix()

src/oemof/solph/flows/_investment_flow_block.py

@@ -1175,3 +1175,16 @@ def _max_invest_rule(_):
  self.maximum_rule_build = BuildAction(rule=_max_invest_rule)
 
  return self.maximum_rule
+
+ def fix_investments_results(self):
+ """Fix investments if `_fix_investments` is set to True for model"""
+ m = self.parent_block()
+ if hasattr(self, "INVESTFLOWS"):
+ for i, o in self.INVESTFLOWS:
+ for p in m.PERIODS:
+ self.invest[i, o, p].fix()
+ self.total[i, o, p].fix()
+ if m.es.periods is not None:
+ self.old[i, o, p].fix()
+ self.old_end[i, o, p].fix()
+ self.old_exo[i, o, p].fix()

tests/constraint_tests.py

@@ -1995,3 +1995,168 @@ def test_storage_level_constraint(self):
  output_levels={out_0: 1 / 8, out_1: 1 / 2},
  )
  self.compare_lp_files("storage_level_constraint.lp", my_om=om)
+
+ def test_investment_fixed(self):
+ """test a repeated solve with fixed investments for a converter"""
+ bgas = solph.buses.Bus(label="gas")
+ bel = solph.buses.Bus(label="electricity")
+
+ source = solph.components.Source(
+ label="gas_source",
+ outputs={bgas: solph.flows.Flow()},
+ )
+ converter = solph.components.Converter(
+ label="powerplant_gas",
+ inputs={bgas: solph.flows.Flow()},
+ outputs={
+ bel: solph.flows.Flow(
+ variable_costs=50,
+ nominal_value=solph.Investment(maximum=1000, ep_costs=20),
+ )
+ },
+ conversion_factors={bel: 0.58},
+ )
+ sink = solph.components.Sink(
+ label="electricity_consumption",
+ inputs={
+ bel: solph.flows.Flow(nominal_value=100, fix=[0.8, 0.9, 1.0])
+ },
+ )
+ self.energysystem.add(bgas, bel, source, converter, sink)
+ om = solph.Model(self.energysystem)
+ self.compare_lp_files("investment_before_fixing.lp", my_om=om)
+ om.solve()
+ om.fix_investments()
+ om.solve()
+ self.compare_lp_files("investment_after_fixing.lp", my_om=om)
+
+ def test_storage_investment_fixed(self):
+ """test a repeated solve with fixed investments for a storage"""
+ bgas = solph.buses.Bus(label="gas")
+ bel = solph.buses.Bus(label="electricity")
+
+ source = solph.components.Source(
+ label="gas_source",
+ outputs={bgas: solph.flows.Flow()},
+ )
+ converter = solph.components.Converter(
+ label="powerplant_gas",
+ inputs={bgas: solph.flows.Flow()},
+ outputs={
+ bel: solph.flows.Flow(
+ variable_costs=50,
+ nominal_value=90,
+ )
+ },
+ conversion_factors={bel: 0.58},
+ )
+ storage = solph.components.GenericStorage(
+ label="storage",
+ nominal_storage_capacity=solph.Investment(maximum=90, ep_costs=20),
+ inputs={bel: solph.flows.Flow(nominal_value=solph.Investment())},
+ outputs={bel: solph.flows.Flow(nominal_value=solph.Investment())},
+ invest_relation_input_capacity=1,
+ invest_relation_input_output=1,
+ )
+ sink = solph.components.Sink(
+ label="electricity_consumption",
+ inputs={
+ bel: solph.flows.Flow(nominal_value=100, fix=[0.8, 0.9, 1.0])
+ },
+ )
+ self.energysystem.add(bgas, bel, source, converter, storage, sink)
+ om = solph.Model(self.energysystem)
+ self.compare_lp_files("investment_storage_before_fixing.lp", my_om=om)
+ om.solve()
+ om.fix_investments()
+ om.solve()
+ self.compare_lp_files("investment_storage_after_fixing.lp", my_om=om)
+
+ def test_dsm_investment_fixed(self):
+ """test a repeated solve with fixed investments for a dsm unit"""
+ for approach in ["oemof", "DIW", "DLR"]:
+ energysystem = solph.EnergySystem(
+ timeindex=pd.date_range("1/1/2012", periods=3, freq="H")
+ )
+ bgas = solph.buses.Bus(label="gas")
+ bel = solph.buses.Bus(label="electricity")
+
+ source = solph.components.Source(
+ label="gas_source",
+ outputs={bgas: solph.flows.Flow()},
+ )
+ converter = solph.components.Converter(
+ label="powerplant_gas",
+ inputs={bgas: solph.flows.Flow()},
+ outputs={
+ bel: solph.flows.Flow(
+ variable_costs=50,
+ nominal_value=110,
+ )
+ },
+ conversion_factors={bel: 0.58},
+ )
+ kwargs_all = {
+ "label": "demand_dsm",
+ "inputs": {
+ bel: solph.flows.Flow(
+ variable_costs=0,
+ )
+ },
+ "demand": [20] * 3,
+ "capacity_up": [10] * 3,
+ "capacity_down": [10] * 3,
+ "delay_time": 1,
+ "max_demand": [1] * 3,
+ "recovery_time_shift": 0,
+ "cost_dsm_up": 0.01,
+ "cost_dsm_down_shift": 0.01,
+ "efficiency": 1.0,
+ "shed_eligibility": False,
+ "shift_eligibility": True,
+ "shift_time": 1,
+ }
+
+ kwargs_dict = {
+ "oemof": {"shift_interval": 24},
+ "DIW": {},
+ "DLR": {
+ "ActivateYearLimit": False,
+ "ActivateDayLimit": False,
+ "n_yearLimit_shift": 2,
+ "n_yearLimit_shed": 10,
+ "t_dayLimit": 2,
+ "addition": True,
+ "fixes": True,
+ },
+ }
+
+ dsm_unit = solph.components.experimental.SinkDSM(
+ **kwargs_all,
+ approach=approach,
+ **kwargs_dict[approach],
+ investment=solph.Investment(
+ maximum=20,
+ ep_costs=10,
+ ),
+ )
+
+ sink = solph.components.Sink(
+ label="electricity_consumption",
+ inputs={
+ bel: solph.flows.Flow(
+ nominal_value=100, fix=[0.9, 1.0, 0.8]
+ )
+ },
+ )
+ energysystem.add(bgas, bel, source, converter, dsm_unit, sink)
+ om = solph.Model(energysystem)
+ self.compare_lp_files(
+ f"investment_dsm_{approach}_before_fixing.lp", my_om=om
+ )
+ om.solve()
+ om.fix_investments()
+ om.solve()
+ self.compare_lp_files(
+ f"investment_dsm_{approach}_after_fixing.lp", my_om=om
+ )