Skip to content
Snippets Groups Projects
Commit 020cff8f authored by Christoph von Oy's avatar Christoph von Oy
Browse files

Removed old Architecture

parent 0edf03c2
Branches
No related tags found
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
component/adapter.py
+ 2
− 3
View file @ 020cff8f
...@@ -30,7 +30,6 @@ from Model_Library.component.core import ( ...@@ -30,7 +30,6 @@ from Model_Library.component.core import (
ComponentLink, ComponentLink,
ComponentPart, ComponentPart,
) )
from Model_Library.dynamics import resample_variable
from Model_Library.optimization_model import VariableKind from Model_Library.optimization_model import VariableKind
import pyomo.environ as pyo import pyomo.environ as pyo
...@@ -165,13 +164,13 @@ class MemberAdapter(AbstractComponent): ...@@ -165,13 +164,13 @@ class MemberAdapter(AbstractComponent):
self.member, self.member,
self.grid.name + ".output_1", self.grid.name + ".output_1",
"into_member", "into_member",
(self.name, ComponentPart.NONE_STATE) (self.name, ComponentPart.NONE_STATE),
) )
yield MemberLink( yield MemberLink(
self.member, self.member,
self.grid.name + ".input_1", self.grid.name + ".input_1",
"from_member", "from_member",
(self.name, ComponentPart.NONE_STATE) (self.name, ComponentPart.NONE_STATE),
) )
def non_state_base_variable_names(self): def non_state_base_variable_names(self):
......
dynamics.py
+ 4
− 518
View file @ 020cff8f
This diff is collapsed.
topology.py
+ 11
− 359
View file @ 020cff8f
...@@ -38,7 +38,6 @@ from Model_Library.component.core import ( ...@@ -38,7 +38,6 @@ from Model_Library.component.core import (
VariableLink, VariableLink,
) )
from Model_Library.component.adapter import AssetLink, MemberLink from Model_Library.component.adapter import AssetLink, MemberLink
from Model_Library.dynamics import PeriodAggregation, TrivialArchitecture
from Model_Library.optimization_model import ( from Model_Library.optimization_model import (
EntityResult, EntityResult,
OptimizationBlock, OptimizationBlock,
...@@ -284,7 +283,7 @@ class Topology: ...@@ -284,7 +283,7 @@ class Topology:
for name in sub_configurations for name in sub_configurations
} }
model = self.build_model_new( model = self.build_model(
architecture, architecture,
component_iden_strs, component_iden_strs,
strategy, strategy,
...@@ -301,23 +300,23 @@ class Topology: ...@@ -301,23 +300,23 @@ class Topology:
if not model.is_ok(): if not model.is_ok():
raise RuntimeError("Model is infeasible or unbounded!") raise RuntimeError("Model is infeasible or unbounded!")
self.create_empty_entity_result_new( self.create_empty_entity_result(
key, key,
architecture, architecture,
component_iden_strs, component_iden_strs,
_extract_sub_configuration(sub_configurations, [0, 1, 2]), _extract_sub_configuration(sub_configurations, [0, 1, 2]),
) )
self.extract_result_new( self.extract_result(
model, key, _extract_sub_configuration(sub_configurations, [0]) model, key, _extract_sub_configuration(sub_configurations, [0])
) )
def build_model_new( def build_model(
self, architecture, component_ident_strs, strategy, sub_model_configurations self, architecture, component_ident_strs, strategy, sub_model_configurations
): ):
model = OptimizationModel(self._name, architecture.get_dynamic("")) model = OptimizationModel(self._name, architecture.get_dynamic(""))
self._build_model_new( self._build_model(
architecture, architecture,
component_ident_strs, component_ident_strs,
strategy, strategy,
...@@ -330,7 +329,7 @@ class Topology: ...@@ -330,7 +329,7 @@ class Topology:
return model return model
def _build_model_new( def _build_model(
self, self,
architecture, architecture,
input_component_ident_strs, input_component_ident_strs,
...@@ -345,7 +344,7 @@ class Topology: ...@@ -345,7 +344,7 @@ class Topology:
sub_strategy = sub_model_configurations[name][2] sub_strategy = sub_model_configurations[name][2]
sub_sub_model_configutation = sub_model_configurations[name][3] sub_sub_model_configutation = sub_model_configurations[name][3]
sub_block = block.add_block(name, sub_architecture.get_dynamic("")) sub_block = block.add_block(name, sub_architecture.get_dynamic(""))
asset._build_model_new( asset._build_model(
sub_architecture, sub_architecture,
sub_component_ident_strs, sub_component_ident_strs,
sub_strategy, sub_strategy,
...@@ -895,270 +894,7 @@ class Topology: ...@@ -895,270 +894,7 @@ class Topology:
return objective_exprs return objective_exprs
def build_model(self, architecture, strategy): def create_empty_entity_result(
model = OptimizationModel(self._name, architecture.model_dynamic())
self.fill_block(model, architecture, strategy)
model.collect_objectives()
return model
def fill_block(self, block, architecture, strategy):
for asset in self._assets.values():
asset_block = OptimizationBlock(asset._name, architecture.model_dynamic())
block.add(asset._name, asset_block)
asset.fill_block(asset_block, architecture, strategy)
if strategy is None:
objectives = {"objective": []}
elif isinstance(strategy, list):
objectives = {"objective": strategy}
elif isinstance(strategy, dict):
objectives = strategy
else:
raise ValueError(f"Invalid strategy type!")
if isinstance(architecture, TrivialArchitecture):
design_objectives = self.fill_design_block(block, objectives)
operational_objectives = self.fill_operational_blocks(
block, block, block, objectives
)
w = (365.0 * 24.0) / (np.sum(block.dynamic.step_lengths()) / 3600.0)
for name in objectives:
scaled_expression, one_time_expression = operational_objectives[name]
objective = (
design_objectives[name]
+ w
* (
pyo.quicksum(term for term in block.general_scaled_expression)
+ scaled_expression
)
+ one_time_expression
)
block.add_objective(name, objective)
elif isinstance(architecture, PeriodAggregation):
design_objectives = self.fill_design_block(block, objectives)
period_blocks = []
operational_objectives = []
for period_index, period_dynamic in enumerate(architecture.period_dynamics):
period_block = OptimizationBlock(str(period_index), period_dynamic)
block.add(str(period_index), period_block)
period_blocks.append(period_block)
operational_objectives.append(
self.fill_operational_blocks(
block, period_block, period_block, objectives
)
)
w = (365.0 * 24.0) / (np.sum(block.dynamic.step_lengths()) / 3600.0)
for name in objectives:
scaled_expression = 0.0
one_time_expression = 0.0
for period_index in range(architecture.number_of_periods()):
(
period_scaled_expression,
period_one_time_expression,
) = operational_objectives[period_index][name]
scaled_expression += architecture.n_p[period_index] * (
period_scaled_expression
+ pyo.quicksum(
term
for term in period_blocks[
period_index
].general_scaled_expression
)
)
one_time_expression += (
architecture.n_p[period_index] * period_one_time_expression
)
objective = design_objectives[name] + w * (
scaled_expression + (1.0 / architecture.n) * one_time_expression
)
block.add_objective(name, objective)
else:
raise ValueError(f"Invalid architecture type {type(architecture)}")
def fill_design_block(self, d_block, objectives):
for component in self._components:
self._components[component].add_design_variables(d_block)
for logic_name, logic in self._additional_model_logic.items():
if logic["type"] == "EqualCapacity":
components = logic["components"]
for i in range(len(components) - 1):
def rule(m):
return (
d_block.component_dict[components[i] + ".capacity"]
== d_block.component_dict[components[i + 1] + ".capacity"]
)
d_block.add(
logic_name + "_cons_" + str(i), pyo.Constraint(rule=rule)
)
design_objectives = dict()
for name, objective in objectives.items():
expression = 0.0
if "annuity" in objective:
annuity = 0.0
for component in self._components.values():
annuity += component.design_annuity(
d_block,
self._planning_horizon,
self._price_change_factor,
self._interest_factor,
)
expression += annuity
design_objectives[name] = expression
return design_objectives
def fill_operational_blocks(self, d_block, o_block, s_block, objectives):
for component in self._components:
self._components[component].add_non_state_variables(o_block)
self._components[component].add_state_variables(s_block)
self._components[component].add_non_state_model(d_block, o_block)
self._components[component].add_state_model(d_block, o_block, s_block)
self._components[component].add_additional_model_logic(d_block, o_block)
for connector in self._connectors.values():
for flow in connector.flows:
o_block.add(flow, pyo.Var(o_block.T, bounds=(0, None)))
connector_var = o_block.component_dict[connector.name]
def rule(m, t):
return connector_var[t] == pyo.quicksum(
o_block.component_dict[flow][t] for flow in connector.flows
)
o_block.add(connector.name + "_sum", pyo.Constraint(o_block.T, rule=rule))
for i, connection in enumerate(self._connections):
def rule(m, t):
return pyo.quicksum(
o_block.component_dict[out_flow][t]
for out_flow in connection.out_flows
) == pyo.quicksum(
o_block.component_dict[in_flow][t]
for in_flow in connection.in_flows
) * (
1.0 - connection.loss_factor
)
o_block.add(str(i) + "_sum", pyo.Constraint(o_block.T, rule=rule))
if connection.capacity is not None:
capacity = connection.capacity
def rule(m, t):
return (
pyo.quicksum(
o_block.component_dict[in_flow][t]
for in_flow in connection.in_flows
)
<= capacity
)
o_block.add(str(i) + "_capacity", pyo.Constraint(o_block.T, rule=rule))
for logic_name, logic in self._additional_model_logic.items():
if logic["type"] == "ConnectorEnable":
enable = logic["enable"].resample(o_block.dynamic).values
for i, connector in enumerate(logic["connectors"]):
connector_var = o_block.component_dict[connector]
def rule(m, t):
if not enable[t]:
return connector_var[t] == 0
else:
return pyo.Constraint.Skip
o_block.add(
logic_name + "_cons_" + str(i),
pyo.Constraint(o_block.T, rule=rule),
)
if logic["type"] == "ConnectionEnable":
enable = logic["enable"].resample(o_block.dynamic).values
for i, connection in enumerate(logic["connections"]):
flow_from = connection["from"]
flow_to = connection["to"]
if (flow_from, flow_to) in self._connections_map:
connection = self._connections[
self._connections_map[flow_from, flow_to]
]
# if flow in self._removed_flows:
# flow = self._removed_flows[flow]
flow_var = o_block.component_dict[connection.in_flows[0]]
def rule(m, t):
if not enable[t]:
return flow_var[t] == 0
else:
return pyo.Constraint.Skip
o_block.add(
logic_name + "_cons_" + str(i),
pyo.Constraint(o_block.T, rule=rule),
)
operational_objectives = dict()
for name, objective in objectives.items():
scaled_expression = 0.0
one_time_expression = 0.0
if "annuity" in objective:
annuity = 0.0
for component in self._components.values():
annuity += component.operational_annuity(
o_block,
self._planning_horizon,
self._price_change_factor,
self._interest_factor,
)
scaled_expression += annuity
if "peak_power_cost" in objective:
peak_power_cost = 0.0
for component in self._components.values():
peak_power_cost += component.peak_power_cost(o_block)
T = self._planning_horizon
r = self._price_change_factor
q = self._interest_factor
if q == 1.0:
a = 1.0 / T
else:
a = (q - 1.0) / (1.0 - q ** (-T))
if q == r:
b = T / q
else:
b = (1.0 - (r / q) ** T) / (q - r)
one_time_expression += peak_power_cost * a * b
if "co2_emissions" in objective:
co2_emissions = 0.0
for component in self._components.values():
co2_emissions += component.co2_emissions(o_block)
scaled_expression += co2_emissions
operational_objectives[name] = (scaled_expression, one_time_expression)
return operational_objectives
def create_empty_entity_result_new(
self, key, architecture, input_component_ident_strs, sub_result_configurations self, key, architecture, input_component_ident_strs, sub_result_configurations
): ):
for name, asset in self._assets.items(): for name, asset in self._assets.items():
...@@ -1166,7 +902,7 @@ class Topology: ...@@ -1166,7 +902,7 @@ class Topology:
sub_architecture = sub_result_configurations[name][1] sub_architecture = sub_result_configurations[name][1]
sub_component_ident_strs = sub_result_configurations[name][2] sub_component_ident_strs = sub_result_configurations[name][2]
sub_sub_result_configurations = sub_result_configurations[name][3] sub_sub_result_configurations = sub_result_configurations[name][3]
asset.create_empty_entity_result_new( asset.create_empty_entity_result(
sub_key, sub_key,
sub_architecture, sub_architecture,
sub_component_ident_strs, sub_component_ident_strs,
...@@ -1264,74 +1000,11 @@ class Topology: ...@@ -1264,74 +1000,11 @@ class Topology:
for dist, _ in dists.values(): for dist, _ in dists.values():
dist.up() dist.up()
def create_empty_entity_result(self, key, architecture): def extract_result(self, model, key, sub_keys):
for asset in self._assets.values():
asset.create_empty_entity_result(key, architecture)
if isinstance(architecture, TrivialArchitecture):
base_variable_names = []
for component in self._components:
base_variable_names.extend(
self._components[component].design_base_variable_names()
)
base_variable_names.extend(
self._components[component].non_state_base_variable_names()
)
base_variable_names.extend(
self._components[component].state_base_variable_names()
)
for connector in self._connectors.values():
for flow in connector.flows:
base_variable_names.append((flow, VariableKind.INDEXED))
result = EntityResult(architecture)
result.register_dynamic(architecture.dynamic, "", base_variable_names)
elif isinstance(architecture, PeriodAggregation):
design_base_variable_names = []
for component in self._components:
design_base_variable_names.extend(
self._components[component].design_base_variable_names()
)
result = EntityResult(architecture)
result.register_dynamic(
architecture.dynamic, "", design_base_variable_names
)
operational_base_variable_names = []
for component in self._components:
operational_base_variable_names.extend(
self._components[component].non_state_base_variable_names()
)
operational_base_variable_names.extend(
self._components[component].state_base_variable_names()
)
for connector in self._connectors.values():
for flow in connector.flows:
operational_base_variable_names.append((flow, VariableKind.INDEXED))
result.register_dynamic(
architecture.value_dynamic,
"aggregated",
operational_base_variable_names,
)
else:
raise ValueError(f"Invalid architecture type {type(architecture)}")
result.compile()
self._results[key] = result
self._last_result_key = key
def extract_result_new(self, model, key, sub_keys):
for name, asset in self._assets.items(): for name, asset in self._assets.items():
sub_key = sub_keys[name][0] sub_key = sub_keys[name][0]
sub_sub_keys = sub_keys[name][1] sub_sub_keys = sub_keys[name][1]
asset.extract_result_new(model, sub_key, sub_sub_keys) asset.extract_result(model, sub_key, sub_sub_keys)
result = self._results[key] result = self._results[key]
...@@ -1342,27 +1015,6 @@ class Topology: ...@@ -1342,27 +1015,6 @@ class Topology:
model.all_blocks[block_prefix + local_block_prefix] model.all_blocks[block_prefix + local_block_prefix]
) )
def extract_result(self, block, key):
for asset in self._assets.values():
asset_block = block.blocks[asset._name]
asset.extract_result(asset_block, key)
result = self._results[key]
if isinstance(result.architecture, TrivialArchitecture):
result.extract_result(block, result.architecture.dynamic)
elif isinstance(result.architecture, PeriodAggregation):
result.extract_result(block, result.architecture.dynamic)
for period_index in range(result.architecture.number_of_periods()):
period_block = block.blocks[str(period_index)]
result.extract_result(period_block, result.architecture.value_dynamic)
else:
raise ValueError(f"Invalid architecture type {type(result.architecture)}")
def save_results(self, path, keys=None): def save_results(self, path, keys=None):
for asset in self._assets.values(): for asset in self._assets.values():
asset.save_results(path, keys) asset.save_results(path, keys)
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment