def test_nodes_with_none_exclusion_old_name(self):
param_results = processing.parameter_as_dict(self.es,
exclude_none=True)
param_results = processing.convert_keys_to_strings(param_results,
keep_none_type=True)
assert_series_equal(
param_results[('storage', None)]['scalars'],
pandas.Series({
'balanced': True,
'initial_storage_level': 0,
'invest_relation_input_capacity': 1 / 6,
'invest_relation_output_capacity': 1 / 6,
'investment_ep_costs': 0.4,
'investment_existing': 0,
'investment_maximum': float('inf'),
'investment_minimum': 0,
'investment_nonconvex': False,
'investment_offset': 0,
'label': 'storage',
'fixed_losses_absolute': 0,
'fixed_losses_relative': 0,
'inflow_conversion_factor': 1,
'loss_rate': 0,
'max_storage_level': 1,
'min_storage_level': 0,
'outflow_conversion_factor': 0.8,
}))
assert_frame_equal(param_results[('storage', None)]['sequences'],
pandas.DataFrame())
marginal_cost=0.0001)
energysystem.add(bus_heat, heat_source, shortage, excess, heat_demand,
thermal_storage)
# Create and solve the optimization model
optimization_model = Model(energysystem)
optimization_model.solve(solver=solver,
solve_kwargs={
'tee': False,
'keepfiles': False
})
# Get results
results = processing.results(optimization_model)
string_results = processing.convert_keys_to_strings(results)
sequences = {k: v['sequences'] for k, v in string_results.items()}
df = pd.concat(sequences, axis=1)
# Print storage sizing
built_storage_capacity = results[thermal_storage, None]['scalars']['invest']
initial_storage_capacity = results[thermal_storage,
None]['scalars']['init_content']
maximum_heat_flow_charging = results[bus_heat,
thermal_storage]['scalars']['invest']
dash = '-' * 50
print(dash)
print('{:>32s}{:>15.3f}'.format('Invested capacity [MW]',
maximum_heat_flow_charging))
print('{:>32s}{:>15.3f}'.format('Invested storage capacity [MWh]',
def node(results, node, multiindex=False, keep_none_type=False):
"""
Obtain results for a single node e.g. a Bus or Component.
Either a node or its label string can be passed.
Results are written into a dictionary which is keyed by 'scalars' and
'sequences' holding respective data in a pandas Series and DataFrame.
"""
def replace_none(col_list, reverse=False):
replacement = (
(None, NONE_REPLACEMENT_STR) if reverse else
(NONE_REPLACEMENT_STR, None)
)
changed_col_list = [
(
(
replacement[0] if n1 is replacement[1] else n1,
replacement[0] if n2 is replacement[1] else n2
),
f
)
for (n1, n2), f in col_list
]
return changed_col_list
# convert to keys if only a string is passed
if type(node) is str:
results = convert_keys_to_strings(results, keep_none_type)
filtered = {}
# create a series with tuples as index labels for scalars
scalars = {k: v['scalars'] for k, v in results.items()
if node in k and not v['scalars'].empty}
if scalars:
# aggregate data
filtered['scalars'] = pd.concat(scalars.values(), axis=0)
# assign index values
idx = {k: [c for c in v['scalars'].index]
for k, v in results.items()
if node in k and not v['scalars'].empty}
idx = [tuple((k, m) for m in v) for k, v in idx.items()]
idx = [i for sublist in idx for i in sublist]
filtered['scalars'].index = idx
# Sort index
# (if Nones are present, they have to be replaced while sorting)
if keep_none_type:
filtered['scalars'].index = replace_none(
filtered['scalars'].index.tolist())
filtered['scalars'].sort_index(axis=0, inplace=True)
if keep_none_type:
filtered['scalars'].index = replace_none(
filtered['scalars'].index.tolist(), True)
if multiindex:
idx = pd.MultiIndex.from_tuples(
[tuple([row[0][0], row[0][1], row[1]])
for row in filtered['scalars'].index])
idx.set_names(['from', 'to', 'type'], inplace=True)
filtered['scalars'].index = idx
# create a dataframe with tuples as column labels for sequences
sequences = {k: v['sequences'] for k, v in results.items()
if node in k and not v['sequences'].empty}
if sequences:
# aggregate data
filtered['sequences'] = pd.concat(sequences.values(), axis=1)
# assign column names
cols = {k: [c for c in v['sequences'].columns]
for k, v in results.items()
if node in k and not v['sequences'].empty}
cols = [tuple((k, m) for m in v) for k, v in cols.items()]
cols = [c for sublist in cols for c in sublist]
filtered['sequences'].columns = replace_none(cols)
filtered['sequences'].sort_index(axis=1, inplace=True)
filtered['sequences'].columns = replace_none(
filtered['sequences'].columns, True)
if multiindex:
idx = pd.MultiIndex.from_tuples(
[tuple([col[0][0], col[0][1], col[1]])
for col in filtered['sequences'].columns])
idx.set_names(['from', 'to', 'type'], inplace=True)
filtered['sequences'].columns = idx
return filtered