def test_delay_param_load():
"""Test that the `.load` method of `FlowDelayParameter` works correctly"""
model = Model()
model.timestepper.start = "2015/01/01"
model.timestepper.end = "2015/01/31"
catchment = Catchment(model, name="input", flow=1)
output = Output(model, name="output")
catchment.connect(output)
data = {"name": "delay", "node": "input", "days": 2}
param = FlowDelayParameter.load(model, data)
assert param.days == 2
data = {"name": "delay2", "node": "input", "timesteps": 2}
param2 = FlowDelayParameter.load(model, data)
assert param2.timesteps == 2
expected = np.concatenate([np.zeros(2), np.ones(29)]).reshape(31, 1)
AssertionRecorder(model, param, name="rec1", expected_data=expected)
AssertionRecorder(model, param2, name="rec2", expected_data=expected)
model.setup()
model.run()
def test_threshold_parameter(simple_linear_model):
model = simple_linear_model
model.timestepper.delta = 150
scenario = Scenario(model, "Scenario", size=2)
class DummyRecorder(Recorder):
def __init__(self, model, value, *args, **kwargs):
super(DummyRecorder, self).__init__(model, *args, **kwargs)
self.val = value
def setup(self):
super(DummyRecorder, self).setup()
num_comb = len(model.scenarios.combinations)
self.data = np.empty([len(model.timestepper), num_comb],
dtype=np.float64)
def after(self):
timestep = model.timestepper.current
self.data[timestep.index, :] = self.val
threshold = 10.0
values = [50.0, 60.0]
rec1 = DummyRecorder(model, threshold - 5, name="rec1") # below
rec2 = DummyRecorder(model, threshold, name="rec2") # equal
rec3 = DummyRecorder(model, threshold + 5, name="rec3") # above
expected = [
("LT", (1, 0, 0)),
("GT", (0, 0, 1)),
("EQ", (0, 1, 0)),
("LE", (1, 1, 0)),
("GE", (0, 1, 1)),
]
for predicate, (value_lt, value_eq, value_gt) in expected:
for rec in (rec1, rec2, rec3):
param = RecorderThresholdParameter(model,
rec,
threshold,
values=values,
predicate=predicate)
e_val = values[getattr(rec.val, "__{}__".format(
predicate.lower()))(threshold)]
e = np.ones([
len(model.timestepper),
len(model.scenarios.get_combinations())
]) * e_val
e[0, :] = values[1] # first timestep is always "on"
r = AssertionRecorder(model, param, expected_data=e)
r.name = "assert {} {} {}".format(rec.val, predicate, threshold)
model.run()
def test_agg_anyall(self, simple_linear_model):
"""Test the "any" and "all" aggregation functions"""
model = simple_linear_model
model.timestepper.delta = 1
model.timestepper.start = "2017-01-01"
model.timestepper.end = "2017-01-03"
scenarioA = Scenario(model, "Scenario A", size=2)
scenarioB = Scenario(model, "Scenario B", size=5)
num_comb = len(model.scenarios.get_combinations())
parameters = {
0: DummyIndexParameter(model, 0, name="p0"),
1: DummyIndexParameter(model, 1, name="p1"),
2: DummyIndexParameter(model, 2, name="p2"),
}
data = [(0, 0), (1, 0), (0, 1), (1, 1), (1, 1, 1), (0, 2)]
data_parameters = [[parameters[i] for i in d] for d in data]
expected = [(np.any(d), np.all(d)) for d in data]
for n, params in enumerate(data_parameters):
for m, agg_func in enumerate(["any", "all"]):
p = AggregatedIndexParameter(model, params, agg_func=agg_func)
e = np.ones([len(model.timestepper), num_comb
]) * expected[n][m]
r = AssertionRecorder(model,
p,
expected_data=e,
name="assertion {}-{}".format(
n, agg_func))
model.run()
def test_node_threshold_parameter2(self, simple_linear_model):
model = simple_linear_model
model.nodes["Input"].max_flow = ArrayIndexedParameter(
model, np.arange(0, 20))
model.nodes["Output"].cost = -10.0
model.timestepper.start = "1920-01-01"
model.timestepper.end = "1920-01-15"
model.timestepper.delta = 1
threshold = 5.0
parameters = {}
for predicate in (">", "<", "="):
data = {
"type": "nodethreshold",
"node": "Output",
"threshold": 5.0,
"predicate": predicate,
# we need to define values so AssertionRecorder can be used
"values": [0.0, 1.0],
}
parameter = load_parameter(model, data)
parameter.name = "nodethresold {}".format(predicate)
parameters[predicate] = parameter
if predicate == ">":
expected_data = (np.arange(-1, 20) > threshold).astype(int)
elif predicate == "<":
expected_data = (np.arange(-1, 20) < threshold).astype(int)
else:
expected_data = (np.arange(-1, 20) == threshold).astype(int)
expected_data[
0] = 0 # previous flow in initial timestep is undefined
expected_data = expected_data[:, np.newaxis]
rec = AssertionRecorder(
model,
parameter,
expected_data=expected_data,
name="assertion recorder {}".format(predicate))
model.run()
