def test_basic_functionality():
times = range(1, 4)
consumption = lambda t: t * 1.5
V0 = 10
p = Producer(name='Producer')
c = Consumer(consumption, name='Consumer')
s = Storage(RESOURCE, capacity=15, name='Storage')
s.volume(0).value = V0
rn = FlowNetwork(RESOURCE)
rn.connect(p, s)
rn.connect(s, c)
prob = Problem()
prob.add_constraints(chain(*(rn.constraints(t) for t in times)))
prob.objective = Minimize(sum(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t in times:
c.activity(t).take_value(solution)
p.activity(t).take_value(solution)
s.volume(t).take_value(solution)
for t in times:
assert approx(p.activity(t).value, 0)
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
assert approx(
s.volume(t).value,
s.volume(t - 1).value + s.accumulation[RESOURCE](t - 1).value)
def test_basic_functionality():
times = range(1,4)
consumption = lambda t: t * 1.5
V0 = 10
p = Producer(name='Producer')
c = Consumer(consumption, name='Consumer')
s = Storage(RESOURCE, capacity=15, name='Storage')
s.volume(0).value = V0
rn = FlowNetwork(RESOURCE)
rn.connect(p, s)
rn.connect(s, c)
prob = Problem()
prob.add_constraints(chain(*(rn.constraints(t) for t in times)))
prob.objective = Minimize(sum(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t in times:
c.activity(t).take_value(solution)
p.activity(t).take_value(solution)
s.volume(t).take_value(solution)
for t in times:
assert approx(p.activity(t).value, 0)
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
assert approx(s.volume(t).value, s.volume(t-1).value + s.accumulation[RESOURCE](t-1).value)
def test_load_and_run():
run_and_save()
with open(FILENAME, 'rb') as f:
p, c, cl = dill.load(f)
os.remove(FILENAME)
run_model(p, c, cl, TIMES_2)
for t in TIMES_1 + TIMES_2:
assert approx(p.production[RESOURCE](t).value, consumption(t))
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
def test_simple_pwa_2():
points = {1: 3, 1.5: 2, 2: 4}
x, y, constraints = fs.piecewise_affine(points, name='aoeu')
prob = fs.Problem()
prob.objective = fs.Maximize(y)
prob.add(constraints)
solution = default_solver.solve(prob)
print(solution)
for var in x.variables:
var.take_value(solution)
assert(approx(x.value, 2))
assert(approx(y.value, 4))
def test_simple_pwa_1():
x_vals = (1, 1.5, 2)
y_vals = [3, 2, 4]
x, y, constraints = fs.piecewise_affine(zip(x_vals, y_vals), name='aoeu')
prob = fs.Problem()
prob.objective = fs.Minimize(y)
prob.add(constraints)
solution = default_solver.solve(prob)
print(solution)
for var in x.variables:
var.take_value(solution)
assert(approx(x.value, 1.5))
assert(approx(y.value, 2))
def test_simple_pwa():
pwa = fs.PiecewiseAffine((1, 1.5, 2), name='aoeu')
prob = fs.Problem()
prob.objective = fs.Minimize(pwa.func([3, 2, 4]))
solution = default_solver.solve(prob)
print(solution)
for var in pwa.variables:
var.take_value(solution)
assert(approx(pwa.arg.value, 1.5))
def test_simple_pwa():
pwa = fs.PiecewiseAffine((1, 1.5, 2), name='aoeu')
prob = fs.Problem()
prob.objective = fs.Minimize(pwa.func([3, 2, 4]))
solution = default_solver.solve(prob)
print(solution)
for var in pwa.variables:
var.take_value(solution)
assert (approx(pwa.arg.value, 1.5))
def check_variant(variant):
times = list(range(5))
consumption = lambda t: t * 1.5
p = Producer(name='Producer')
c = Consumer(consumption, variant)
cl = Cluster(p, c, resource=RESOURCE, name='Cluster')
prob = fs.Problem()
prob.add_constraints(chain(*(cl.constraints(t) for t in times)))
prob.objective = fs.Minimize(sum(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t in times:
c.activity(t).take_value(solution)
p.activity(t).take_value(solution)
for t in times:
assert approx(p.production[RESOURCE](t).value, consumption(t))
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
def check_variant(variant, sum_func=sum):
times = list(range(5))
consumption = lambda t: t * 1.5
p = Producer(name='Producer')
c = Consumer(consumption, variant)
cl = Cluster(p, c, resource=RESOURCE, name='Cluster')
prob = fs.Problem()
prob += (part.constraints.make(t) for part, t in product(cl.descendants_and_self, times))
prob.objective = fs.Minimize(sum_func(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t in times:
c.activity(t).take_value(solution)
p.activity(t).take_value(solution)
for t in times:
assert approx(p.production[RESOURCE](t).value, consumption(t))
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
def check_variant(variant):
times = list(range(5))
consumption = lambda t: t * 1.5
p = Producer(name='Producer')
c = Consumer(consumption, variant)
cl = Cluster(p, c, resource=RESOURCE, name='Cluster')
prob = fs.Problem()
prob.add_constraints(chain(*(cl.constraints(t) for t in times)))
prob.objective = fs.Minimize(sum(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t in times:
c.activity(t).take_value(solution)
p.activity(t).take_value(solution)
for t in times:
assert approx(p.production[RESOURCE](t).value, consumption(t))
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
def test_state_vars():
times = list(range(1, 4))
consumption = lambda t: t * 1.5
p = Producer(name='Producer')
c = Consumer(consumption, name='Consumer')
cl = Cluster(p, c, resource=RESOURCE, name='Cluster')
prob = fs.Problem()
prob.add_constraints(chain(*(cl.constraints(t) for t in times)))
prob.objective = fs.Minimize(sum(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t, part in product(times, cl.parts()):
for v in part.state_variables(t):
v.take_value(solution)
for t in times:
assert approx(p.production[RESOURCE](t).value, consumption(t))
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
def test_state_vars():
times = list(range(1,4))
consumption = lambda t: t * 1.5
p = Producer(name='Producer')
c = Consumer(consumption, name='Consumer')
cl = Cluster(p, c, resource=RESOURCE, name='Cluster')
prob = fs.Problem()
prob.add_constraints(chain(*(cl.constraints(t) for t in times)))
prob.objective = fs.Minimize(sum(p.cost(t) for t in times))
solution = default_solver.solve(prob)
for t, part in product(times, cl.parts()):
for v in part.state_variables(t):
v.take_value(solution)
for t in times:
assert approx(p.production[RESOURCE](t).value, consumption(t))
assert approx(c.consumption[RESOURCE](t).value, consumption(t))
def test_simple_SOS1():
n = 4
index = 2
sum_val = 3.
vs = [fs.Variable(lb=-1, domain=fs.Domain.integer) for i in range(n)]
#vs[0] = fs.Variable(lb=-1, domain=fs.Domain.integer)
weights = [1 for i in range(n)]
weights[index] = 0.5
prob = fs.Problem()
prob.add_constraint(fs.SOS1(vs))
prob.add_constraint(Constraint(sum(vs) == sum_val))
#prob.constraints.update(Constraint(v >= 0) for v in vs)
prob.objective = fs.Minimize(sum(v * w for v, w in zip(vs, weights)))
solution = default_solver.solve(prob)
print(solution)
for v in vs:
v.take_value(solution)
for i in range(n):
if i == index:
assert(approx(vs[i].value, sum_val))
else:
assert(approx(vs[i].value, 0))
def test_simple_SOS1():
n = 4
index = 2
sum_val = 3.
vs = [fs.Variable(lb=-1, domain=fs.Domain.integer) for i in range(n)]
#vs[0] = fs.Variable(lb=-1, domain=fs.Domain.integer)
weights = [1 for i in range(n)]
weights[index] = 0.5
prob = fs.Problem()
prob.add_constraint(fs.SOS1(vs))
prob.add_constraint(Constraint(sum(vs) == sum_val))
#prob.constraints.update(Constraint(v >= 0) for v in vs)
prob.objective = fs.Minimize(sum(v * w for v, w in zip(vs, weights)))
solution = default_solver.solve(prob)
print(solution)
for v in vs:
v.take_value(solution)
for i in range(n):
if i == index:
assert (approx(vs[i].value, sum_val))
else:
assert (approx(vs[i].value, 0))
def test_series_simple():
consumption = lambda t: t * 1.5
p = Producer(name='Producer')
c = Consumer(consumption, name='Consumer')
cl = Cluster(p, c, resource=RESOURCE, name='Cluster')
t0 = 0
step = 3
m = fs.models.MyopicDispatchModel(t0=t0, step=step, horizon=7)
m.require_cost = lambda part: part is not cl
m.add_part(cl)
m.solver = default_solver
m.advance()
m.advance()
times = m.times(t0, step * 2)
prod = fs.get_series(p.production[RESOURCE], times)
cons = fs.get_series(c.consumption[RESOURCE], times)
for t in times:
assert prod[t] == float(p.production[RESOURCE](t))
assert cons[t] == float(c.consumption[RESOURCE](t))
assert approx(prod[t], cons[t])
assert ((prod-cons).abs() <= 1e-6).all()
