def sos_model(sector_model, scenario_model, economic_model):
"""SosModel with one scenario and one sector model
"""
model = SosModel('test_sos_model')
model.add_model(scenario_model)
model.add_model(economic_model)
model.add_model(sector_model)
model.add_dependency(scenario_model, 'precipitation', sector_model,
'precipitation')
model.add_dependency(economic_model, 'gva', sector_model, 'rGVA')
return model
def test_nested_graph(self, get_sector_model):
"""If we add a nested model, all Sectormodel and ScenarioModel objects
are added as nodes in the graph with edges along dependencies.
SosModel objects are not included, as they are just containers for the
SectorModel and ScenarioModel objects, passing up inputs for deferred
linkages to dependencies.
Not implemented yet:
"""
SectorModel = get_sector_model
energy_model = SectorModel('energy_sector_model')
input_metadata = {
'name': 'electricity_demand_input',
'spatial_resolution': Mock(),
'temporal_resolution': Mock(),
'units': 'unit'
}
energy_model._model_inputs = MetadataSet([input_metadata])
sos_model_lo = SosModel('lower')
sos_model_lo.add_model(energy_model)
sos_model_high = SosModel('higher')
sos_model_high.add_model(sos_model_lo)
with raises(NotImplementedError):
sos_model_high.check_dependencies()
graph = sos_model_high.dependency_graph
assert graph.edges() == []
expected = networkx.DiGraph()
expected.add_node(sos_model_lo)
expected.add_node(energy_model)
assert energy_model in graph.nodes()
scenario = ScenarioModel('electricity_demand')
scenario.add_output('elec_demand_output', Mock(), Mock(), 'kWh')
sos_model_high.add_dependency(scenario, 'elec_demand_output',
'electricity_demand_input')
sos_model_high.check_dependencies()
assert graph.edges() == [(scenario, sos_model_high)]
def test_add_dependency(self, empty_sector_model):
"""Add models, connect via dependency
"""
spec = Spec(name='hourly_value',
dims=['hours'],
coords={'hours': range(24)},
dtype='int')
sink_model = copy(empty_sector_model)
sink_model.add_input(spec)
source_model = copy(empty_sector_model)
source_model.add_output(spec)
sos_model = SosModel('test')
sos_model.add_model(source_model)
sos_model.add_model(sink_model)
sos_model.add_dependency(source_model, 'hourly_value', sink_model,
'hourly_value')
def test_composite_nested_sos_model(self, get_sector_model):
"""System of systems example with two nested SosModels, two Scenarios
and one SectorModel. One dependency is defined at the SectorModel
level, another at the lower SosModel level
"""
SectorModel = get_sector_model
elec_scenario = ScenarioModel('electricity_demand_scenario')
elec_scenario.add_output('electricity_demand_output',
Mock(), Mock(), 'unit')
energy_model = SectorModel('energy_sector_model')
energy_model.add_input(
'electricity_demand_input', Mock(), Mock(), 'unit')
energy_model.add_input('fluffiness_input', Mock(), Mock(), 'unit')
energy_model.add_output('cost', Mock(), Mock(), 'unit')
energy_model.add_output('fluffyness', Mock(), Mock(), 'unit')
def energy_function(timestep, input_data):
"""Mimics the running of a sector model
"""
results = {}
demand = input_data['electricity_demand_input']
fluff = input_data['fluffiness_input']
results['cost'] = demand * 1.2894
results['fluffyness'] = fluff * 22
return results
energy_model.simulate = energy_function
energy_model.add_dependency(elec_scenario,
'electricity_demand_output',
'electricity_demand_input')
sos_model_lo = SosModel('lower')
sos_model_lo.add_model(elec_scenario)
sos_model_lo.add_model(energy_model)
fluf_scenario = ScenarioModel('fluffiness_scenario')
fluf_scenario.add_output('fluffiness', Mock(), Mock(), 'unit')
# fluf_scenario.add_data('fluffiness', np.array([[[12]]]), [2010])
assert sos_model_lo.free_inputs.names == ['fluffiness_input']
sos_model_lo.add_dependency(fluf_scenario,
'fluffiness',
'fluffiness_input')
assert sos_model_lo.inputs.names == []
sos_model_high = SosModel('higher')
sos_model_high.add_model(sos_model_lo)
sos_model_high.add_model(fluf_scenario)
data_handle = get_data_handle(sos_model_high)
actual = sos_model_high.simulate(data_handle)
expected = {
'fluffiness_scenario': {
'fluffiness': 12
},
'lower': {
'electricity_demand_scenario': {
'electricity_demand_output': 123
},
'energy_sector_model': {
'cost': 158.5962,
'fluffyness': 264
}
}
}
assert actual == expected