def test_with_nonstorage_load(self, model):
"""Test load from dict with 'storage_node' key."""
m = model
s = m.nodes["Storage"]
l = Link(m, "Link")
# Connect the link node to the network to create a valid model
o = m.nodes["Output"]
s.connect(l)
l.connect(o)
data = {
"type": "controlcurve",
"control_curve": 0.8,
"values": [10.0, 0.0],
"storage_node": "Storage",
}
l.cost = p = load_parameter(model, data)
assert isinstance(p, ControlCurveParameter)
@assert_rec(m, l.cost)
def expected_func(timestep, scenario_index):
v = s.initial_volume
if v >= 80.0:
expected = 10.0
else:
expected = 0.0
return expected
for initial_volume in (90, 70):
s.initial_volume = initial_volume
m.run()
def test_with_nonstorage(self, model):
"""Test usage on non-`Storage` node."""
# Now test if the parameter is used on a non storage node
m = model
s = m.nodes["Storage"]
l = Link(m, "Link")
# Connect the link node to the network to create a valid model
o = m.nodes["Output"]
s.connect(l)
l.connect(o)
cc = ConstantParameter(model, 0.8)
l.cost = ControlCurveParameter(model, s, cc, [10.0, 0.0])
@assert_rec(m, l.cost)
def expected_func(timestep, scenario_index):
v = s.initial_volume
if v >= 80.0:
expected = 10.0
else:
expected = 0.0
return expected
for initial_volume in (90, 70):
s.initial_volume = initial_volume
m.run()
def create_model():
# create a model
model = Model(start="2016-01-01", end="2019-12-31", timestep=7)
# create three nodes (an input, a link, and an output)
A = Input(model, name="A", max_flow=10.0)
B = Link(model, name="B", cost=1.0)
C = Output(model, name="C", max_flow=5.0, cost=-2.0)
# connect nodes
A.connect(B)
B.connect(C)
return model
def simple_linear_model(request, solver):
"""
Make a simple model with a single Input and Output.
Input -> Link -> Output
"""
model = Model(solver=solver)
inpt = Input(model, name="Input")
lnk = Link(model, name="Link", cost=1.0)
inpt.connect(lnk)
otpt = Output(model, name="Output")
lnk.connect(otpt)
return model
def create_model(harmonic=True):
# import flow timeseries for catchments
flow = pd.read_csv(os.path.join('data', 'thames_stochastic_flow.gz'))
flow['Date'] = flow['Date'].apply(pd.to_datetime)
flow.set_index('Date', inplace=True)
# resample input to weekly average
flow = flow.resample('7D', how='mean')
model = InspyredOptimisationModel(
solver='glpk',
start=flow.index[0],
end=flow.index[365*10], # roughly 10 years
timestep=datetime.timedelta(7), # weekly time-step
)
flow_parameter = ArrayIndexedParameter(model, flow['flow'].values)
catchment1 = Input(model, 'catchment1', min_flow=flow_parameter, max_flow=flow_parameter)
catchment2 = Input(model, 'catchment2', min_flow=flow_parameter, max_flow=flow_parameter)
reservoir1 = Storage(model, 'reservoir1', min_volume=3000, max_volume=20000, initial_volume=16000)
reservoir2 = Storage(model, 'reservoir2', min_volume=3000, max_volume=20000, initial_volume=16000)
if harmonic:
control_curve = AnnualHarmonicSeriesParameter(model, 0.5, [0.5], [0.0], mean_upper_bounds=1.0, amplitude_upper_bounds=1.0)
else:
control_curve = MonthlyProfileParameter(model, np.array([0.0]*12), lower_bounds=0.0, upper_bounds=1.0)
control_curve.is_variable = True
controller = ControlCurveParameter(model, reservoir1, control_curve, [0.0, 10.0])
transfer = Link(model, 'transfer', max_flow=controller, cost=-500)
demand1 = Output(model, 'demand1', max_flow=45.0, cost=-101)
demand2 = Output(model, 'demand2', max_flow=20.0, cost=-100)
river1 = Link(model, 'river1')
river2 = Link(model, 'river2')
# compensation flows from reservoirs
compensation1 = Link(model, 'compensation1', max_flow=5.0, cost=-9999)
compensation2 = Link(model, 'compensation2', max_flow=5.0, cost=-9998)
terminator = Output(model, 'terminator', cost=1.0)
catchment1.connect(reservoir1)
catchment2.connect(reservoir2)
reservoir1.connect(demand1)
reservoir2.connect(demand2)
reservoir2.connect(transfer)
transfer.connect(reservoir1)
reservoir1.connect(river1)
reservoir2.connect(river2)
river1.connect(terminator)
river2.connect(terminator)
reservoir1.connect(compensation1)
reservoir2.connect(compensation2)
compensation1.connect(terminator)
compensation2.connect(terminator)
r1 = TotalDeficitNodeRecorder(model, demand1)
r2 = TotalDeficitNodeRecorder(model, demand2)
r3 = AggregatedRecorder(model, [r1, r2], agg_func="mean")
r3.is_objective = 'minimise'
r4 = TotalFlowNodeRecorder(model, transfer)
r4.is_objective = 'minimise'
return model