diff --git a/docs/usage.rst b/docs/usage.rst index 9c3c0a172..9c54d38f8 100644 --- a/docs/usage.rst +++ b/docs/usage.rst @@ -1030,7 +1030,10 @@ First, you start by defining your energy system as you might have done before, b my_energysystem = solph.EnergySystem(timeindex=my_index, periods=periods) If you want to use a multi-period model you have define periods of your energy system explicitly. This way, -you are forced to critically think, e.g. about handling leap years, and take some design decisions. +you are forced to critically think, e.g. about handling leap years, and take some design decisions. It is possible to +define periods with different lengths, but remember that decommissioning of components is possible only at the +beginning of each period. This means that if the life of a component is just a little longer, it will remain for the +entire next period. This can have a particularly large impact the longer your periods are. To assist you, here is a plain python snippet that includes leap years which you can just copy and adjust to your needs: @@ -1268,18 +1271,18 @@ Besides the `invest` variable, new variables are introduced as well. These are: Modelling cellular energy systems and modularizing energy system models ----------------------------------------------------------------------- -The cellular approach is a concept proposed by the [VDE-ETG](https://shop.vde.com/en/vde-study-the-cellular-approach). It is -related to smart-grids and multi-microgrid systems but extends both. The idea is to group the components of an energy system -into a hierarchically aggregating structure of cells. For example, the sources, sinks, storages and converters of a household -could be a single cell. Then a group of physically neighboring households could form another cell, consisting of household-cells. -This behaviour can be scaled up. The real game-changer in the cellular approach is the way the cells are operated, which will +The cellular approach is a concept proposed by the [VDE-ETG](https://shop.vde.com/en/vde-study-the-cellular-approach). It is +related to smart-grids and multi-microgrid systems but extends both. The idea is to group the components of an energy system +into a hierarchically aggregating structure of cells. For example, the sources, sinks, storages and converters of a household +could be a single cell. Then a group of physically neighboring households could form another cell, consisting of household-cells. +This behaviour can be scaled up. The real game-changer in the cellular approach is the way the cells are operated, which will not be covered here. Here, we focus on the way such cellular energy systems can be modeled. -So far, the implementation in solph is just a neat way to group different parts of a larger energy system into cells. However, +So far, the implementation in solph is just a neat way to group different parts of a larger energy system into cells. However, the implementation can also be regarded as a precursor for further functionality. Decomposition techniques such -as [Benders](https://en.wikipedia.org/wiki/Benders_decomposition) or -[Dantzig-Wolfe](https://en.wikipedia.org/wiki/Dantzig%E2%80%93Wolfe_decomposition) could be implemented in solph. These methods -are dependent on a special constraint matrix structure, which the cellular modelling approach presented here is helping to obtain. +as [Benders](https://en.wikipedia.org/wiki/Benders_decomposition) or +[Dantzig-Wolfe](https://en.wikipedia.org/wiki/Dantzig%E2%80%93Wolfe_decomposition) could be implemented in solph. These methods +are dependent on a special constraint matrix structure, which the cellular modelling approach presented here is helping to obtain. Modelling procedure ^^^^^^^^^^^^^^^^^^^ @@ -1327,15 +1330,15 @@ Now we can go on and add components to the energy cells just like we do with reg .. note:: This is just an exemplary piece of code. A (little bit more interesting) working example can be found in the examples. - -The next step would be to model the connections between cells. Here, we resort to the class -:py:class:`oemof.solph.components.Link`. Each connection Link has two inputs (from the -"parent cell" and the "child cell") and two outputs (to the "parent cell" and the "child -cell"). A connection between the "parent cell" `es` and the "child cell" `ec_1` could look + +The next step would be to model the connections between cells. Here, we resort to the class +:py:class:`oemof.solph.components.Link`. Each connection Link has two inputs (from the +"parent cell" and the "child cell") and two outputs (to the "parent cell" and the "child +cell"). A connection between the "parent cell" `es` and the "child cell" `ec_1` could look like this: .. code-block:: python - + connector_el_ec_1 = solph.buses.Bus( label="connector_el_ec_1", inputs={ @@ -1353,25 +1356,25 @@ like this: ) es.add(connector_el_ec_1) -The `conversion_factors` can be used to model transmission losses. Here, a symmetrical +The `conversion_factors` can be used to model transmission losses. Here, a symmetrical loss of 15% is assumed. All connection Links are added to the upmost energy cell. -.. note:: Note that we do not add the energy cells as components to their parent cells! +.. note:: Note that we do not add the energy cells as components to their parent cells! Instead, the hierarchical structure is flattened and all connections between the cells are created as depicted above. -The last step is to create (and solve) the model. Again, this is fairly similar to the -regular model creation. However, instead of passing just one instance of +The last step is to create (and solve) the model. Again, this is fairly similar to the +regular model creation. However, instead of passing just one instance of :py:class:`oemof.solph.EnergySystem`, a list of energy systems is passed. .. warning:: - By convention the first element of the list is assumed to be the upmost energy cell. + By convention the first element of the list is assumed to be the upmost energy cell. The ordering afterwards does not play a role. .. note:: The resulting model is monolithic. This means that all components of all energy - cells are actually grouped into one pyomo model. It would, therefore, also be possible - to model all the components in one :py:class:`oemof.solph.EnergySystem` instance and + cells are actually grouped into one pyomo model. It would, therefore, also be possible + to model all the components in one :py:class:`oemof.solph.EnergySystem` instance and the results would be identical. .. code-block:: python @@ -1385,7 +1388,7 @@ As pointed out above, the resulting model is monolithic. Nonetheless, this model holds some benefits: * Better overview through segmentation of the energy system -* (Facilitated) opportunity to model cellular energy systems where the energy exchanged between cells +* (Facilitated) opportunity to model cellular energy systems where the energy exchanged between cells is of interest * Segmentation of the energy system is a necessary precursor for distributed optimization via Dantzig-Wolfe diff --git a/docs/whatsnew/v0-5-1.rst b/docs/whatsnew/v0-5-1.rst index 91252f40b..e36d8302a 100644 --- a/docs/whatsnew/v0-5-1.rst +++ b/docs/whatsnew/v0-5-1.rst @@ -43,12 +43,14 @@ Bug fixes * Fixed error when calling `oemof_installation_test` as console script. * Corrected several typos in the docs. +* Periods with multiple period lengths are now supported in multi-period investment. * Add missing 'custom_attributes' for the link component Testing ####### * Add tests for experimental SinkDSM component. +* Add tests for multi-period investment. Other changes ############# diff --git a/examples/cellular/cellular.py b/examples/cellular/cellular.py index aef652801..53a223757 100644 --- a/examples/cellular/cellular.py +++ b/examples/cellular/cellular.py @@ -30,14 +30,14 @@ """ +from oemof.solph import EnergySystem from oemof.solph import Model from oemof.solph import buses from oemof.solph import components as cmp -from oemof.solph import EnergySystem - from oemof.solph import create_time_index from oemof.solph import flows -from oemof.solph import processing, views +from oemof.solph import processing +from oemof.solph import views def main(): diff --git a/examples/electrical/lopf.py b/examples/electrical/lopf.py index 9254f604c..5c1918b9b 100644 --- a/examples/electrical/lopf.py +++ b/examples/electrical/lopf.py @@ -31,11 +31,17 @@ import pandas as pd from matplotlib import pyplot as plt from oemof.network.graph import create_nx_graph -from oemof.solph import EnergySystem, Investment, Model, processing, views -from oemof.solph.components import Sink, Source + +from oemof.solph import EnergySystem +from oemof.solph import Investment +from oemof.solph import Model +from oemof.solph import processing +from oemof.solph import views from oemof.solph.buses.experimental import ElectricalBus -from oemof.solph.flows.experimental import ElectricalLine +from oemof.solph.components import Sink +from oemof.solph.components import Source from oemof.solph.flows import Flow +from oemof.solph.flows.experimental import ElectricalLine try: import pygraphviz as pygz diff --git a/examples/excel_reader/dispatch.py b/examples/excel_reader/dispatch.py index 4894b1497..4b32377d9 100644 --- a/examples/excel_reader/dispatch.py +++ b/examples/excel_reader/dispatch.py @@ -41,16 +41,16 @@ """ -import os import logging -import pandas as pd +import os +import networkx as nx +import pandas as pd +from matplotlib import pyplot as plt +from oemof.network.graph import create_nx_graph from oemof.tools import logger -from oemof import solph -from oemof.network.graph import create_nx_graph -from matplotlib import pyplot as plt -import networkx as nx +from oemof import solph def nodes_from_excel(filename): diff --git a/examples/invest_nonconvex_flow_examples/diesel_genset_nonconvex_investment.py b/examples/invest_nonconvex_flow_examples/diesel_genset_nonconvex_investment.py index aeab52562..098f4b673 100644 --- a/examples/invest_nonconvex_flow_examples/diesel_genset_nonconvex_investment.py +++ b/examples/invest_nonconvex_flow_examples/diesel_genset_nonconvex_investment.py @@ -31,13 +31,16 @@ __copyright__ = "oemof developer group" __license__ = "MIT" -import numpy as np import os -import pandas as pd import time -from datetime import datetime, timedelta -from oemof import solph import warnings +from datetime import datetime +from datetime import timedelta + +import numpy as np +import pandas as pd + +from oemof import solph try: import matplotlib.pyplot as plt diff --git a/examples/invest_nonconvex_flow_examples/house_with_nonconvex_investment.py b/examples/invest_nonconvex_flow_examples/house_with_nonconvex_investment.py index c137ce46d..c03f8061e 100644 --- a/examples/invest_nonconvex_flow_examples/house_with_nonconvex_investment.py +++ b/examples/invest_nonconvex_flow_examples/house_with_nonconvex_investment.py @@ -30,9 +30,10 @@ import numpy as np import pandas as pd -from oemof import solph from oemof.tools import economics +from oemof import solph + try: import matplotlib.pyplot as plt except ImportError: diff --git a/examples/invest_nonconvex_flow_examples/house_without_nonconvex_investment.py b/examples/invest_nonconvex_flow_examples/house_without_nonconvex_investment.py index 14dd060e6..ddf01bce6 100644 --- a/examples/invest_nonconvex_flow_examples/house_without_nonconvex_investment.py +++ b/examples/invest_nonconvex_flow_examples/house_without_nonconvex_investment.py @@ -36,9 +36,10 @@ import numpy as np import pandas as pd -from oemof import solph from oemof.tools import economics +from oemof import solph + try: import matplotlib.pyplot as plt except ImportError: diff --git a/examples/start_and_shutdown_costs/startup_shutdown.py b/examples/start_and_shutdown_costs/startup_shutdown.py index fabd0220f..abee8c9e6 100644 --- a/examples/start_and_shutdown_costs/startup_shutdown.py +++ b/examples/start_and_shutdown_costs/startup_shutdown.py @@ -17,9 +17,10 @@ `MIT license `_ """ +import matplotlib.pyplot as plt import pandas as pd + from oemof import solph -import matplotlib.pyplot as plt def main(): diff --git a/examples/storage_investment/v1_invest_optimize_all_technologies.py b/examples/storage_investment/v1_invest_optimize_all_technologies.py index 50cc4ad16..ce3a79891 100644 --- a/examples/storage_investment/v1_invest_optimize_all_technologies.py +++ b/examples/storage_investment/v1_invest_optimize_all_technologies.py @@ -68,8 +68,6 @@ import warnings import pandas as pd - -# Default logger of oemof from oemof.tools import economics from oemof.tools import logger diff --git a/examples/storage_investment/v2_invest_optimize_only_gas_and_storage.py b/examples/storage_investment/v2_invest_optimize_only_gas_and_storage.py index a49a245e0..6657df87b 100644 --- a/examples/storage_investment/v2_invest_optimize_only_gas_and_storage.py +++ b/examples/storage_investment/v2_invest_optimize_only_gas_and_storage.py @@ -68,8 +68,6 @@ import warnings import pandas as pd - -# Default logger of oemof from oemof.tools import economics from oemof.tools import logger diff --git a/examples/storage_investment/v3_invest_optimize_only_storage_with_fossil_share.py b/examples/storage_investment/v3_invest_optimize_only_storage_with_fossil_share.py index 0662d8e81..564310453 100644 --- a/examples/storage_investment/v3_invest_optimize_only_storage_with_fossil_share.py +++ b/examples/storage_investment/v3_invest_optimize_only_storage_with_fossil_share.py @@ -67,8 +67,6 @@ import warnings import pandas as pd - -# Default logger of oemof from oemof.tools import economics from oemof.tools import logger diff --git a/examples/storage_investment/v4_invest_optimize_all_technologies_with_fossil_share.py b/examples/storage_investment/v4_invest_optimize_all_technologies_with_fossil_share.py index 1828b4ce3..bea03c3e1 100644 --- a/examples/storage_investment/v4_invest_optimize_all_technologies_with_fossil_share.py +++ b/examples/storage_investment/v4_invest_optimize_all_technologies_with_fossil_share.py @@ -64,8 +64,6 @@ import warnings import pandas as pd - -# Default logger of oemof from oemof.tools import economics from oemof.tools import logger diff --git a/examples/storage_level_constraint/storage_level_constraint.py b/examples/storage_level_constraint/storage_level_constraint.py index f846b68bd..e8bfab87d 100644 --- a/examples/storage_level_constraint/storage_level_constraint.py +++ b/examples/storage_level_constraint/storage_level_constraint.py @@ -1,12 +1,15 @@ -import pandas as pd -from oemof.solph import Bus, EnergySystem, Flow, Model -from oemof.solph.components import GenericStorage, Source, Sink -from oemof.solph.processing import results - import matplotlib.pyplot as plt +import pandas as pd +from oemof.solph import Bus +from oemof.solph import EnergySystem +from oemof.solph import Flow +from oemof.solph import Model +from oemof.solph.components import GenericStorage +from oemof.solph.components import Sink +from oemof.solph.components import Source from oemof.solph.constraints import storage_level_constraint - +from oemof.solph.processing import results es = EnergySystem( timeindex=pd.date_range("2022-01-01", freq="1H", periods=24), diff --git a/examples/time_index_example/non_equidistant_time_step_example.py b/examples/time_index_example/non_equidistant_time_step_example.py index 4b9a3e6a5..c03c7e570 100644 --- a/examples/time_index_example/non_equidistant_time_step_example.py +++ b/examples/time_index_example/non_equidistant_time_step_example.py @@ -26,6 +26,7 @@ pip install oemof.solph """ import pandas as pd + from oemof import solph try: diff --git a/src/oemof/solph/_energy_system.py b/src/oemof/solph/_energy_system.py index d3c1e00b7..a2a166fb5 100644 --- a/src/oemof/solph/_energy_system.py +++ b/src/oemof/solph/_energy_system.py @@ -173,6 +173,7 @@ def __init__( warnings.warn(msg, debugging.SuspiciousUsageWarning) self.periods = periods self._extract_periods_years() + self._extract_periods_matrix() def _extract_periods_years(self): """Map simulation years to the respective period based on time indices @@ -192,6 +193,26 @@ def _extract_periods_years(self): self.periods_years = periods_years + def _extract_periods_matrix(self): + """Determines a matrix describing the temporal distance to each period. + Rows represent investment/commissioning periods, columns represent + decommissioning periods. The values describe the temporal distance + between each investment period to each decommissioning period. + + Returns + ------- + period_distance_matrix: np.array + + """ + periods_matrix = [] + if self.periods is not None: + period_years = np.array(self.periods_years) + for v in period_years: + row = period_years - v + row = np.where(row < 0, 0, row) + periods_matrix.append(row) + self.periods_matrix = np.array(periods_matrix) + def create_time_index( year: int = None, diff --git a/src/oemof/solph/components/_generic_storage.py b/src/oemof/solph/components/_generic_storage.py index 05a492216..99f497c75 100644 --- a/src/oemof/solph/components/_generic_storage.py +++ b/src/oemof/solph/components/_generic_storage.py @@ -22,6 +22,7 @@ import numbers from warnings import warn +import numpy as np from oemof.network import network from oemof.tools import debugging from oemof.tools import economics @@ -1218,7 +1219,18 @@ def _total_storage_capacity_rule(block): def _old_storage_capacity_rule_end(block): """Rule definition for determining old endogenously installed - capacity to be decommissioned due to reaching its lifetime + capacity to be decommissioned due to reaching its lifetime. + Investment and decommissioning periods are linked within + the constraint. The respective decommissioning period is + determined for every investment period based on the components + lifetime and a matrix describing its age of each endogenous + investment. Decommissioning can only occur at the beginning of + each period. + + Note + ---- + For further information on the implementation check + PR#957 https://github.com/oemof/oemof-solph/pull/957 """ for n in self.INVESTSTORAGES: lifetime = n.investment.lifetime @@ -1228,27 +1240,77 @@ def _old_storage_capacity_rule_end(block): "for a Flow going into or out of " "a GenericStorage unit " "in a multi-period model!" - " Value for {} is missing.".format(n) + f" Value for {n} is missing." ) raise ValueError(msg) + # get the period matrix describing the temporal distance + # between all period combinations. + periods_matrix = m.es.periods_matrix + + # get the index of the minimum value in each row greater + # equal than the lifetime. This value equals the + # decommissioning period if not zero. The index of this + # value represents the investment period. If np.where + # condition is not met in any row, min value will be zero + decomm_periods = np.argmin( + np.where( + (periods_matrix >= lifetime), + periods_matrix, + np.inf, + ), + axis=1, + ) + + # no decommissioning in first period + expr = self.old_end[n, 0] == 0 + self.old_rule_end.add((n, 0), expr) + + # all periods not in decomm_periods have no decommissioning + # zero is excluded for p in m.PERIODS: - # No shutdown in first period - if p == 0: + if p not in decomm_periods and p != 0: expr = self.old_end[n, p] == 0 self.old_rule_end.add((n, p), expr) - elif lifetime <= m.es.periods_years[p]: - # Obtain commissioning period - comm_p = 0 - for k, v in enumerate(m.es.periods_years): - if m.es.periods_years[p] - lifetime - v < 0: - # change of sign is detected - comm_p = k - 1 - break - expr = self.old_end[n, p] == self.invest[n, comm_p] - self.old_rule_end.add((n, p), expr) + + # multiple invests can be decommissioned in the same period + # but only sequential ones, thus a bookkeeping is + # introduced andconstraints are added to equation one + # iteration later. + last_decomm_p = np.nan + # loop over invest periods (values are decomm_periods) + for invest_p, decomm_p in enumerate(decomm_periods): + # Add constraint of iteration before + # (skipped in first iteration by last_decomm_p = nan) + if (decomm_p != last_decomm_p) and ( + last_decomm_p is not np.nan + ): + expr = self.old_end[n, last_decomm_p] == expr + self.old_rule_end.add((n, last_decomm_p), expr) + + # no decommissioning if decomm_p is zero + if decomm_p == 0: + # overwrite decomm_p with zero to avoid + # chaining invest periods in next iteration + last_decomm_p = 0 + + # if decomm_p is the same as the last one chain invest + # period + elif decomm_p == last_decomm_p: + expr += self.invest[n, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # if decomm_p is not zero, not the same as the last one + # and it's not the first period else: - expr = self.old_end[n, p] == 0 - self.old_rule_end.add((n, p), expr) + expr = self.invest[n, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # Add constraint of very last iteration + if last_decomm_p != 0: + expr = self.old_end[n, last_decomm_p] == expr + self.old_rule_end.add((n, last_decomm_p), expr) self.old_rule_end = Constraint( self.INVESTSTORAGES, m.PERIODS, noruleinit=True diff --git a/src/oemof/solph/components/experimental/_sink_dsm.py b/src/oemof/solph/components/experimental/_sink_dsm.py index e956a3ebe..eeda335aa 100644 --- a/src/oemof/solph/components/experimental/_sink_dsm.py +++ b/src/oemof/solph/components/experimental/_sink_dsm.py @@ -25,7 +25,7 @@ import itertools from warnings import warn -from numpy import mean +import numpy as np from oemof.tools import debugging from oemof.tools import economics from pyomo.core.base.block import ScalarBlock @@ -305,8 +305,8 @@ def __init__( self.cost_dsm_down_shift = sequence(cost_dsm_down_shift) self.cost_dsm_down_shed = sequence(cost_dsm_down_shed) self.efficiency = efficiency - self.capacity_down_mean = mean(capacity_down) - self.capacity_up_mean = mean(capacity_up) + self.capacity_down_mean = np.mean(capacity_down) + self.capacity_up_mean = np.mean(capacity_up) self.recovery_time_shift = recovery_time_shift self.recovery_time_shed = recovery_time_shed self.ActivateYearLimit = ActivateYearLimit @@ -963,28 +963,99 @@ def _total_dsm_capacity_rule(block): def _old_dsm_capacity_rule_end(block): """Rule definition for determining old endogenously installed - capacity to be decommissioned due to reaching its lifetime + capacity to be decommissioned due to reaching its lifetime. + Investment and decommissioning periods are linked within + the constraint. The respective decommissioning period is + determined for every investment period based on the components + lifetime and a matrix describing its age of each endogenous + investment. Decommissioning can only occur at the beginning of + each period. + + Note + ---- + For further information on the implementation check + PR#957 https://github.com/oemof/oemof-solph/pull/957 """ for g in group: lifetime = g.investment.lifetime + if lifetime is None: + msg = ( + "You have to specify a lifetime " + "for a Flow with an associated " + "investment object in " + f"a multi-period model! Value for {(g)} " + "is missing." + ) + raise ValueError(msg) + + # get the period matrix describing the temporal distance + # between all period combinations. + periods_matrix = m.es.periods_matrix + + # get the index of the minimum value in each row greater + # equal than the lifetime. This value equals the + # decommissioning period if not zero. The index of this + # value represents the investment period. If np.where + # condition is not met in any row, min value will be zero + decomm_periods = np.argmin( + np.where( + (periods_matrix >= lifetime), + periods_matrix, + np.inf, + ), + axis=1, + ) + + # no decommissioning in first period + expr = self.old_end[g, 0] == 0 + self.old_dsm_rule_end.add((g, 0), expr) + + # all periods not in decomm_periods have no decommissioning + # zero is excluded for p in m.PERIODS: - # No shutdown in first period - if p == 0: + if p not in decomm_periods and p != 0: expr = self.old_end[g, p] == 0 self.old_dsm_rule_end.add((g, p), expr) - elif lifetime <= m.es.periods_years[p]: - # Obtain commissioning period - comm_p = 0 - for k, v in enumerate(m.es.periods_years): - if m.es.periods_years[p] - lifetime - v < 0: - # change of sign is detected - comm_p = k - 1 - break - expr = self.old_end[g, p] == self.invest[g, comm_p] - self.old_dsm_rule_end.add((g, p), expr) + + # multiple invests can be decommissioned in the same period + # but only sequential ones, thus a bookkeeping is + # introduced andconstraints are added to equation one + # iteration later. + last_decomm_p = np.nan + # loop over invest periods (values are decomm_periods) + for invest_p, decomm_p in enumerate(decomm_periods): + # Add constraint of iteration before + # (skipped in first iteration by last_decomm_p = nan) + if (decomm_p != last_decomm_p) and ( + last_decomm_p is not np.nan + ): + expr = self.old_end[g, last_decomm_p] == expr + self.old_dsm_rule_end.add((g, last_decomm_p), expr) + + # no decommissioning if decomm_p is zero + if decomm_p == 0: + # overwrite decomm_p with zero to avoid + # chaining invest periods in next iteration + last_decomm_p = 0 + + # if decomm_p is the same as the last one chain invest + # period + elif decomm_p == last_decomm_p: + expr += self.invest[g, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # if decomm_p is not zero, not the same as the last one + # and it's not the first period else: - expr = self.old_end[g, p] == 0 - self.old_dsm_rule_end.add((g, p), expr) + expr = self.invest[g, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # Add constraint of very last iteration + if last_decomm_p != 0: + expr = self.old_end[g, last_decomm_p] == expr + self.old_dsm_rule_end.add((g, last_decomm_p), expr) self.old_dsm_rule_end = Constraint( group, m.PERIODS, noruleinit=True @@ -2283,28 +2354,98 @@ def _total_dsm_capacity_rule(block): def _old_dsm_capacity_rule_end(block): """Rule definition for determining old endogenously installed - capacity to be decommissioned due to reaching its lifetime + capacity to be decommissioned due to reaching its lifetime. + Investment and decommissioning periods are linked within + the constraint. The respective decommissioning period is + determined for every investment period based on the components + lifetime and a matrix describing its age of each endogenous + investment. Decommissioning can only occur at the beginning of + each period. + + Note + ---- + For further information on the implementation check + PR#957 https://github.com/oemof/oemof-solph/pull/957 """ for g in group: lifetime = g.investment.lifetime + if lifetime is None: + msg = ( + "You have to specify a lifetime " + "for a Flow with an associated " + "investment object in " + f"a multi-period model! Value for {g} " + "is missing." + ) + raise ValueError(msg) + # get the period matrix describing the temporal distance + # between all period combinations. + periods_matrix = m.es.periods_matrix + + # get the index of the minimum value in each row greater + # equal than the lifetime. This value equals the + # decommissioning period if not zero. The index of this + # value represents the investment period. If np.where + # condition is not met in any row, min value will be zero + decomm_periods = np.argmin( + np.where( + (periods_matrix >= lifetime), + periods_matrix, + np.inf, + ), + axis=1, + ) + + # no decommissioning in first period + expr = self.old_end[g, 0] == 0 + self.old_dsm_rule_end.add((g, 0), expr) + + # all periods not in decomm_periods have no decommissioning + # zero is excluded for p in m.PERIODS: - # No shutdown in first period - if p == 0: + if p not in decomm_periods and p != 0: expr = self.old_end[g, p] == 0 self.old_dsm_rule_end.add((g, p), expr) - elif lifetime <= m.es.periods_years[p]: - # Obtain commissioning period - comm_p = 0 - for k, v in enumerate(m.es.periods_years): - if m.es.periods_years[p] - lifetime - v < 0: - # change of sign is detected - comm_p = k - 1 - break - expr = self.old_end[g, p] == self.invest[g, comm_p] - self.old_dsm_rule_end.add((g, p), expr) + + # multiple invests can be decommissioned in the same period + # but only sequential ones, thus a bookkeeping is + # introduced andconstraints are added to equation one + # iteration later. + last_decomm_p = np.nan + # loop over invest periods (values are decomm_periods) + for invest_p, decomm_p in enumerate(decomm_periods): + # Add constraint of iteration before + # (skipped in first iteration by last_decomm_p = nan) + if (decomm_p != last_decomm_p) and ( + last_decomm_p is not np.nan + ): + expr = self.old_end[g, last_decomm_p] == expr + self.old_dsm_rule_end.add((g, last_decomm_p), expr) + + # no decommissioning if decomm_p is zero + if decomm_p == 0: + # overwrite decomm_p with zero to avoid + # chaining invest periods in next iteration + last_decomm_p = 0 + + # if decomm_p is the same as the last one chain invest + # period + elif decomm_p == last_decomm_p: + expr += self.invest[g, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # if decomm_p is not zero, not the same as the last one + # and it's not the first period else: - expr = self.old_end[g, p] == 0 - self.old_dsm_rule_end.add((g, p), expr) + expr = self.invest[g, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # Add constraint of very last iteration + if last_decomm_p != 0: + expr = self.old_end[g, last_decomm_p] == expr + self.old_dsm_rule_end.add((g, last_decomm_p), expr) self.old_dsm_rule_end = Constraint( group, m.PERIODS, noruleinit=True @@ -4378,28 +4519,99 @@ def _total_capacity_rule(block): def _old_dsm_capacity_rule_end(block): """Rule definition for determining old endogenously installed - capacity to be decommissioned due to reaching its lifetime + capacity to be decommissioned due to reaching its lifetime. + Investment and decommissioning periods are linked within + the constraint. The respective decommissioning period is + determined for every investment period based on the components + lifetime and a matrix describing its age of each endogenous + investment. Decommissioning can only occur at the beginning of + each period. + + Note + ---- + For further information on the implementation check + PR#957 https://github.com/oemof/oemof-solph/pull/957 """ for g in group: lifetime = g.investment.lifetime + if lifetime is None: + msg = ( + "You have to specify a lifetime " + "for a Flow with an associated " + "investment object in " + f"a multi-period model! Value for {(g)} " + "is missing." + ) + raise ValueError(msg) + + # get the period matrix describing the temporal distance + # between all period combinations. + periods_matrix = m.es.periods_matrix + + # get the index of the minimum value in each row greater + # equal than the lifetime. This value equals the + # decommissioning period if not zero. The index of this + # value represents the investment period. If np.where + # condition is not met in any row, min value will be zero + decomm_periods = np.argmin( + np.where( + (periods_matrix >= lifetime), + periods_matrix, + np.inf, + ), + axis=1, + ) + + # no decommissioning in first period + expr = self.old_end[g, 0] == 0 + self.old_dsm_rule_end.add((g, 0), expr) + + # all periods not in decomm_periods have no decommissioning + # zero is excluded for p in m.PERIODS: - # No shutdown in first period - if p == 0: + if p not in decomm_periods and p != 0: expr = self.old_end[g, p] == 0 self.old_dsm_rule_end.add((g, p), expr) - elif lifetime <= m.es.periods_years[p]: - # Obtain commissioning period - comm_p = 0 - for k, v in enumerate(m.es.periods_years): - if m.es.periods_years[p] - lifetime - v < 0: - # change of sign is detected - comm_p = k - 1 - break - expr = self.old_end[g, p] == self.invest[g, comm_p] - self.old_dsm_rule_end.add((g, p), expr) + + # multiple invests can be decommissioned in the same period + # but only sequential ones, thus a bookkeeping is + # introduced andconstraints are added to equation one + # iteration later. + last_decomm_p = np.nan + # loop over invest periods (values are decomm_periods) + for invest_p, decomm_p in enumerate(decomm_periods): + # Add constraint of iteration before + # (skipped in first iteration by last_decomm_p = nan) + if (decomm_p != last_decomm_p) and ( + last_decomm_p is not np.nan + ): + expr = self.old_end[g, last_decomm_p] == expr + self.old_dsm_rule_end.add((g, last_decomm_p), expr) + + # no decommissioning if decomm_p is zero + if decomm_p == 0: + # overwrite decomm_p with zero to avoid + # chaining invest periods in next iteration + last_decomm_p = 0 + + # if decomm_p is the same as the last one chain invest + # period + elif decomm_p == last_decomm_p: + expr += self.invest[g, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # if decomm_p is not zero, not the same as the last one + # and it's not the first period else: - expr = self.old_end[g, p] == 0 - self.old_dsm_rule_end.add((g, p), expr) + expr = self.invest[g, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # Add constraint of very last iteration + if last_decomm_p != 0: + expr = self.old_end[g, last_decomm_p] == expr + self.old_dsm_rule_end.add((g, last_decomm_p), expr) self.old_dsm_rule_end = Constraint( group, m.PERIODS, noruleinit=True diff --git a/src/oemof/solph/flows/_flow.py b/src/oemof/solph/flows/_flow.py index c919ab3eb..03b929575 100644 --- a/src/oemof/solph/flows/_flow.py +++ b/src/oemof/solph/flows/_flow.py @@ -244,9 +244,9 @@ def __init__( the_attr = eval(attr) if the_attr is not None: raise AttributeError( - "If {} is set in a flow (except InvestmentFlow), " + f"If {attr} is set in a flow (except InvestmentFlow), " "nominal_value must be set as well.\n" - "Otherwise, it won't have any effect.".format(attr) + "Otherwise, it won't have any effect." ) # minimum will be set even without nominal limit diff --git a/src/oemof/solph/flows/_investment_flow_block.py b/src/oemof/solph/flows/_investment_flow_block.py index 105984b5f..9ee4122e3 100644 --- a/src/oemof/solph/flows/_investment_flow_block.py +++ b/src/oemof/solph/flows/_investment_flow_block.py @@ -17,6 +17,7 @@ """ from warnings import warn +import numpy as np from oemof.tools import debugging from oemof.tools import economics from pyomo.core import Binary @@ -472,7 +473,18 @@ def _total_capacity_rule(block): def _old_capacity_rule_end(block): """Rule definition for determining old endogenously installed - capacity to be decommissioned due to reaching its lifetime + capacity to be decommissioned due to reaching its lifetime. + Investment and decommissioning periods are linked within + the constraint. The respective decommissioning period is + determined for every investment period based on the components + lifetime and a matrix describing its age of each endogenous + investment. Decommissioning can only occur at the beginning of + each period. + + Note + ---- + For further information on the implementation check + PR#957 https://github.com/oemof/oemof-solph/pull/957 """ for i, o in self.INVESTFLOWS: lifetime = m.flows[i, o].investment.lifetime @@ -481,31 +493,79 @@ def _old_capacity_rule_end(block): "You have to specify a lifetime " "for a Flow with an associated " "investment object in " - "a multi-period model! Value for {} " - "is missing.".format((i, o)) + f"a multi-period model! Value for {(i, o)} " + "is missing." ) raise ValueError(msg) + + # get the period matrix describing the temporal distance + # between all period combinations. + periods_matrix = m.es.periods_matrix + + # get the index of the minimum value in each row greater + # equal than the lifetime. This value equals the + # decommissioning period if not zero. The index of this + # value represents the investment period. If np.where + # condition is not met in any row, min value will be zero + decomm_periods = np.argmin( + np.where( + (periods_matrix >= lifetime), + periods_matrix, + np.inf, + ), + axis=1, + ) + + # no decommissioning in first period + expr = self.old_end[i, o, 0] == 0 + self.old_rule_end.add((i, o, 0), expr) + + # all periods not in decomm_periods have no decommissioning + # zero is excluded for p in m.PERIODS: - # No shutdown in first period - if p == 0: + if p not in decomm_periods and p != 0: expr = self.old_end[i, o, p] == 0 self.old_rule_end.add((i, o, p), expr) - elif lifetime <= m.es.periods_years[p]: - # Obtain commissioning period - comm_p = 0 - for k, v in enumerate(m.es.periods_years): - if m.es.periods_years[p] - lifetime - v < 0: - # change of sign is detected - comm_p = k - 1 - break - expr = ( - self.old_end[i, o, p] - == self.invest[i, o, comm_p] - ) - self.old_rule_end.add((i, o, p), expr) + + # multiple invests can be decommissioned in the same period + # but only sequential ones, thus a bookkeeping is + # introduced andconstraints are added to equation one + # iteration later. + last_decomm_p = np.nan + # loop over invest periods (values are decomm_periods) + for invest_p, decomm_p in enumerate(decomm_periods): + # Add constraint of iteration before + # (skipped in first iteration by last_decomm_p = nan) + if (decomm_p != last_decomm_p) and ( + last_decomm_p is not np.nan + ): + expr = self.old_end[i, o, last_decomm_p] == expr + self.old_rule_end.add((i, o, last_decomm_p), expr) + + # no decommissioning if decomm_p is zero + if decomm_p == 0: + # overwrite decomm_p with zero to avoid + # chaining invest periods in next iteration + last_decomm_p = 0 + + # if decomm_p is the same as the last one chain invest + # period + elif decomm_p == last_decomm_p: + expr += self.invest[i, o, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # if decomm_p is not zero, not the same as the last one + # and it's not the first period else: - expr = self.old_end[i, o, p] == 0 - self.old_rule_end.add((i, o, p), expr) + expr = self.invest[i, o, invest_p] + # overwrite decomm_p + last_decomm_p = decomm_p + + # Add constraint of very last iteration + if last_decomm_p != 0: + expr = self.old_end[i, o, last_decomm_p] == expr + self.old_rule_end.add((i, o, last_decomm_p), expr) self.old_rule_end = Constraint( self.INVESTFLOWS, m.PERIODS, noruleinit=True diff --git a/tests/lp_files/multi_period_period_length.lp b/tests/lp_files/multi_period_period_length.lp new file mode 100644 index 000000000..66c20689e --- /dev/null +++ b/tests/lp_files/multi_period_period_length.lp @@ -0,0 +1,8065 @@ +\* Source Pyomo model name=Model *\ + +min +objective: ++15992.031251718836 ONE_VAR_CONSTANT ++12.231343625058066 InvestmentFlowBlock_invest(storage_electricity_0) ++8.231343625058066 InvestmentFlowBlock_invest(storage_electricity_1) ++6.116009561015236 InvestmentFlowBlock_invest(storage_electricity_2) ++5.017258045399043 InvestmentFlowBlock_invest(storage_electricity_3) ++4.544285192584936 InvestmentFlowBlock_invest(storage_electricity_4) ++3.7278966318848936 InvestmentFlowBlock_invest(storage_electricity_5) ++2.769882109365063 InvestmentFlowBlock_invest(storage_electricity_6) ++1.864051255691565 InvestmentFlowBlock_invest(storage_electricity_7) ++12.231343625058066 InvestmentFlowBlock_invest(electricity_storage_0) ++8.231343625058066 InvestmentFlowBlock_invest(electricity_storage_1) ++6.116009561015236 InvestmentFlowBlock_invest(electricity_storage_2) ++5.017258045399043 InvestmentFlowBlock_invest(electricity_storage_3) ++4.544285192584936 InvestmentFlowBlock_invest(electricity_storage_4) ++3.7278966318848936 InvestmentFlowBlock_invest(electricity_storage_5) ++2.769882109365063 InvestmentFlowBlock_invest(electricity_storage_6) ++1.864051255691565 InvestmentFlowBlock_invest(electricity_storage_7) ++12.231343625058066 GenericInvestmentStorageBlock_invest(storage_0) ++8.231343625058066 GenericInvestmentStorageBlock_invest(storage_1) ++6.116009561015236 GenericInvestmentStorageBlock_invest(storage_2) ++5.017258045399043 GenericInvestmentStorageBlock_invest(storage_3) ++4.544285192584936 GenericInvestmentStorageBlock_invest(storage_4) ++3.7278966318848936 GenericInvestmentStorageBlock_invest(storage_5) ++2.769882109365063 GenericInvestmentStorageBlock_invest(storage_6) ++1.864051255691565 GenericInvestmentStorageBlock_invest(storage_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_0) ++100 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_1) ++100 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_2) ++100 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_3) ++67.29713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_4) ++67.29713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_5) ++0.6729713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_5) ++67.29713331080575 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_6) ++50.00276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_7) ++50.00276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_8) ++0.5000276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_8) ++50.00276133592969 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_9) ++41.01968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_10) ++41.01968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_11) ++0.4101968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_11) ++41.01968025099306 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_12) ++37.15278821269615 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_13) ++37.15278821269615 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_14) ++0.37152788212696153 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_14) ++37.15278821269615 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_15) ++30.478226645906993 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_16) ++30.478226645906993 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_17) ++0.3047822664590699 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_17) ++30.478226645906993 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_18) ++22.645771341837463 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_19) ++22.645771341837463 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_20) ++0.22645771341837465 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_20) ++22.645771341837463 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_21) ++15.239954929176601 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_22) ++15.239954929176601 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_23) ++0.15239954929176602 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_23) ++15.239954929176601 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) ++455.88267648036174 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_0) ++233.38374795126995 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_1) ++144.56161688922427 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_2) ++106.29941341240747 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_3) ++91.48640392066359 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_4) ++68.26495688582924 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_5) ++44.80528445188661 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_6) ++26.387865849578166 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_0) ++100 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_1) ++100 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) ++100 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_2) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) ++67.29713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_3) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) ++67.29713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_4) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) ++0.6729713331080575 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) ++67.29713331080575 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_5) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) ++50.00276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_6) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) ++50.00276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_7) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) ++0.5000276133592969 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) ++50.00276133592969 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_8) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) ++41.01968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_9) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) ++41.01968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_10) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) ++0.4101968025099306 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) ++41.01968025099306 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_11) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) ++37.15278821269615 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_12) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) ++37.15278821269615 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_13) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) ++0.37152788212696153 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) ++37.15278821269615 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_14) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) ++30.478226645906993 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_15) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) ++30.478226645906993 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_16) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) ++0.3047822664590699 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) ++30.478226645906993 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_17) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) ++22.645771341837463 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_18) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) ++22.645771341837463 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_19) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) ++0.22645771341837465 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) ++22.645771341837463 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_20) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) ++15.239954929176601 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_21) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) ++15.239954929176601 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_22) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) ++0.15239954929176602 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) ++15.239954929176601 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_23) ++455.88267648036174 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_0) ++233.38374795126995 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_1) ++144.56161688922427 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_2) ++106.29941341240747 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_3) ++91.48640392066359 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_4) ++68.26495688582924 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_5) ++44.80528445188661 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_6) ++26.387865849578166 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_7) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_0) ++100 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_1) ++100 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_2) ++100 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_2) ++0.6729713331080575 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_3) ++0.6729713331080575 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_3) ++67.29713331080575 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_3) ++0.6729713331080575 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_4) ++0.6729713331080575 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_4) ++67.29713331080575 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_4) ++0.6729713331080575 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_5) ++0.6729713331080575 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_5) ++67.29713331080575 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_5) ++0.5000276133592969 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_6) ++0.5000276133592969 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_6) ++50.00276133592969 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_6) ++0.5000276133592969 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_7) ++0.5000276133592969 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_7) ++50.00276133592969 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_7) ++0.5000276133592969 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_8) ++0.5000276133592969 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_8) ++50.00276133592969 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_8) ++0.4101968025099306 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_9) ++0.4101968025099306 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_9) ++41.01968025099306 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_9) ++0.4101968025099306 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_10) ++0.4101968025099306 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_10) ++41.01968025099306 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_10) ++0.4101968025099306 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_11) ++0.4101968025099306 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_11) ++41.01968025099306 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_11) ++0.37152788212696153 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_12) ++0.37152788212696153 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_12) ++37.15278821269615 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_12) ++0.37152788212696153 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_13) ++0.37152788212696153 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_13) ++37.15278821269615 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_13) ++0.37152788212696153 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_14) ++0.37152788212696153 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_14) ++37.15278821269615 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_14) ++0.3047822664590699 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_15) ++0.3047822664590699 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_15) ++30.478226645906993 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_15) ++0.3047822664590699 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_16) ++0.3047822664590699 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_16) ++30.478226645906993 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_16) ++0.3047822664590699 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_17) ++0.3047822664590699 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_17) ++30.478226645906993 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_17) ++0.22645771341837465 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_18) ++0.22645771341837465 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_18) ++22.645771341837463 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_18) ++0.22645771341837465 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_19) ++0.22645771341837465 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_19) ++22.645771341837463 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_19) ++0.22645771341837465 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_20) ++0.22645771341837465 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_20) ++22.645771341837463 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_20) ++0.15239954929176602 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_21) ++0.15239954929176602 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_21) ++15.239954929176601 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_21) ++0.15239954929176602 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_22) ++0.15239954929176602 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_22) ++15.239954929176601 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_22) ++0.15239954929176602 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_23) ++0.15239954929176602 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_23) ++15.239954929176601 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_23) ++455.88267648036174 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_0) ++233.38374795126995 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_1) ++144.56161688922427 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_2) ++106.29941341240747 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_3) ++91.48640392066359 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_4) ++68.26495688582924 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_5) ++44.80528445188661 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_6) ++26.387865849578166 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_7) + +s.t. + +c_e_BusBlock_balance(electricity_0_0)_: ++1 flow(storage_electricity_0_0) +-1 flow(electricity_storage_0_0) +-1 flow(electricity_demand_dsm_diw_0_0) +-1 flow(electricity_demand_dsm_dlr_0_0) +-1 flow(electricity_demand_dsm_oemof_0_0) += 0 + +c_e_BusBlock_balance(electricity_0_1)_: ++1 flow(storage_electricity_0_1) +-1 flow(electricity_storage_0_1) +-1 flow(electricity_demand_dsm_diw_0_1) +-1 flow(electricity_demand_dsm_dlr_0_1) +-1 flow(electricity_demand_dsm_oemof_0_1) += 0 + +c_e_BusBlock_balance(electricity_0_2)_: ++1 flow(storage_electricity_0_2) +-1 flow(electricity_storage_0_2) +-1 flow(electricity_demand_dsm_diw_0_2) +-1 flow(electricity_demand_dsm_dlr_0_2) +-1 flow(electricity_demand_dsm_oemof_0_2) += 0 + +c_e_BusBlock_balance(electricity_1_3)_: ++1 flow(storage_electricity_1_3) +-1 flow(electricity_storage_1_3) +-1 flow(electricity_demand_dsm_diw_1_3) +-1 flow(electricity_demand_dsm_dlr_1_3) +-1 flow(electricity_demand_dsm_oemof_1_3) += 0 + +c_e_BusBlock_balance(electricity_1_4)_: ++1 flow(storage_electricity_1_4) +-1 flow(electricity_storage_1_4) +-1 flow(electricity_demand_dsm_diw_1_4) +-1 flow(electricity_demand_dsm_dlr_1_4) +-1 flow(electricity_demand_dsm_oemof_1_4) += 0 + +c_e_BusBlock_balance(electricity_1_5)_: ++1 flow(storage_electricity_1_5) +-1 flow(electricity_storage_1_5) +-1 flow(electricity_demand_dsm_diw_1_5) +-1 flow(electricity_demand_dsm_dlr_1_5) +-1 flow(electricity_demand_dsm_oemof_1_5) += 0 + +c_e_BusBlock_balance(electricity_2_6)_: ++1 flow(storage_electricity_2_6) +-1 flow(electricity_storage_2_6) +-1 flow(electricity_demand_dsm_diw_2_6) +-1 flow(electricity_demand_dsm_dlr_2_6) +-1 flow(electricity_demand_dsm_oemof_2_6) += 0 + +c_e_BusBlock_balance(electricity_2_7)_: ++1 flow(storage_electricity_2_7) +-1 flow(electricity_storage_2_7) +-1 flow(electricity_demand_dsm_diw_2_7) +-1 flow(electricity_demand_dsm_dlr_2_7) +-1 flow(electricity_demand_dsm_oemof_2_7) += 0 + +c_e_BusBlock_balance(electricity_2_8)_: ++1 flow(storage_electricity_2_8) +-1 flow(electricity_storage_2_8) +-1 flow(electricity_demand_dsm_diw_2_8) +-1 flow(electricity_demand_dsm_dlr_2_8) +-1 flow(electricity_demand_dsm_oemof_2_8) += 0 + +c_e_BusBlock_balance(electricity_3_9)_: ++1 flow(storage_electricity_3_9) +-1 flow(electricity_storage_3_9) +-1 flow(electricity_demand_dsm_diw_3_9) +-1 flow(electricity_demand_dsm_dlr_3_9) +-1 flow(electricity_demand_dsm_oemof_3_9) += 0 + +c_e_BusBlock_balance(electricity_3_10)_: ++1 flow(storage_electricity_3_10) +-1 flow(electricity_storage_3_10) +-1 flow(electricity_demand_dsm_diw_3_10) +-1 flow(electricity_demand_dsm_dlr_3_10) +-1 flow(electricity_demand_dsm_oemof_3_10) += 0 + +c_e_BusBlock_balance(electricity_3_11)_: ++1 flow(storage_electricity_3_11) +-1 flow(electricity_storage_3_11) +-1 flow(electricity_demand_dsm_diw_3_11) +-1 flow(electricity_demand_dsm_dlr_3_11) +-1 flow(electricity_demand_dsm_oemof_3_11) += 0 + +c_e_BusBlock_balance(electricity_4_12)_: ++1 flow(storage_electricity_4_12) +-1 flow(electricity_storage_4_12) +-1 flow(electricity_demand_dsm_diw_4_12) +-1 flow(electricity_demand_dsm_dlr_4_12) +-1 flow(electricity_demand_dsm_oemof_4_12) += 0 + +c_e_BusBlock_balance(electricity_4_13)_: ++1 flow(storage_electricity_4_13) +-1 flow(electricity_storage_4_13) +-1 flow(electricity_demand_dsm_diw_4_13) +-1 flow(electricity_demand_dsm_dlr_4_13) +-1 flow(electricity_demand_dsm_oemof_4_13) += 0 + +c_e_BusBlock_balance(electricity_4_14)_: ++1 flow(storage_electricity_4_14) +-1 flow(electricity_storage_4_14) +-1 flow(electricity_demand_dsm_diw_4_14) +-1 flow(electricity_demand_dsm_dlr_4_14) +-1 flow(electricity_demand_dsm_oemof_4_14) += 0 + +c_e_BusBlock_balance(electricity_5_15)_: ++1 flow(storage_electricity_5_15) +-1 flow(electricity_storage_5_15) +-1 flow(electricity_demand_dsm_diw_5_15) +-1 flow(electricity_demand_dsm_dlr_5_15) +-1 flow(electricity_demand_dsm_oemof_5_15) += 0 + +c_e_BusBlock_balance(electricity_5_16)_: ++1 flow(storage_electricity_5_16) +-1 flow(electricity_storage_5_16) +-1 flow(electricity_demand_dsm_diw_5_16) +-1 flow(electricity_demand_dsm_dlr_5_16) +-1 flow(electricity_demand_dsm_oemof_5_16) += 0 + +c_e_BusBlock_balance(electricity_5_17)_: ++1 flow(storage_electricity_5_17) +-1 flow(electricity_storage_5_17) +-1 flow(electricity_demand_dsm_diw_5_17) +-1 flow(electricity_demand_dsm_dlr_5_17) +-1 flow(electricity_demand_dsm_oemof_5_17) += 0 + +c_e_BusBlock_balance(electricity_6_18)_: ++1 flow(storage_electricity_6_18) +-1 flow(electricity_storage_6_18) +-1 flow(electricity_demand_dsm_diw_6_18) +-1 flow(electricity_demand_dsm_dlr_6_18) +-1 flow(electricity_demand_dsm_oemof_6_18) += 0 + +c_e_BusBlock_balance(electricity_6_19)_: ++1 flow(storage_electricity_6_19) +-1 flow(electricity_storage_6_19) +-1 flow(electricity_demand_dsm_diw_6_19) +-1 flow(electricity_demand_dsm_dlr_6_19) +-1 flow(electricity_demand_dsm_oemof_6_19) += 0 + +c_e_BusBlock_balance(electricity_6_20)_: ++1 flow(storage_electricity_6_20) +-1 flow(electricity_storage_6_20) +-1 flow(electricity_demand_dsm_diw_6_20) +-1 flow(electricity_demand_dsm_dlr_6_20) +-1 flow(electricity_demand_dsm_oemof_6_20) += 0 + +c_e_BusBlock_balance(electricity_7_21)_: ++1 flow(storage_electricity_7_21) +-1 flow(electricity_storage_7_21) +-1 flow(electricity_demand_dsm_diw_7_21) +-1 flow(electricity_demand_dsm_dlr_7_21) +-1 flow(electricity_demand_dsm_oemof_7_21) += 0 + +c_e_BusBlock_balance(electricity_7_22)_: ++1 flow(storage_electricity_7_22) +-1 flow(electricity_storage_7_22) +-1 flow(electricity_demand_dsm_diw_7_22) +-1 flow(electricity_demand_dsm_dlr_7_22) +-1 flow(electricity_demand_dsm_oemof_7_22) += 0 + +c_e_BusBlock_balance(electricity_7_23)_: ++1 flow(storage_electricity_7_23) +-1 flow(electricity_storage_7_23) +-1 flow(electricity_demand_dsm_diw_7_23) +-1 flow(electricity_demand_dsm_dlr_7_23) +-1 flow(electricity_demand_dsm_oemof_7_23) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_0)_: +-1 InvestmentFlowBlock_invest(storage_electricity_0) ++1 InvestmentFlowBlock_total(storage_electricity_0) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_1)_: +-1 InvestmentFlowBlock_invest(storage_electricity_1) +-1 InvestmentFlowBlock_total(storage_electricity_0) ++1 InvestmentFlowBlock_total(storage_electricity_1) ++1 InvestmentFlowBlock_old(storage_electricity_1) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_2)_: +-1 InvestmentFlowBlock_invest(storage_electricity_2) +-1 InvestmentFlowBlock_total(storage_electricity_1) ++1 InvestmentFlowBlock_total(storage_electricity_2) ++1 InvestmentFlowBlock_old(storage_electricity_2) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_3)_: +-1 InvestmentFlowBlock_invest(storage_electricity_3) +-1 InvestmentFlowBlock_total(storage_electricity_2) ++1 InvestmentFlowBlock_total(storage_electricity_3) ++1 InvestmentFlowBlock_old(storage_electricity_3) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_4)_: +-1 InvestmentFlowBlock_invest(storage_electricity_4) +-1 InvestmentFlowBlock_total(storage_electricity_3) ++1 InvestmentFlowBlock_total(storage_electricity_4) ++1 InvestmentFlowBlock_old(storage_electricity_4) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_5)_: +-1 InvestmentFlowBlock_invest(storage_electricity_5) +-1 InvestmentFlowBlock_total(storage_electricity_4) ++1 InvestmentFlowBlock_total(storage_electricity_5) ++1 InvestmentFlowBlock_old(storage_electricity_5) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_6)_: +-1 InvestmentFlowBlock_invest(storage_electricity_6) +-1 InvestmentFlowBlock_total(storage_electricity_5) ++1 InvestmentFlowBlock_total(storage_electricity_6) ++1 InvestmentFlowBlock_old(storage_electricity_6) += 0 + +c_e_InvestmentFlowBlock_total_rule(storage_electricity_7)_: +-1 InvestmentFlowBlock_invest(storage_electricity_7) +-1 InvestmentFlowBlock_total(storage_electricity_6) ++1 InvestmentFlowBlock_total(storage_electricity_7) ++1 InvestmentFlowBlock_old(storage_electricity_7) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_0)_: +-1 InvestmentFlowBlock_invest(electricity_storage_0) ++1 InvestmentFlowBlock_total(electricity_storage_0) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_1)_: +-1 InvestmentFlowBlock_invest(electricity_storage_1) +-1 InvestmentFlowBlock_total(electricity_storage_0) ++1 InvestmentFlowBlock_total(electricity_storage_1) ++1 InvestmentFlowBlock_old(electricity_storage_1) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_2)_: +-1 InvestmentFlowBlock_invest(electricity_storage_2) +-1 InvestmentFlowBlock_total(electricity_storage_1) ++1 InvestmentFlowBlock_total(electricity_storage_2) ++1 InvestmentFlowBlock_old(electricity_storage_2) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_3)_: +-1 InvestmentFlowBlock_invest(electricity_storage_3) +-1 InvestmentFlowBlock_total(electricity_storage_2) ++1 InvestmentFlowBlock_total(electricity_storage_3) ++1 InvestmentFlowBlock_old(electricity_storage_3) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_4)_: +-1 InvestmentFlowBlock_invest(electricity_storage_4) +-1 InvestmentFlowBlock_total(electricity_storage_3) ++1 InvestmentFlowBlock_total(electricity_storage_4) ++1 InvestmentFlowBlock_old(electricity_storage_4) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_5)_: +-1 InvestmentFlowBlock_invest(electricity_storage_5) +-1 InvestmentFlowBlock_total(electricity_storage_4) ++1 InvestmentFlowBlock_total(electricity_storage_5) ++1 InvestmentFlowBlock_old(electricity_storage_5) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_6)_: +-1 InvestmentFlowBlock_invest(electricity_storage_6) +-1 InvestmentFlowBlock_total(electricity_storage_5) ++1 InvestmentFlowBlock_total(electricity_storage_6) ++1 InvestmentFlowBlock_old(electricity_storage_6) += 0 + +c_e_InvestmentFlowBlock_total_rule(electricity_storage_7)_: +-1 InvestmentFlowBlock_invest(electricity_storage_7) +-1 InvestmentFlowBlock_total(electricity_storage_6) ++1 InvestmentFlowBlock_total(electricity_storage_7) ++1 InvestmentFlowBlock_old(electricity_storage_7) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_0)_: ++1 InvestmentFlowBlock_old_end(storage_electricity_0) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_1)_: +-1 InvestmentFlowBlock_invest(storage_electricity_0) ++1 InvestmentFlowBlock_old_end(storage_electricity_1) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_2)_: ++1 InvestmentFlowBlock_old_end(storage_electricity_2) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_3)_: +-1 InvestmentFlowBlock_invest(storage_electricity_1) ++1 InvestmentFlowBlock_old_end(storage_electricity_3) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_4)_: ++1 InvestmentFlowBlock_old_end(storage_electricity_4) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_5)_: +-1 InvestmentFlowBlock_invest(storage_electricity_2) ++1 InvestmentFlowBlock_old_end(storage_electricity_5) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_6)_: +-1 InvestmentFlowBlock_invest(storage_electricity_3) +-1 InvestmentFlowBlock_invest(storage_electricity_4) ++1 InvestmentFlowBlock_old_end(storage_electricity_6) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(storage_electricity_7)_: +-1 InvestmentFlowBlock_invest(storage_electricity_5) +-1 InvestmentFlowBlock_invest(storage_electricity_6) ++1 InvestmentFlowBlock_old_end(storage_electricity_7) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_0)_: ++1 InvestmentFlowBlock_old_end(electricity_storage_0) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_1)_: +-1 InvestmentFlowBlock_invest(electricity_storage_0) ++1 InvestmentFlowBlock_old_end(electricity_storage_1) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_2)_: ++1 InvestmentFlowBlock_old_end(electricity_storage_2) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_3)_: +-1 InvestmentFlowBlock_invest(electricity_storage_1) ++1 InvestmentFlowBlock_old_end(electricity_storage_3) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_4)_: ++1 InvestmentFlowBlock_old_end(electricity_storage_4) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_5)_: +-1 InvestmentFlowBlock_invest(electricity_storage_2) ++1 InvestmentFlowBlock_old_end(electricity_storage_5) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_6)_: +-1 InvestmentFlowBlock_invest(electricity_storage_3) +-1 InvestmentFlowBlock_invest(electricity_storage_4) ++1 InvestmentFlowBlock_old_end(electricity_storage_6) += 0 + +c_e_InvestmentFlowBlock_old_rule_end(electricity_storage_7)_: +-1 InvestmentFlowBlock_invest(electricity_storage_5) +-1 InvestmentFlowBlock_invest(electricity_storage_6) ++1 InvestmentFlowBlock_old_end(electricity_storage_7) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_0)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_0) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_1)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_1) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_2)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_2) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_3)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_3) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_4)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_4) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_5)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_5) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_6)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_6) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(storage_electricity_7)_: ++1 InvestmentFlowBlock_old_exo(storage_electricity_7) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_0)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_0) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_1)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_1) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_2)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_2) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_3)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_3) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_4)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_4) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_5)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_5) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_6)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_6) += 0 + +c_e_InvestmentFlowBlock_old_rule_exo(electricity_storage_7)_: ++1 InvestmentFlowBlock_old_exo(electricity_storage_7) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_0)_: +-1 InvestmentFlowBlock_old_end(storage_electricity_0) +-1 InvestmentFlowBlock_old_exo(storage_electricity_0) ++1 InvestmentFlowBlock_old(storage_electricity_0) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_1)_: ++1 InvestmentFlowBlock_old(storage_electricity_1) +-1 InvestmentFlowBlock_old_end(storage_electricity_1) +-1 InvestmentFlowBlock_old_exo(storage_electricity_1) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_2)_: ++1 InvestmentFlowBlock_old(storage_electricity_2) +-1 InvestmentFlowBlock_old_end(storage_electricity_2) +-1 InvestmentFlowBlock_old_exo(storage_electricity_2) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_3)_: ++1 InvestmentFlowBlock_old(storage_electricity_3) +-1 InvestmentFlowBlock_old_end(storage_electricity_3) +-1 InvestmentFlowBlock_old_exo(storage_electricity_3) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_4)_: ++1 InvestmentFlowBlock_old(storage_electricity_4) +-1 InvestmentFlowBlock_old_end(storage_electricity_4) +-1 InvestmentFlowBlock_old_exo(storage_electricity_4) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_5)_: ++1 InvestmentFlowBlock_old(storage_electricity_5) +-1 InvestmentFlowBlock_old_end(storage_electricity_5) +-1 InvestmentFlowBlock_old_exo(storage_electricity_5) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_6)_: ++1 InvestmentFlowBlock_old(storage_electricity_6) +-1 InvestmentFlowBlock_old_end(storage_electricity_6) +-1 InvestmentFlowBlock_old_exo(storage_electricity_6) += 0 + +c_e_InvestmentFlowBlock_old_rule(storage_electricity_7)_: ++1 InvestmentFlowBlock_old(storage_electricity_7) +-1 InvestmentFlowBlock_old_end(storage_electricity_7) +-1 InvestmentFlowBlock_old_exo(storage_electricity_7) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_0)_: +-1 InvestmentFlowBlock_old_end(electricity_storage_0) +-1 InvestmentFlowBlock_old_exo(electricity_storage_0) ++1 InvestmentFlowBlock_old(electricity_storage_0) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_1)_: ++1 InvestmentFlowBlock_old(electricity_storage_1) +-1 InvestmentFlowBlock_old_end(electricity_storage_1) +-1 InvestmentFlowBlock_old_exo(electricity_storage_1) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_2)_: ++1 InvestmentFlowBlock_old(electricity_storage_2) +-1 InvestmentFlowBlock_old_end(electricity_storage_2) +-1 InvestmentFlowBlock_old_exo(electricity_storage_2) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_3)_: ++1 InvestmentFlowBlock_old(electricity_storage_3) +-1 InvestmentFlowBlock_old_end(electricity_storage_3) +-1 InvestmentFlowBlock_old_exo(electricity_storage_3) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_4)_: ++1 InvestmentFlowBlock_old(electricity_storage_4) +-1 InvestmentFlowBlock_old_end(electricity_storage_4) +-1 InvestmentFlowBlock_old_exo(electricity_storage_4) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_5)_: ++1 InvestmentFlowBlock_old(electricity_storage_5) +-1 InvestmentFlowBlock_old_end(electricity_storage_5) +-1 InvestmentFlowBlock_old_exo(electricity_storage_5) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_6)_: ++1 InvestmentFlowBlock_old(electricity_storage_6) +-1 InvestmentFlowBlock_old_end(electricity_storage_6) +-1 InvestmentFlowBlock_old_exo(electricity_storage_6) += 0 + +c_e_InvestmentFlowBlock_old_rule(electricity_storage_7)_: ++1 InvestmentFlowBlock_old(electricity_storage_7) +-1 InvestmentFlowBlock_old_end(electricity_storage_7) +-1 InvestmentFlowBlock_old_exo(electricity_storage_7) += 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_0_0)_: ++1 flow(storage_electricity_0_0) +-1 InvestmentFlowBlock_total(storage_electricity_0) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_0_1)_: ++1 flow(storage_electricity_0_1) +-1 InvestmentFlowBlock_total(storage_electricity_0) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_0_2)_: ++1 flow(storage_electricity_0_2) +-1 InvestmentFlowBlock_total(storage_electricity_0) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_1_3)_: ++1 flow(storage_electricity_1_3) +-1 InvestmentFlowBlock_total(storage_electricity_1) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_1_4)_: ++1 flow(storage_electricity_1_4) +-1 InvestmentFlowBlock_total(storage_electricity_1) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_1_5)_: ++1 flow(storage_electricity_1_5) +-1 InvestmentFlowBlock_total(storage_electricity_1) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_2_6)_: ++1 flow(storage_electricity_2_6) +-1 InvestmentFlowBlock_total(storage_electricity_2) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_2_7)_: ++1 flow(storage_electricity_2_7) +-1 InvestmentFlowBlock_total(storage_electricity_2) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_2_8)_: ++1 flow(storage_electricity_2_8) +-1 InvestmentFlowBlock_total(storage_electricity_2) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_3_9)_: ++1 flow(storage_electricity_3_9) +-1 InvestmentFlowBlock_total(storage_electricity_3) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_3_10)_: ++1 flow(storage_electricity_3_10) +-1 InvestmentFlowBlock_total(storage_electricity_3) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_3_11)_: ++1 flow(storage_electricity_3_11) +-1 InvestmentFlowBlock_total(storage_electricity_3) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_4_12)_: ++1 flow(storage_electricity_4_12) +-1 InvestmentFlowBlock_total(storage_electricity_4) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_4_13)_: ++1 flow(storage_electricity_4_13) +-1 InvestmentFlowBlock_total(storage_electricity_4) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_4_14)_: ++1 flow(storage_electricity_4_14) +-1 InvestmentFlowBlock_total(storage_electricity_4) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_5_15)_: ++1 flow(storage_electricity_5_15) +-1 InvestmentFlowBlock_total(storage_electricity_5) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_5_16)_: ++1 flow(storage_electricity_5_16) +-1 InvestmentFlowBlock_total(storage_electricity_5) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_5_17)_: ++1 flow(storage_electricity_5_17) +-1 InvestmentFlowBlock_total(storage_electricity_5) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_6_18)_: ++1 flow(storage_electricity_6_18) +-1 InvestmentFlowBlock_total(storage_electricity_6) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_6_19)_: ++1 flow(storage_electricity_6_19) +-1 InvestmentFlowBlock_total(storage_electricity_6) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_6_20)_: ++1 flow(storage_electricity_6_20) +-1 InvestmentFlowBlock_total(storage_electricity_6) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_7_21)_: ++1 flow(storage_electricity_7_21) +-1 InvestmentFlowBlock_total(storage_electricity_7) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_7_22)_: ++1 flow(storage_electricity_7_22) +-1 InvestmentFlowBlock_total(storage_electricity_7) +<= 0 + +c_u_InvestmentFlowBlock_max(storage_electricity_7_23)_: ++1 flow(storage_electricity_7_23) +-1 InvestmentFlowBlock_total(storage_electricity_7) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_0_0)_: ++1 flow(electricity_storage_0_0) +-1 InvestmentFlowBlock_total(electricity_storage_0) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_0_1)_: ++1 flow(electricity_storage_0_1) +-1 InvestmentFlowBlock_total(electricity_storage_0) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_0_2)_: ++1 flow(electricity_storage_0_2) +-1 InvestmentFlowBlock_total(electricity_storage_0) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_1_3)_: ++1 flow(electricity_storage_1_3) +-1 InvestmentFlowBlock_total(electricity_storage_1) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_1_4)_: ++1 flow(electricity_storage_1_4) +-1 InvestmentFlowBlock_total(electricity_storage_1) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_1_5)_: ++1 flow(electricity_storage_1_5) +-1 InvestmentFlowBlock_total(electricity_storage_1) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_2_6)_: ++1 flow(electricity_storage_2_6) +-1 InvestmentFlowBlock_total(electricity_storage_2) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_2_7)_: ++1 flow(electricity_storage_2_7) +-1 InvestmentFlowBlock_total(electricity_storage_2) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_2_8)_: ++1 flow(electricity_storage_2_8) +-1 InvestmentFlowBlock_total(electricity_storage_2) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_3_9)_: ++1 flow(electricity_storage_3_9) +-1 InvestmentFlowBlock_total(electricity_storage_3) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_3_10)_: ++1 flow(electricity_storage_3_10) +-1 InvestmentFlowBlock_total(electricity_storage_3) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_3_11)_: ++1 flow(electricity_storage_3_11) +-1 InvestmentFlowBlock_total(electricity_storage_3) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_4_12)_: ++1 flow(electricity_storage_4_12) +-1 InvestmentFlowBlock_total(electricity_storage_4) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_4_13)_: ++1 flow(electricity_storage_4_13) +-1 InvestmentFlowBlock_total(electricity_storage_4) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_4_14)_: ++1 flow(electricity_storage_4_14) +-1 InvestmentFlowBlock_total(electricity_storage_4) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_5_15)_: ++1 flow(electricity_storage_5_15) +-1 InvestmentFlowBlock_total(electricity_storage_5) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_5_16)_: ++1 flow(electricity_storage_5_16) +-1 InvestmentFlowBlock_total(electricity_storage_5) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_5_17)_: ++1 flow(electricity_storage_5_17) +-1 InvestmentFlowBlock_total(electricity_storage_5) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_6_18)_: ++1 flow(electricity_storage_6_18) +-1 InvestmentFlowBlock_total(electricity_storage_6) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_6_19)_: ++1 flow(electricity_storage_6_19) +-1 InvestmentFlowBlock_total(electricity_storage_6) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_6_20)_: ++1 flow(electricity_storage_6_20) +-1 InvestmentFlowBlock_total(electricity_storage_6) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_7_21)_: ++1 flow(electricity_storage_7_21) +-1 InvestmentFlowBlock_total(electricity_storage_7) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_7_22)_: ++1 flow(electricity_storage_7_22) +-1 InvestmentFlowBlock_total(electricity_storage_7) +<= 0 + +c_u_InvestmentFlowBlock_max(electricity_storage_7_23)_: ++1 flow(electricity_storage_7_23) +-1 InvestmentFlowBlock_total(electricity_storage_7) +<= 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_0)_: +-1 GenericInvestmentStorageBlock_invest(storage_0) ++1 GenericInvestmentStorageBlock_total(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_1)_: +-1 GenericInvestmentStorageBlock_invest(storage_1) +-1 GenericInvestmentStorageBlock_total(storage_0) ++1 GenericInvestmentStorageBlock_total(storage_1) ++1 GenericInvestmentStorageBlock_old(storage_1) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_2)_: +-1 GenericInvestmentStorageBlock_invest(storage_2) +-1 GenericInvestmentStorageBlock_total(storage_1) ++1 GenericInvestmentStorageBlock_total(storage_2) ++1 GenericInvestmentStorageBlock_old(storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_3)_: +-1 GenericInvestmentStorageBlock_invest(storage_3) +-1 GenericInvestmentStorageBlock_total(storage_2) ++1 GenericInvestmentStorageBlock_total(storage_3) ++1 GenericInvestmentStorageBlock_old(storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_4)_: +-1 GenericInvestmentStorageBlock_invest(storage_4) +-1 GenericInvestmentStorageBlock_total(storage_3) ++1 GenericInvestmentStorageBlock_total(storage_4) ++1 GenericInvestmentStorageBlock_old(storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_5)_: +-1 GenericInvestmentStorageBlock_invest(storage_5) +-1 GenericInvestmentStorageBlock_total(storage_4) ++1 GenericInvestmentStorageBlock_total(storage_5) ++1 GenericInvestmentStorageBlock_old(storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_6)_: +-1 GenericInvestmentStorageBlock_invest(storage_6) +-1 GenericInvestmentStorageBlock_total(storage_5) ++1 GenericInvestmentStorageBlock_total(storage_6) ++1 GenericInvestmentStorageBlock_old(storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_total_storage_rule(storage_7)_: +-1 GenericInvestmentStorageBlock_invest(storage_7) +-1 GenericInvestmentStorageBlock_total(storage_6) ++1 GenericInvestmentStorageBlock_total(storage_7) ++1 GenericInvestmentStorageBlock_old(storage_7) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_0)_: ++1 GenericInvestmentStorageBlock_old_end(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_1)_: +-1 GenericInvestmentStorageBlock_invest(storage_0) ++1 GenericInvestmentStorageBlock_old_end(storage_1) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_2)_: ++1 GenericInvestmentStorageBlock_old_end(storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_3)_: +-1 GenericInvestmentStorageBlock_invest(storage_1) ++1 GenericInvestmentStorageBlock_old_end(storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_4)_: ++1 GenericInvestmentStorageBlock_old_end(storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_5)_: +-1 GenericInvestmentStorageBlock_invest(storage_2) ++1 GenericInvestmentStorageBlock_old_end(storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_6)_: +-1 GenericInvestmentStorageBlock_invest(storage_3) +-1 GenericInvestmentStorageBlock_invest(storage_4) ++1 GenericInvestmentStorageBlock_old_end(storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_end(storage_7)_: +-1 GenericInvestmentStorageBlock_invest(storage_5) +-1 GenericInvestmentStorageBlock_invest(storage_6) ++1 GenericInvestmentStorageBlock_old_end(storage_7) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_0)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_1)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_1) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_2)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_3)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_4)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_5)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_6)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule_exo(storage_7)_: ++1 GenericInvestmentStorageBlock_old_exo(storage_7) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_0)_: +-1 GenericInvestmentStorageBlock_old_end(storage_0) +-1 GenericInvestmentStorageBlock_old_exo(storage_0) ++1 GenericInvestmentStorageBlock_old(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_1)_: ++1 GenericInvestmentStorageBlock_old(storage_1) +-1 GenericInvestmentStorageBlock_old_end(storage_1) +-1 GenericInvestmentStorageBlock_old_exo(storage_1) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_2)_: ++1 GenericInvestmentStorageBlock_old(storage_2) +-1 GenericInvestmentStorageBlock_old_end(storage_2) +-1 GenericInvestmentStorageBlock_old_exo(storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_3)_: ++1 GenericInvestmentStorageBlock_old(storage_3) +-1 GenericInvestmentStorageBlock_old_end(storage_3) +-1 GenericInvestmentStorageBlock_old_exo(storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_4)_: ++1 GenericInvestmentStorageBlock_old(storage_4) +-1 GenericInvestmentStorageBlock_old_end(storage_4) +-1 GenericInvestmentStorageBlock_old_exo(storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_5)_: ++1 GenericInvestmentStorageBlock_old(storage_5) +-1 GenericInvestmentStorageBlock_old_end(storage_5) +-1 GenericInvestmentStorageBlock_old_exo(storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_6)_: ++1 GenericInvestmentStorageBlock_old(storage_6) +-1 GenericInvestmentStorageBlock_old_end(storage_6) +-1 GenericInvestmentStorageBlock_old_exo(storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_old_rule(storage_7)_: ++1 GenericInvestmentStorageBlock_old(storage_7) +-1 GenericInvestmentStorageBlock_old_end(storage_7) +-1 GenericInvestmentStorageBlock_old_exo(storage_7) += 0 + +c_e_GenericInvestmentStorageBlock_initially_empty(storage_0)_: +1 GenericInvestmentStorageBlock_storage_content(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_0_1)_: ++1 flow(storage_electricity_0_1) +-1 flow(electricity_storage_0_1) ++1 GenericInvestmentStorageBlock_storage_content(storage_1) +-1 GenericInvestmentStorageBlock_storage_content(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_0_2)_: ++1 flow(storage_electricity_0_2) +-1 flow(electricity_storage_0_2) +-1 GenericInvestmentStorageBlock_storage_content(storage_1) ++1 GenericInvestmentStorageBlock_storage_content(storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_1_3)_: ++1 flow(storage_electricity_1_3) +-1 flow(electricity_storage_1_3) +-1 GenericInvestmentStorageBlock_storage_content(storage_2) ++1 GenericInvestmentStorageBlock_storage_content(storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_1_4)_: ++1 flow(storage_electricity_1_4) +-1 flow(electricity_storage_1_4) +-1 GenericInvestmentStorageBlock_storage_content(storage_3) ++1 GenericInvestmentStorageBlock_storage_content(storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_1_5)_: ++1 flow(storage_electricity_1_5) +-1 flow(electricity_storage_1_5) +-1 GenericInvestmentStorageBlock_storage_content(storage_4) ++1 GenericInvestmentStorageBlock_storage_content(storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_2_6)_: ++1 flow(storage_electricity_2_6) +-1 flow(electricity_storage_2_6) +-1 GenericInvestmentStorageBlock_storage_content(storage_5) ++1 GenericInvestmentStorageBlock_storage_content(storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_2_7)_: ++1 flow(storage_electricity_2_7) +-1 flow(electricity_storage_2_7) +-1 GenericInvestmentStorageBlock_storage_content(storage_6) ++1 GenericInvestmentStorageBlock_storage_content(storage_7) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_2_8)_: ++1 flow(storage_electricity_2_8) +-1 flow(electricity_storage_2_8) +-1 GenericInvestmentStorageBlock_storage_content(storage_7) ++1 GenericInvestmentStorageBlock_storage_content(storage_8) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_3_9)_: ++1 flow(storage_electricity_3_9) +-1 flow(electricity_storage_3_9) +-1 GenericInvestmentStorageBlock_storage_content(storage_8) ++1 GenericInvestmentStorageBlock_storage_content(storage_9) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_3_10)_: ++1 flow(storage_electricity_3_10) +-1 flow(electricity_storage_3_10) +-1 GenericInvestmentStorageBlock_storage_content(storage_9) ++1 GenericInvestmentStorageBlock_storage_content(storage_10) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_3_11)_: ++1 flow(storage_electricity_3_11) +-1 flow(electricity_storage_3_11) +-1 GenericInvestmentStorageBlock_storage_content(storage_10) ++1 GenericInvestmentStorageBlock_storage_content(storage_11) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_4_12)_: ++1 flow(storage_electricity_4_12) +-1 flow(electricity_storage_4_12) +-1 GenericInvestmentStorageBlock_storage_content(storage_11) ++1 GenericInvestmentStorageBlock_storage_content(storage_12) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_4_13)_: ++1 flow(storage_electricity_4_13) +-1 flow(electricity_storage_4_13) +-1 GenericInvestmentStorageBlock_storage_content(storage_12) ++1 GenericInvestmentStorageBlock_storage_content(storage_13) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_4_14)_: ++1 flow(storage_electricity_4_14) +-1 flow(electricity_storage_4_14) +-1 GenericInvestmentStorageBlock_storage_content(storage_13) ++1 GenericInvestmentStorageBlock_storage_content(storage_14) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_5_15)_: ++1 flow(storage_electricity_5_15) +-1 flow(electricity_storage_5_15) +-1 GenericInvestmentStorageBlock_storage_content(storage_14) ++1 GenericInvestmentStorageBlock_storage_content(storage_15) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_5_16)_: ++1 flow(storage_electricity_5_16) +-1 flow(electricity_storage_5_16) +-1 GenericInvestmentStorageBlock_storage_content(storage_15) ++1 GenericInvestmentStorageBlock_storage_content(storage_16) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_5_17)_: ++1 flow(storage_electricity_5_17) +-1 flow(electricity_storage_5_17) +-1 GenericInvestmentStorageBlock_storage_content(storage_16) ++1 GenericInvestmentStorageBlock_storage_content(storage_17) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_6_18)_: ++1 flow(storage_electricity_6_18) +-1 flow(electricity_storage_6_18) +-1 GenericInvestmentStorageBlock_storage_content(storage_17) ++1 GenericInvestmentStorageBlock_storage_content(storage_18) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_6_19)_: ++1 flow(storage_electricity_6_19) +-1 flow(electricity_storage_6_19) +-1 GenericInvestmentStorageBlock_storage_content(storage_18) ++1 GenericInvestmentStorageBlock_storage_content(storage_19) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_6_20)_: ++1 flow(storage_electricity_6_20) +-1 flow(electricity_storage_6_20) +-1 GenericInvestmentStorageBlock_storage_content(storage_19) ++1 GenericInvestmentStorageBlock_storage_content(storage_20) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_7_21)_: ++1 flow(storage_electricity_7_21) +-1 flow(electricity_storage_7_21) +-1 GenericInvestmentStorageBlock_storage_content(storage_20) ++1 GenericInvestmentStorageBlock_storage_content(storage_21) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_7_22)_: ++1 flow(storage_electricity_7_22) +-1 flow(electricity_storage_7_22) +-1 GenericInvestmentStorageBlock_storage_content(storage_21) ++1 GenericInvestmentStorageBlock_storage_content(storage_22) += 0 + +c_e_GenericInvestmentStorageBlock_balance(storage_7_23)_: ++1 flow(storage_electricity_7_23) +-1 flow(electricity_storage_7_23) +-1 GenericInvestmentStorageBlock_storage_content(storage_22) ++1 GenericInvestmentStorageBlock_storage_content(storage_23) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_0)_: ++1 InvestmentFlowBlock_total(storage_electricity_0) +-1 InvestmentFlowBlock_total(electricity_storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_1)_: ++1 InvestmentFlowBlock_total(storage_electricity_1) +-1 InvestmentFlowBlock_total(electricity_storage_1) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_2)_: ++1 InvestmentFlowBlock_total(storage_electricity_2) +-1 InvestmentFlowBlock_total(electricity_storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_3)_: ++1 InvestmentFlowBlock_total(storage_electricity_3) +-1 InvestmentFlowBlock_total(electricity_storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_4)_: ++1 InvestmentFlowBlock_total(storage_electricity_4) +-1 InvestmentFlowBlock_total(electricity_storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_5)_: ++1 InvestmentFlowBlock_total(storage_electricity_5) +-1 InvestmentFlowBlock_total(electricity_storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_6)_: ++1 InvestmentFlowBlock_total(storage_electricity_6) +-1 InvestmentFlowBlock_total(electricity_storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_power_coupled(storage_7)_: ++1 InvestmentFlowBlock_total(storage_electricity_7) +-1 InvestmentFlowBlock_total(electricity_storage_7) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_0)_: ++1 InvestmentFlowBlock_total(storage_electricity_0) +-0.2 GenericInvestmentStorageBlock_total(storage_0) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_1)_: ++1 InvestmentFlowBlock_total(storage_electricity_1) +-0.2 GenericInvestmentStorageBlock_total(storage_1) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_2)_: ++1 InvestmentFlowBlock_total(storage_electricity_2) +-0.2 GenericInvestmentStorageBlock_total(storage_2) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_3)_: ++1 InvestmentFlowBlock_total(storage_electricity_3) +-0.2 GenericInvestmentStorageBlock_total(storage_3) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_4)_: ++1 InvestmentFlowBlock_total(storage_electricity_4) +-0.2 GenericInvestmentStorageBlock_total(storage_4) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_5)_: ++1 InvestmentFlowBlock_total(storage_electricity_5) +-0.2 GenericInvestmentStorageBlock_total(storage_5) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_6)_: ++1 InvestmentFlowBlock_total(storage_electricity_6) +-0.2 GenericInvestmentStorageBlock_total(storage_6) += 0 + +c_e_GenericInvestmentStorageBlock_storage_capacity_outflow(storage_7)_: ++1 InvestmentFlowBlock_total(storage_electricity_7) +-0.2 GenericInvestmentStorageBlock_total(storage_7) += 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_0_0)_: +-1 GenericInvestmentStorageBlock_total(storage_0) ++1 GenericInvestmentStorageBlock_storage_content(storage_0) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_0_1)_: +-1 GenericInvestmentStorageBlock_total(storage_0) ++1 GenericInvestmentStorageBlock_storage_content(storage_1) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_0_2)_: +-1 GenericInvestmentStorageBlock_total(storage_0) ++1 GenericInvestmentStorageBlock_storage_content(storage_2) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_1_3)_: +-1 GenericInvestmentStorageBlock_total(storage_1) ++1 GenericInvestmentStorageBlock_storage_content(storage_3) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_1_4)_: +-1 GenericInvestmentStorageBlock_total(storage_1) ++1 GenericInvestmentStorageBlock_storage_content(storage_4) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_1_5)_: +-1 GenericInvestmentStorageBlock_total(storage_1) ++1 GenericInvestmentStorageBlock_storage_content(storage_5) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_2_6)_: +-1 GenericInvestmentStorageBlock_total(storage_2) ++1 GenericInvestmentStorageBlock_storage_content(storage_6) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_2_7)_: +-1 GenericInvestmentStorageBlock_total(storage_2) ++1 GenericInvestmentStorageBlock_storage_content(storage_7) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_2_8)_: +-1 GenericInvestmentStorageBlock_total(storage_2) ++1 GenericInvestmentStorageBlock_storage_content(storage_8) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_3_9)_: +-1 GenericInvestmentStorageBlock_total(storage_3) ++1 GenericInvestmentStorageBlock_storage_content(storage_9) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_3_10)_: +-1 GenericInvestmentStorageBlock_total(storage_3) ++1 GenericInvestmentStorageBlock_storage_content(storage_10) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_3_11)_: +-1 GenericInvestmentStorageBlock_total(storage_3) ++1 GenericInvestmentStorageBlock_storage_content(storage_11) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_4_12)_: +-1 GenericInvestmentStorageBlock_total(storage_4) ++1 GenericInvestmentStorageBlock_storage_content(storage_12) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_4_13)_: +-1 GenericInvestmentStorageBlock_total(storage_4) ++1 GenericInvestmentStorageBlock_storage_content(storage_13) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_4_14)_: +-1 GenericInvestmentStorageBlock_total(storage_4) ++1 GenericInvestmentStorageBlock_storage_content(storage_14) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_5_15)_: +-1 GenericInvestmentStorageBlock_total(storage_5) ++1 GenericInvestmentStorageBlock_storage_content(storage_15) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_5_16)_: +-1 GenericInvestmentStorageBlock_total(storage_5) ++1 GenericInvestmentStorageBlock_storage_content(storage_16) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_5_17)_: +-1 GenericInvestmentStorageBlock_total(storage_5) ++1 GenericInvestmentStorageBlock_storage_content(storage_17) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_6_18)_: +-1 GenericInvestmentStorageBlock_total(storage_6) ++1 GenericInvestmentStorageBlock_storage_content(storage_18) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_6_19)_: +-1 GenericInvestmentStorageBlock_total(storage_6) ++1 GenericInvestmentStorageBlock_storage_content(storage_19) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_6_20)_: +-1 GenericInvestmentStorageBlock_total(storage_6) ++1 GenericInvestmentStorageBlock_storage_content(storage_20) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_7_21)_: +-1 GenericInvestmentStorageBlock_total(storage_7) ++1 GenericInvestmentStorageBlock_storage_content(storage_21) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_7_22)_: +-1 GenericInvestmentStorageBlock_total(storage_7) ++1 GenericInvestmentStorageBlock_storage_content(storage_22) +<= 0 + +c_u_GenericInvestmentStorageBlock_max_storage_content(storage_7_23)_: +-1 GenericInvestmentStorageBlock_total(storage_7) ++1 GenericInvestmentStorageBlock_storage_content(storage_23) +<= 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_0)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_1)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_1) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_1) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_2)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_2) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_2) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_3)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_3) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_3) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_4)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_4) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_4) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_5)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_5) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_5) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_6)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_6) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_6) += 0 + +c_e_SinkDSMDIWInvestmentBlock_total_dsm_rule(demand_dsm_diw_7)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_7) +-1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_7) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_0)_: ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_0) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_1)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_1) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_2)_: ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_2) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_3)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_3) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_4)_: ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_4) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_5)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_5) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_6)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_3) +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_4) ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_6) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_end(demand_dsm_diw_7)_: +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_5) +-1 SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_6) ++1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_7) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_0)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_0) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_1)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_1) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_2)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_2) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_3)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_3) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_4)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_4) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_5)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_5) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_6)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_6) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule_exo(demand_dsm_diw_7)_: ++1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_7) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_0)_: +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_0) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_0) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_1)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_1) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_1) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_1) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_2)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_2) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_2) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_2) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_3)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_3) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_3) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_3) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_4)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_4) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_4) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_4) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_5)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_5) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_5) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_5) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_6)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_6) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_6) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_6) += 0 + +c_e_SinkDSMDIWInvestmentBlock_old_dsm_rule(demand_dsm_diw_7)_: ++1 SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_7) +-1 SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_7) +-1 SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_7) += 0 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_0_0)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_0) +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_0) ++1 flow(electricity_demand_dsm_diw_0_0) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_0_1)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) ++1 flow(electricity_demand_dsm_diw_0_1) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_0_2)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) ++1 flow(electricity_demand_dsm_diw_0_2) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_1_3)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) ++1 flow(electricity_demand_dsm_diw_1_3) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_1_4)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) ++1 flow(electricity_demand_dsm_diw_1_4) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_1_5)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) ++1 flow(electricity_demand_dsm_diw_1_5) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_2_6)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) ++1 flow(electricity_demand_dsm_diw_2_6) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_2_7)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) ++1 flow(electricity_demand_dsm_diw_2_7) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_2_8)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) ++1 flow(electricity_demand_dsm_diw_2_8) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_3_9)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) ++1 flow(electricity_demand_dsm_diw_3_9) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_3_10)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) ++1 flow(electricity_demand_dsm_diw_3_10) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_3_11)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) ++1 flow(electricity_demand_dsm_diw_3_11) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_4_12)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) ++1 flow(electricity_demand_dsm_diw_4_12) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_4_13)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) ++1 flow(electricity_demand_dsm_diw_4_13) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_4_14)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) ++1 flow(electricity_demand_dsm_diw_4_14) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_5_15)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) ++1 flow(electricity_demand_dsm_diw_5_15) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_5_16)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) ++1 flow(electricity_demand_dsm_diw_5_16) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_5_17)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) ++1 flow(electricity_demand_dsm_diw_5_17) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_6_18)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) ++1 flow(electricity_demand_dsm_diw_6_18) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_6_19)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) ++1 flow(electricity_demand_dsm_diw_6_19) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_6_20)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) ++1 flow(electricity_demand_dsm_diw_6_20) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_7_21)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) ++1 flow(electricity_demand_dsm_diw_7_21) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_7_22)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) ++1 flow(electricity_demand_dsm_diw_7_22) += 1 + +c_e_SinkDSMDIWInvestmentBlock_input_output_relation(demand_dsm_diw_7_23)_: +-1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) ++1 flow(electricity_demand_dsm_diw_7_23) += 1 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_0)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_0) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_0) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_1) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_1)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_0) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_1) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_1) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_2) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_2)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_1) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_2) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_2) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_3) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_3)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_2) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_3) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_3) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_4) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_4)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_3) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_4) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_4) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_5) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_5)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_4) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_5) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_5) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_6) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_6)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_5) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_6) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_6) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_7) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_7)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_6) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_7) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_7) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_8) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_8)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_7) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_8) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_8) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_9) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_9)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_8) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_9) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_9) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_10) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_10)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_9) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_10) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_10) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_11) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_11)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_10) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_11) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_11) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_12) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_12)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_11) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_12) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_12) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_13) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_13)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_12) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_13) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_13) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_14) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_14)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_13) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_14) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_14) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_15) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_15)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_14) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_15) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_15) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_16) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_16)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_15) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_16) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_16) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_17) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_17)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_16) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_17) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_17) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_18) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_18)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_17) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_18) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_18) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_19) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_19)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_18) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_19) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_19) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_20) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_20)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_19) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_20) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_20) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_21) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_21)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_20) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_21) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_21) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_22) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_22)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_21) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_22) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_22) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_23) += 0 + +c_e_SinkDSMDIWInvestmentBlock_dsm_updo_constraint(demand_dsm_diw_23)_: +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_22) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_23) +-1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_23) += 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_0_0)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_0) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_0_1)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_1) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_0_2)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_2) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_1_3)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_3) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_1_4)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_4) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_1_5)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_5) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_2_6)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_6) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_2_7)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_7) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_2_8)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_8) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_3_9)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_9) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_3_10)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_10) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_3_11)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_11) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_4_12)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_12) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_4_13)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_13) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_4_14)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_14) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_5_15)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_15) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_5_16)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_16) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_5_17)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_17) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_6_18)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_18) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_6_19)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_19) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_6_20)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_20) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_7_21)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_21) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_7_22)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_22) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_up_constraint(demand_dsm_diw_7_23)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_23) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_0_0)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_0) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_0_1)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_0_2)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_1_3)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_1_4)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_1_5)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_2_6)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_2_7)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_2_8)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_3_9)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_3_10)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_3_11)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_4_12)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_4_13)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_4_14)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_5_15)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_5_16)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_5_17)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_6_18)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_6_19)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_6_20)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_7_21)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_7_22)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_dsm_do_constraint(demand_dsm_diw_7_23)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_0_0)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_0) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_0_1)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_0_2)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_1_3)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_1_4)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_1_5)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_2_6)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_2_7)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_2_8)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_3_9)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_3_10)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_3_11)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_4_12)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_4_13)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_4_14)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_5_15)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_5_16)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_5_17)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_6_18)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_6_19)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_6_20)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_7_21)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_7_22)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_C2_constraint(demand_dsm_diw_7_23)_: ++1 SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_23) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) +-0.5 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_0_0)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_0) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_0_1)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_0_2)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_1_3)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_1_4)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_1_5)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_2_6)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_2_7)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_2_8)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_3_9)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_3_10)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_3_11)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_4_12)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_4_13)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_4_14)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_5_15)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_5_16)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_5_17)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_6_18)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_6_19)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_6_20)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_7_21)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_7_22)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_shed_limit_constraint(demand_dsm_diw_7_23)_: ++1 SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) +-1.0 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 0 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_0)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_1)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_2)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_3)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_4)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_5)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_6)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) +<= 1000 + +c_u_SinkDSMDIWInvestmentBlock_overall_dsm_maximum(demand_dsm_diw_7)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +<= 1000 + +c_l_SinkDSMDIWInvestmentBlock_overall_minimum(demand_dsm_diw)_: ++1 SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) +>= 5 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_0)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_1)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_1) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_2)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_2) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_3)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_3) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_4)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_4) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_5)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_5) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_6)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_6) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_total_dsm_rule(demand_dsm_dlr_7)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_7) +-1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_0)_: ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_1)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_2)_: ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_3)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_4)_: ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_5)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_6)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_3) +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_end(demand_dsm_dlr_7)_: +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_5) +-1 SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_0)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_1)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_2)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_3)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_4)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_5)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_6)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule_exo(demand_dsm_dlr_7)_: ++1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_0)_: +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_0) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_1)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_1) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_1) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_2)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_2) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_2) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_3)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_3) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_3) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_4)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_4) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_4) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_5)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_5) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_5) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_6)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_6) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_6) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_old_dsm_rule(demand_dsm_dlr_7)_: ++1 SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_7) +-1 SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_7) +-1 SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_0_0)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_0) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_0) ++1 flow(electricity_demand_dsm_dlr_0_0) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_0_1)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_1) ++1 flow(electricity_demand_dsm_dlr_0_1) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_0_2)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_2) ++1 flow(electricity_demand_dsm_dlr_0_2) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_1_3)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_3) ++1 flow(electricity_demand_dsm_dlr_1_3) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_1_4)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_4) ++1 flow(electricity_demand_dsm_dlr_1_4) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_1_5)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_5) ++1 flow(electricity_demand_dsm_dlr_1_5) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_2_6)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_6) ++1 flow(electricity_demand_dsm_dlr_2_6) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_2_7)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_7) ++1 flow(electricity_demand_dsm_dlr_2_7) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_2_8)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_8) ++1 flow(electricity_demand_dsm_dlr_2_8) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_3_9)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_9) ++1 flow(electricity_demand_dsm_dlr_3_9) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_3_10)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_10) ++1 flow(electricity_demand_dsm_dlr_3_10) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_3_11)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_11) ++1 flow(electricity_demand_dsm_dlr_3_11) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_4_12)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_12) ++1 flow(electricity_demand_dsm_dlr_4_12) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_4_13)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_13) ++1 flow(electricity_demand_dsm_dlr_4_13) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_4_14)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_14) ++1 flow(electricity_demand_dsm_dlr_4_14) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_5_15)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_15) ++1 flow(electricity_demand_dsm_dlr_5_15) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_5_16)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_16) ++1 flow(electricity_demand_dsm_dlr_5_16) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_5_17)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_17) ++1 flow(electricity_demand_dsm_dlr_5_17) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_6_18)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_18) ++1 flow(electricity_demand_dsm_dlr_6_18) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_6_19)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_19) ++1 flow(electricity_demand_dsm_dlr_6_19) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_6_20)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_20) ++1 flow(electricity_demand_dsm_dlr_6_20) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_7_21)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_21) ++1 flow(electricity_demand_dsm_dlr_7_21) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_7_22)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_22) ++1 flow(electricity_demand_dsm_dlr_7_22) += 1 + +c_e_SinkDSMDLRInvestmentBlock_input_output_relation(demand_dsm_dlr_7_23)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_23) ++1 flow(electricity_demand_dsm_dlr_7_23) += 1 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_0)_: ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_1)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_2)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_3)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_4)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_5)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_6)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_7)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_8)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_9)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_10)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_11)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_12)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_13)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_14)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_15)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_16)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_17)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_18)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_19)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_20)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_21)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_22)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_1_23)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_0)_: ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_2)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_3)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_4)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_5)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_6)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_7)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_8)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_9)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_10)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_11)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_12)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_13)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_14)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_15)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_16)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_17)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_18)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_19)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_20)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_21)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_22)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_red(demand_dsm_dlr_2_23)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_0)_: ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_1)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_2)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_3)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_4)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_5)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_6)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_7)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_8)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_9)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_10)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_11)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_12)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_13)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_14)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_15)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_16)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_17)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_18)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_19)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_20)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_21)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_22)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_1_23)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_0)_: ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_2)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_3)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_4)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_5)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_6)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_7)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_8)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_9)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_10)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_11)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_12)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_13)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_14)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_15)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_16)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_17)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_18)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_19)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_20)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_21)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_22)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_capacity_balance_inc(demand_dsm_dlr_2_23)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_no_comp_red(demand_dsm_dlr_1_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_no_comp_red(demand_dsm_dlr_2_22)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_no_comp_red(demand_dsm_dlr_2_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_no_comp_inc(demand_dsm_dlr_1_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_no_comp_inc(demand_dsm_dlr_2_22)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_no_comp_inc(demand_dsm_dlr_2_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) += 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_0_0)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_0) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_0_1)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_1) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_0_2)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_2) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_1_3)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_3) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_1_4)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_4) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_1_5)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_5) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_2_6)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_6) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_2_7)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_7) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_2_8)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_8) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_3_9)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_9) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_3_10)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_10) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_3_11)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_11) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_4_12)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_12) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_4_13)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_13) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_4_14)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_14) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_5_15)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_15) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_5_16)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_16) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_5_17)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_17) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_6_18)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_18) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_6_19)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_19) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_6_20)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_20) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_7_21)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_21) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_7_22)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_22) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_red(demand_dsm_dlr_7_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_23) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_0_0)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_0) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_0_1)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_1) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_0_2)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_1_3)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_1_4)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_1_5)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_2_6)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_2_7)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_2_8)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_3_9)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_3_10)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_3_11)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_4_12)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_4_13)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_4_14)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_5_15)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_5_16)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_5_17)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_6_18)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_6_19)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_6_20)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_7_21)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_7_22)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_availability_inc(demand_dsm_dlr_7_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_0)_: +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) +-1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_1)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_0) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_2)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_1) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_3)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_2) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_4)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_3) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_5)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_4) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_6)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_5) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_7)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_6) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_8)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_7) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_8) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_9)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_8) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_9) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_10)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_9) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_10) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_11)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_10) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_11) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_12)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_11) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_12) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_13)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_12) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_13) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_14)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_13) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_14) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_15)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_14) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_15) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_16)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_15) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_16) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_17)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_16) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_17) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_18)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_17) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_18) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_19)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_18) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_19) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_20)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_19) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_20) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_21)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_20) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_21) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_22)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_21) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_red(demand_dsm_dlr_23)_: +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_22) +-1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_23) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_0)_: +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) +-1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_0) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_1)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_0) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_1) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_2)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_1) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_2) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_3)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_2) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_3) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_4)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_3) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_4) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_5)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_4) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_5) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_6)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_5) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_6) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_7)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_6) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_7) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_8)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_7) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_8) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_9)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_8) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_9) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_10)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_9) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_10) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_11)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_10) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_11) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_12)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_11) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_12) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_13)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_12) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_13) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_14)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_13) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_14) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_15)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_14) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_15) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_16)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_15) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_16) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_17)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_16) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_17) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_18)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_17) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_18) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_19)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_18) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_19) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_20)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_19) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_20) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_21)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_20) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_21) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_22)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_21) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_22) += 0 + +c_e_SinkDSMDLRInvestmentBlock_dr_storage_inc(demand_dsm_dlr_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) +-1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_22) +-1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_23) += 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_0_0)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_0_1)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_0_2)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_1_3)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_1_4)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_1_5)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_2_6)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_2_7)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_2_8)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_8) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_3_9)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_9) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_3_10)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_10) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_3_11)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_11) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_4_12)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_12) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_4_13)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_13) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_4_14)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_14) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_5_15)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_15) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_5_16)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_16) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_5_17)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_17) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_6_18)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_18) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_6_19)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_19) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_6_20)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_20) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_7_21)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_21) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_7_22)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_22) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_red(demand_dsm_dlr_7_23)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_23) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_0_0)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_0_1)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_0_2)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_1_3)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_1_4)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_1_5)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_2_6)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_2_7)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_2_8)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_8) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_3_9)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_9) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_3_10)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_10) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_3_11)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_11) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_4_12)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_12) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_4_13)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_13) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_4_14)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_14) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_5_15)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_15) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_5_16)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_16) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_5_17)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_17) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_6_18)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_18) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_6_19)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_19) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_6_20)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_20) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_7_21)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_21) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_7_22)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_22) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_storage_limit_inc(demand_dsm_dlr_7_23)_: +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_23) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_0)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_2) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_1)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_5) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_2)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_8) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_3)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_11) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_4)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_14) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_5)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_17) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_6)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_20) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_yearly_limit_shed(demand_dsm_dlr_7)_: ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_23) +-50.0 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_0_0)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_0) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_0) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_0_1)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_1) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_1) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_0_2)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_2) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_1_3)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_3) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_1_4)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_4) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_1_5)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_5) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_2_6)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_6) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_2_7)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_7) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_2_8)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_8) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_3_9)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_9) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_3_10)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_10) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_3_11)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_11) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_4_12)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_12) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_4_13)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_13) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_4_14)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_14) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_5_15)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_15) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_5_16)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_16) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_5_17)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_17) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_6_18)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_18) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_6_19)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_19) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_6_20)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_20) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_7_21)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_21) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_7_22)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_22) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_dr_logical_constraint(demand_dsm_dlr_7_23)_: ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) ++1 SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_23) +-0.5 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 0 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_0)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_1)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_2)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_3)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_4)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_5)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_6)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) +<= 1000 + +c_u_SinkDSMDLRInvestmentBlock_overall_dsm_maximum(demand_dsm_dlr_7)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +<= 1000 + +c_l_SinkDSMDLRInvestmentBlock_overall_minimum(demand_dsm_dlr)_: ++1 SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) +>= 5 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_0)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) += 50 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_1)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_1) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_1) += 0 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_2)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_2) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_2) += 0 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_3)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_3) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_3) += 0 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_4)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_4) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_4) += 0 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_5)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_5) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_5) += 0 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_6)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_6) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_6) += 0 + +c_e_SinkDSMOemofInvestmentBlock_total_dsm_rule(demand_dsm_oemof_7)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_7) +-1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_7) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_0)_: ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_0) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_1)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_1) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_2)_: ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_2) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_3)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_3) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_4)_: ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_4) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_5)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_5) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_6)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_3) +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_6) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_end(demand_dsm_oemof_7)_: +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_5) +-1 SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_7) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_0)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_0) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_1)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_1) += 50 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_2)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_2) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_3)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_3) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_4)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_4) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_5)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_5) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_6)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_6) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule_exo(demand_dsm_oemof_7)_: ++1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_7) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_0)_: +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_0) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_0) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_1)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_1) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_1) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_1) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_2)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_2) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_2) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_2) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_3)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_3) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_3) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_3) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_4)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_4) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_4) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_4) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_5)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_5) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_5) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_5) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_6)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_6) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_6) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_6) += 0 + +c_e_SinkDSMOemofInvestmentBlock_old_dsm_rule(demand_dsm_oemof_7)_: ++1 SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_7) +-1 SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_7) +-1 SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_7) += 0 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_0_0)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_0) +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_0) ++1 flow(electricity_demand_dsm_oemof_0_0) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_0_1)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_1) ++1 flow(electricity_demand_dsm_oemof_0_1) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_0_2)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_2) ++1 flow(electricity_demand_dsm_oemof_0_2) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_1_3)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_3) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_3) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_3) ++1 flow(electricity_demand_dsm_oemof_1_3) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_1_4)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_4) ++1 flow(electricity_demand_dsm_oemof_1_4) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_1_5)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_5) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_5) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_5) ++1 flow(electricity_demand_dsm_oemof_1_5) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_2_6)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_6) ++1 flow(electricity_demand_dsm_oemof_2_6) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_2_7)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_7) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_7) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_7) ++1 flow(electricity_demand_dsm_oemof_2_7) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_2_8)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_8) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_8) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_8) ++1 flow(electricity_demand_dsm_oemof_2_8) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_3_9)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_9) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_9) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_9) ++1 flow(electricity_demand_dsm_oemof_3_9) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_3_10)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_10) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_10) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_10) ++1 flow(electricity_demand_dsm_oemof_3_10) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_3_11)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_11) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_11) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_11) ++1 flow(electricity_demand_dsm_oemof_3_11) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_4_12)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_12) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_12) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_12) ++1 flow(electricity_demand_dsm_oemof_4_12) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_4_13)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_13) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_13) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_13) ++1 flow(electricity_demand_dsm_oemof_4_13) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_4_14)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_14) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_14) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_14) ++1 flow(electricity_demand_dsm_oemof_4_14) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_5_15)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_15) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_15) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_15) ++1 flow(electricity_demand_dsm_oemof_5_15) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_5_16)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_16) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_16) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_16) ++1 flow(electricity_demand_dsm_oemof_5_16) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_5_17)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_17) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_17) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_17) ++1 flow(electricity_demand_dsm_oemof_5_17) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_6_18)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_18) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_18) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_18) ++1 flow(electricity_demand_dsm_oemof_6_18) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_6_19)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_19) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_19) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_19) ++1 flow(electricity_demand_dsm_oemof_6_19) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_6_20)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_20) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_20) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_20) ++1 flow(electricity_demand_dsm_oemof_6_20) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_7_21)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_21) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_21) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_21) ++1 flow(electricity_demand_dsm_oemof_7_21) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_7_22)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_22) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_22) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_22) ++1 flow(electricity_demand_dsm_oemof_7_22) += 1 + +c_e_SinkDSMOemofInvestmentBlock_input_output_relation(demand_dsm_oemof_7_23)_: +-1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_23) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_23) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_23) ++1 flow(electricity_demand_dsm_oemof_7_23) += 1 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_0_0)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_0) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_0_1)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_1) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_0_2)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_2) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_1_3)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_3) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_1_4)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_4) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_1_5)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_5) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_2_6)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_6) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_2_7)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_7) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_2_8)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_8) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_3_9)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_9) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_3_10)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_10) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_3_11)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_11) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_4_12)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_12) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_4_13)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_13) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_4_14)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_14) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_5_15)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_15) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_5_16)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_16) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_5_17)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_17) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_6_18)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_18) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_6_19)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_19) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_6_20)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_20) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_7_21)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_21) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_7_22)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_22) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_up_constraint(demand_dsm_oemof_7_23)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_23) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_0_0)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_0) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_0_1)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_1) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_1) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_0_2)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_2) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_1_3)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_3) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_3) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_1_4)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_4) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_1_5)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_5) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_5) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_2_6)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_6) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_2_7)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_7) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_7) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_2_8)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_8) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_8) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_3_9)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_9) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_9) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_3_10)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_10) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_10) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_3_11)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_11) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_11) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_4_12)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_12) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_12) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_4_13)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_13) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_13) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_4_14)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_14) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_14) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_5_15)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_15) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_15) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_5_16)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_16) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_16) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_5_17)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_17) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_17) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_6_18)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_18) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_18) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_6_19)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_19) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_19) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_6_20)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_20) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_20) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_7_21)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_21) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_21) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_7_22)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_22) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_22) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 0 + +c_u_SinkDSMOemofInvestmentBlock_dsm_down_constraint(demand_dsm_oemof_7_23)_: ++1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_23) ++1 SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_23) +-0.5 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_0)_: +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_0) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_1) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_1) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_2)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_2) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_2) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_3) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_3) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_4)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_4) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_4) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_5) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_5) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_6)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_6) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_6) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_7) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_7) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_8)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_8) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_8) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_9) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_9) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_10)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_10) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_10) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_11) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_11) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_12)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_12) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_12) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_13) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_13) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_14)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_14) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_14) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_15) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_15) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_16)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_16) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_16) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_17) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_17) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_18)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_18) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_18) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_19) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_19) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_20)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_20) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_20) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_21) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_21) += 0 + +c_e_SinkDSMOemofInvestmentBlock_dsm_sum_constraint(demand_dsm_oemof_22)_: ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_22) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_22) ++1 SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_23) +-1 SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_23) += 0 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_0)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_1)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_2)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_3)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_4)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_5)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_6)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) +<= 1000 + +c_u_SinkDSMOemofInvestmentBlock_overall_dsm_maximum(demand_dsm_oemof_7)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +<= 1000 + +c_l_SinkDSMOemofInvestmentBlock_overall_minimum(demand_dsm_oemof)_: ++1 SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) +>= 5 + +bounds + 1 <= ONE_VAR_CONSTANT <= 1 + 0 <= InvestmentFlowBlock_invest(storage_electricity_0) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_1) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_2) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_3) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_4) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_5) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_6) <= +inf + 0 <= InvestmentFlowBlock_invest(storage_electricity_7) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_0) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_1) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_2) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_3) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_4) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_5) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_6) <= +inf + 0 <= InvestmentFlowBlock_invest(electricity_storage_7) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_1) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_2) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_3) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_4) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_5) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_6) <= +inf + 0 <= GenericInvestmentStorageBlock_invest(storage_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_8) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_9) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_10) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_11) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_12) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_13) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_14) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_15) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_16) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_17) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_18) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_19) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_20) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_21) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_22) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_up(demand_dsm_diw_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_0_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_1_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_2_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_3_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_4_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_5_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_6_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_7_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_8_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_9_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_10_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_11_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_12_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_13_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_14_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_15_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_16_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_17_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_18_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_19_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_20_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_21_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_22_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shift(demand_dsm_diw_23_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_dsm_do_shed(demand_dsm_diw_23) <= +inf + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_0) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_1) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_2) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_3) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_4) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_5) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_6) <= 100 + 33 <= SinkDSMDIWInvestmentBlock_invest(demand_dsm_diw_7) <= 100 + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_1_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_1_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up(demand_dsm_dlr_2_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_do(demand_dsm_dlr_2_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_1_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_1_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shift(demand_dsm_dlr_2_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_balance_dsm_up(demand_dsm_dlr_2_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_shed(demand_dsm_dlr_23) <= +inf + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_0) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_1) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_2) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_3) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_4) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_5) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_6) <= 100 + 33 <= SinkDSMDLRInvestmentBlock_invest(demand_dsm_dlr_7) <= 100 + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_0) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_0) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_0) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_8) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_8) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_8) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_9) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_9) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_9) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_10) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_10) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_10) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_11) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_11) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_11) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_12) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_12) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_12) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_13) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_13) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_13) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_14) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_14) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_14) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_15) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_15) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_15) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_16) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_16) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_16) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_17) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_17) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_17) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_18) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_18) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_18) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_19) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_19) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_19) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_20) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_20) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_20) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_21) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_21) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_21) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_22) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_22) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_22) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_up(demand_dsm_oemof_23) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shift(demand_dsm_oemof_23) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_dsm_do_shed(demand_dsm_oemof_23) <= +inf + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_0) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_1) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_2) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_3) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_4) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_5) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_6) <= 100 + 33 <= SinkDSMOemofInvestmentBlock_invest(demand_dsm_oemof_7) <= 100 + 0 <= flow(storage_electricity_0_0) <= +inf + 0 <= flow(electricity_storage_0_0) <= +inf + 0 <= flow(electricity_demand_dsm_diw_0_0) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_0_0) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_0_0) <= +inf + 0 <= flow(storage_electricity_0_1) <= +inf + 0 <= flow(electricity_storage_0_1) <= +inf + 0 <= flow(electricity_demand_dsm_diw_0_1) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_0_1) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_0_1) <= +inf + 0 <= flow(storage_electricity_0_2) <= +inf + 0 <= flow(electricity_storage_0_2) <= +inf + 0 <= flow(electricity_demand_dsm_diw_0_2) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_0_2) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_0_2) <= +inf + 0 <= flow(storage_electricity_1_3) <= +inf + 0 <= flow(electricity_storage_1_3) <= +inf + 0 <= flow(electricity_demand_dsm_diw_1_3) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_1_3) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_1_3) <= +inf + 0 <= flow(storage_electricity_1_4) <= +inf + 0 <= flow(electricity_storage_1_4) <= +inf + 0 <= flow(electricity_demand_dsm_diw_1_4) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_1_4) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_1_4) <= +inf + 0 <= flow(storage_electricity_1_5) <= +inf + 0 <= flow(electricity_storage_1_5) <= +inf + 0 <= flow(electricity_demand_dsm_diw_1_5) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_1_5) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_1_5) <= +inf + 0 <= flow(storage_electricity_2_6) <= +inf + 0 <= flow(electricity_storage_2_6) <= +inf + 0 <= flow(electricity_demand_dsm_diw_2_6) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_2_6) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_2_6) <= +inf + 0 <= flow(storage_electricity_2_7) <= +inf + 0 <= flow(electricity_storage_2_7) <= +inf + 0 <= flow(electricity_demand_dsm_diw_2_7) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_2_7) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_2_7) <= +inf + 0 <= flow(storage_electricity_2_8) <= +inf + 0 <= flow(electricity_storage_2_8) <= +inf + 0 <= flow(electricity_demand_dsm_diw_2_8) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_2_8) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_2_8) <= +inf + 0 <= flow(storage_electricity_3_9) <= +inf + 0 <= flow(electricity_storage_3_9) <= +inf + 0 <= flow(electricity_demand_dsm_diw_3_9) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_3_9) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_3_9) <= +inf + 0 <= flow(storage_electricity_3_10) <= +inf + 0 <= flow(electricity_storage_3_10) <= +inf + 0 <= flow(electricity_demand_dsm_diw_3_10) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_3_10) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_3_10) <= +inf + 0 <= flow(storage_electricity_3_11) <= +inf + 0 <= flow(electricity_storage_3_11) <= +inf + 0 <= flow(electricity_demand_dsm_diw_3_11) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_3_11) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_3_11) <= +inf + 0 <= flow(storage_electricity_4_12) <= +inf + 0 <= flow(electricity_storage_4_12) <= +inf + 0 <= flow(electricity_demand_dsm_diw_4_12) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_4_12) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_4_12) <= +inf + 0 <= flow(storage_electricity_4_13) <= +inf + 0 <= flow(electricity_storage_4_13) <= +inf + 0 <= flow(electricity_demand_dsm_diw_4_13) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_4_13) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_4_13) <= +inf + 0 <= flow(storage_electricity_4_14) <= +inf + 0 <= flow(electricity_storage_4_14) <= +inf + 0 <= flow(electricity_demand_dsm_diw_4_14) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_4_14) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_4_14) <= +inf + 0 <= flow(storage_electricity_5_15) <= +inf + 0 <= flow(electricity_storage_5_15) <= +inf + 0 <= flow(electricity_demand_dsm_diw_5_15) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_5_15) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_5_15) <= +inf + 0 <= flow(storage_electricity_5_16) <= +inf + 0 <= flow(electricity_storage_5_16) <= +inf + 0 <= flow(electricity_demand_dsm_diw_5_16) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_5_16) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_5_16) <= +inf + 0 <= flow(storage_electricity_5_17) <= +inf + 0 <= flow(electricity_storage_5_17) <= +inf + 0 <= flow(electricity_demand_dsm_diw_5_17) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_5_17) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_5_17) <= +inf + 0 <= flow(storage_electricity_6_18) <= +inf + 0 <= flow(electricity_storage_6_18) <= +inf + 0 <= flow(electricity_demand_dsm_diw_6_18) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_6_18) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_6_18) <= +inf + 0 <= flow(storage_electricity_6_19) <= +inf + 0 <= flow(electricity_storage_6_19) <= +inf + 0 <= flow(electricity_demand_dsm_diw_6_19) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_6_19) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_6_19) <= +inf + 0 <= flow(storage_electricity_6_20) <= +inf + 0 <= flow(electricity_storage_6_20) <= +inf + 0 <= flow(electricity_demand_dsm_diw_6_20) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_6_20) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_6_20) <= +inf + 0 <= flow(storage_electricity_7_21) <= +inf + 0 <= flow(electricity_storage_7_21) <= +inf + 0 <= flow(electricity_demand_dsm_diw_7_21) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_7_21) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_7_21) <= +inf + 0 <= flow(storage_electricity_7_22) <= +inf + 0 <= flow(electricity_storage_7_22) <= +inf + 0 <= flow(electricity_demand_dsm_diw_7_22) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_7_22) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_7_22) <= +inf + 0 <= flow(storage_electricity_7_23) <= +inf + 0 <= flow(electricity_storage_7_23) <= +inf + 0 <= flow(electricity_demand_dsm_diw_7_23) <= +inf + 0 <= flow(electricity_demand_dsm_dlr_7_23) <= +inf + 0 <= flow(electricity_demand_dsm_oemof_7_23) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_0) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_1) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_1) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_2) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_2) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_3) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_3) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_4) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_4) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_5) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_5) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_6) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_6) <= +inf + 0 <= InvestmentFlowBlock_total(storage_electricity_7) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_7) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_0) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_1) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_1) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_2) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_2) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_3) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_3) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_4) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_4) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_5) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_5) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_6) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_6) <= +inf + 0 <= InvestmentFlowBlock_total(electricity_storage_7) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_7) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_0) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_1) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_2) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_3) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_4) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_5) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_6) <= +inf + 0 <= InvestmentFlowBlock_old_end(storage_electricity_7) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_0) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_1) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_2) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_3) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_4) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_5) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_6) <= +inf + 0 <= InvestmentFlowBlock_old_end(electricity_storage_7) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_0) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_1) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_2) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_3) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_4) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_5) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_6) <= +inf + 0 <= InvestmentFlowBlock_old_exo(storage_electricity_7) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_0) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_1) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_2) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_3) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_4) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_5) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_6) <= +inf + 0 <= InvestmentFlowBlock_old_exo(electricity_storage_7) <= +inf + 0 <= InvestmentFlowBlock_old(storage_electricity_0) <= +inf + 0 <= InvestmentFlowBlock_old(electricity_storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_1) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_1) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_2) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_2) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_3) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_3) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_4) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_4) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_5) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_5) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_6) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_6) <= +inf + 0 <= GenericInvestmentStorageBlock_total(storage_7) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_7) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_1) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_2) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_3) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_4) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_5) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_6) <= +inf + 0 <= GenericInvestmentStorageBlock_old_end(storage_7) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_1) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_2) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_3) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_4) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_5) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_6) <= +inf + 0 <= GenericInvestmentStorageBlock_old_exo(storage_7) <= +inf + 0 <= GenericInvestmentStorageBlock_old(storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_1) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_0) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_2) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_3) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_4) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_5) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_6) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_7) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_8) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_9) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_10) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_11) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_12) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_13) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_14) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_15) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_16) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_17) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_18) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_19) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_20) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_21) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_22) <= +inf + 0 <= GenericInvestmentStorageBlock_storage_content(storage_23) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_total(demand_dsm_diw_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_end(demand_dsm_diw_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_0) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_1) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_2) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_3) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_4) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_5) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_6) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old_exo(demand_dsm_diw_7) <= +inf + 0 <= SinkDSMDIWInvestmentBlock_old(demand_dsm_diw_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_total(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_end(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old_exo(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_old(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_do_level(demand_dsm_dlr_23) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_0) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_1) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_2) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_3) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_4) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_5) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_6) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_7) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_8) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_9) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_10) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_11) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_12) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_13) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_14) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_15) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_16) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_17) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_18) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_19) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_20) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_21) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_22) <= +inf + 0 <= SinkDSMDLRInvestmentBlock_dsm_up_level(demand_dsm_dlr_23) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_0) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_total(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_0) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_end(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_0) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_1) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_2) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_3) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_4) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_5) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_6) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old_exo(demand_dsm_oemof_7) <= +inf + 0 <= SinkDSMOemofInvestmentBlock_old(demand_dsm_oemof_0) <= +inf +end diff --git a/tests/multi_period_constraint_tests.py b/tests/multi_period_constraint_tests.py index 2f2694ad1..12c49f2c1 100644 --- a/tests/multi_period_constraint_tests.py +++ b/tests/multi_period_constraint_tests.py @@ -1983,3 +1983,167 @@ def test_fixed_costs(self): ) self.energysystem.add(bel, source1, source2, source3) self.compare_lp_files("fixed_costs_sources.lp") + + def test_multi_period_varying_period_length(self): + """Test multi period with varying period length""" + + # Define starting years of investment periods + years = [2000, 2020, 2035, 2045, 2050, 2060, 2075, 2095] + + # Create a list of timeindex for each period + periods = [ + pd.date_range(f"1/1/{i}", periods=3, freq="H") for i in years + ] + + # Create an overall timeindex + timeindex = pd.concat( + [pd.Series(index=i, dtype="float64") for i in periods] + ).index + + # Create an energy system + es = solph.EnergySystem( + timeindex=timeindex, + timeincrement=[1] * len(timeindex), + periods=periods, + infer_last_interval=False, + ) + + # Create buses + bel = solph.Bus(label="electricity", balanced=True) + + # Create a storage + storage = solph.components.GenericStorage( + label="storage", + inputs={ + bel: solph.Flow( + variable_costs=0, + investment=solph.Investment( + ep_costs=10, + existing=0, + lifetime=20, + age=0, + interest_rate=0.02, + ), + ) + }, + outputs={ + bel: solph.Flow( + variable_costs=0, + investment=solph.Investment( + ep_costs=10, + existing=0, + lifetime=20, + age=0, + interest_rate=0.02, + ), + ) + }, + loss_rate=0.00, + invest_relation_output_capacity=0.2, + invest_relation_input_output=1, + # inflow_conversion_factor=1, + # outflow_conversion_factor=0.8, + # nominal_storage_capacity=100, + investment=solph.Investment( + ep_costs=10, + maximum=float("+inf"), + existing=0, + lifetime=20, + age=0, + fixed_costs=None, + interest_rate=0.02, + ), + ) + # Create a DSM sink with DIW approach + sinkdsm_diw = solph.components.experimental.SinkDSM( + label="demand_dsm_diw", + inputs={bel: solph.flows.Flow()}, + demand=[1] * len(timeindex), + capacity_up=[0.5] * len(timeindex), + capacity_down=[0.5] * len(timeindex), + approach="DIW", + max_demand=[1] * len(timeindex), + delay_time=1, + cost_dsm_down_shift=1, + cost_dsm_up=1, + cost_dsm_down_shed=100, + shed_eligibility=True, + recovery_time_shed=2, + shed_time=2, + investment=solph.Investment( + ep_costs=100, + minimum=33, + maximum=100, + lifetime=20, + fixed_costs=20, + overall_maximum=1000, + overall_minimum=5, + ), + ) + + # Create a DSM sink with DLR approach + sinkdsm_dlr = solph.components.experimental.SinkDSM( + label="demand_dsm_dlr", + inputs={bel: solph.flows.Flow()}, + demand=[1] * len(timeindex), + capacity_up=[0.5] * len(timeindex), + capacity_down=[0.5] * len(timeindex), + approach="DLR", + max_demand=[1] * len(timeindex), + delay_time=2, + shift_time=1, + cost_dsm_down_shift=1, + cost_dsm_up=1, + cost_dsm_down_shed=100, + shed_eligibility=True, + recovery_time_shed=2, + shed_time=2, + n_yearLimit_shed=50, + investment=solph.Investment( + ep_costs=100, + minimum=33, + maximum=100, + lifetime=20, + fixed_costs=20, + overall_maximum=1000, + overall_minimum=5, + ), + ) + + # Create a DSM sink with oemof approach + sinkdsm_oemof = solph.components.experimental.SinkDSM( + label="demand_dsm_oemof", + inputs={bel: solph.flows.Flow()}, + demand=[1] * len(timeindex), + capacity_up=[0.5] * len(timeindex), + capacity_down=[0.5] * len(timeindex), + approach="oemof", + max_demand=[1] * len(timeindex), + shift_interval=2, + cost_dsm_down_shift=1, + cost_dsm_up=1, + cost_dsm_down_shed=100, + shed_eligibility=True, + recovery_time_shed=2, + shed_time=2, + investment=solph.Investment( + ep_costs=100, + existing=50, + minimum=33, + maximum=100, + age=1, + lifetime=20, + fixed_costs=20, + overall_maximum=1000, + overall_minimum=5, + ), + ) + + # Add components to the energy system + es.add(bel, storage, sinkdsm_diw, sinkdsm_dlr, sinkdsm_oemof) + + # Create an optimization problem + om = solph.Model(es) + + # Compare the lp files + self.compare_lp_files("multi_period_period_length.lp", my_om=om)