def Xtest_rangeset_domain(self):
self.model = ConcreteModel()
self.model.s = RangeSet(3) #Set(initialize=[1,2,3])
self.model.y = Var([1, 2], within=self.model.s)
self.model.obj = Objective(expr=self.model.y[1] - self.model.y[2])
self.model.con1 = Constraint(expr=self.model.y[1] >= 1.1)
self.model.con2 = Constraint(expr=self.model.y[2] <= 2.9)
self.instance = self.model.create_instance()
self.opt = SolverFactory("glpk")
self.results = self.opt.solve(self.instance)
self.instance.load(self.results)
self.assertEqual(self.instance.y[1], 2)
self.assertEqual(self.instance.y[2], 2)
def test_rule5(self):
"""Test rule option"""
model = ConcreteModel()
model.B = RangeSet(1, 4)
def f(model):
ans = 0
for i in model.B:
ans = ans + model.x[i]
return (ans, 1)
model.x = Var(model.B, initialize=2)
model.c = Constraint(rule=f)
self.assertEqual(model.c(), 8)
self.assertEqual(value(model.c.body), 8)
def test_determine_valid_values(self):
m = ConcreteModel()
m.x = Var()
m.y = Var(RangeSet(4), domain=Binary)
m.z = Var(domain=Integers, bounds=(-1, 2))
m.constr = Constraint(expr=m.x == m.y[1] + 2 * m.y[2] + m.y[3] +
2 * m.y[4] + m.z)
m.logical = ConstraintList()
m.logical.add(expr=m.y[1] + m.y[2] == 1)
m.logical.add(expr=m.y[3] + m.y[4] == 1)
m.logical.add(expr=m.y[2] + m.y[4] <= 1)
var_to_values_map = determine_valid_values(
m, detect_effectively_discrete_vars(m, 1E-6),
Bunch(equality_tolerance=1E-6, pruning_solver='glpk'))
valid_values = set([1, 2, 3, 4, 5])
self.assertEqual(set(var_to_values_map[m.x]), valid_values)
def test_len(self):
"""Test len method"""
model = self.create_model()
model.obj = Objective(model.A,model.A)
self.assertEqual(len(model.obj),0)
model = self.create_model()
"""Test rule option"""
def f(model):
ans=0
for i in model.x.keys():
ans = ans + model.x[i]
return ans
model.x = Var(RangeSet(1,4),initialize=2)
model.obj = Objective(rule=f)
self.assertEqual(len(model.obj),1)
def test_rule_option1(self):
model = self.create_model()
model.B = RangeSet(1,4)
def f(model, i):
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
ans = ans <= 0
ans = ans >= 0
return ans
model.x = Var(model.B, initialize=2)
model.c = Constraint(model.A,rule=f)
self.assertEqual(model.c[1](), 8)
self.assertEqual(model.c[2](), 16)
self.assertEqual(len(model.c), 4)
def setUp(self):
m = ConcreteModel()
m.mycomp = Var()
m.MyComp = Var()
m.that = Var()
self.long1 = m.myverylongcomponentname = Var()
self.long2 = m.myverylongcomponentnamerighthere = Var()
self.long3 = m.anotherlongonebutdifferent = Var()
self.long4 = m.anotherlongonebutdifferentlongcomponentname = Var()
self.long5 = m.longcomponentname_1_ = Var()
m.s = RangeSet(10)
m.ind = Var(m.s)
m.myblock = Block()
m.myblock.mystreet = Constraint()
m.add_component("myblock.mystreet", Var())
self.thecopy = m.__getattribute__("myblock.mystreet")
self.m = m
def test_assert_units_consistent_all_components(self):
# test all scalar components consistent
u = units
m = self._create_model_and_vars()
m.obj = Objective(expr=m.dx / m.t - m.vx)
m.con = Constraint(expr=m.dx / m.t == m.vx)
# vars already added
m.exp = Expression(expr=m.dx / m.t - m.vx)
m.suff = Suffix(direction=Suffix.LOCAL)
# params already added
# sets already added
m.rs = RangeSet(5)
m.disj1 = Disjunct()
m.disj1.constraint = Constraint(expr=m.dx / m.t <= m.vx)
m.disj2 = Disjunct()
m.disj2.constraint = Constraint(expr=m.dx / m.t <= m.vx)
m.disjn = Disjunction(expr=[m.disj1, m.disj2])
# block tested as part of model
m.extfn = ExternalFunction(python_callback_function,
units=u.m / u.s,
arg_units=[u.m, u.s])
m.conext = Constraint(expr=m.extfn(m.dx, m.t) - m.vx == 0)
m.cset = ContinuousSet(bounds=(0, 1))
m.svar = Var(m.cset, units=u.m)
m.dvar = DerivativeVar(sVar=m.svar, units=u.m / u.s)
def prt1_rule(m):
return {'avar': m.dx}
def prt2_rule(m):
return {'avar': m.dy}
m.prt1 = Port(rule=prt1_rule)
m.prt2 = Port(rule=prt2_rule)
def arcrule(m):
return dict(source=m.prt1, destination=m.prt2)
m.arc = Arc(rule=arcrule)
# complementarities do not work yet
# The expression system removes the u.m since it is multiplied by zero.
# We need to change the units_container to allow 0 when comparing units
# m.compl = Complementarity(expr=complements(m.dx/m.t >= m.vx, m.dx == 0*u.m))
assert_units_consistent(m)
def test_simple_rule(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.x = Var(m.I)
@m.Constraint(m.I)
def c(m, i):
return m.x[i] <= 0
template, indices = templatize_constraint(m.c)
self.assertEqual(len(indices), 1)
self.assertIs(indices[0]._set, m.I)
self.assertEqual(str(template), "x[_1] <= 0.0")
# Test that the RangeSet iterator was put back
self.assertEqual(list(m.I), list(range(1,4)))
# Evaluate the template
indices[0].set_value(2)
self.assertEqual(str(resolve_template(template)), 'x[2] <= 0.0')
def test_rule_option2(self):
"""Test rule option"""
model = self.create_model()
model.B = RangeSet(1,4)
def f(model, i):
if i == 1:
return Objective.Skip
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
return ans
model.x = Var(model.B, initialize=2)
model.obj = Objective(model.A,rule=f)
self.assertEqual(model.obj[2](), 16)
self.assertEqual(value(model.obj[2]), 16)
def test_len(self):
model = self.create_model()
model.c = Constraint(model.A)
self.assertEqual(len(model.c),0)
model = self.create_model()
model.B = RangeSet(1,4)
"""Test rule option"""
def f(model):
ans=0
for i in model.B:
ans = ans + model.x[i]
ans = ans==2
return ans
model.x = Var(model.B, initialize=2)
model.c = Constraint(rule=f)
self.assertEqual(len(model.c),1)
def test_fix_discrete(self):
# Coverage of the _clear_attribute method
self.model.A = RangeSet(1,4)
self.model.a = Var()
self.model.b = Var(within=self.model.A)
self.model.c = Var(within=NonNegativeIntegers)
self.model.d = Var(within=Integers, bounds=(-2,3))
self.model.e = Var(within=Boolean)
self.model.f = Var(domain=Boolean)
instance=self.model.create_instance()
xfrm = TransformationFactory('core.fix_discrete')
rinst = xfrm.create_using(instance)
self.assertFalse(rinst.a.is_fixed())
self.assertTrue(rinst.b.is_fixed())
self.assertTrue(rinst.c.is_fixed())
self.assertTrue(rinst.d.is_fixed())
self.assertTrue(rinst.e.is_fixed())
self.assertTrue(rinst.f.is_fixed())
def test_init_param_from_ndarray(self):
# Test issue #2033
m = ConcreteModel()
m.ix_set = RangeSet(2)
p_init = np.array([0, 5])
def init_workaround(model, i):
return p_init[i - 1]
m.p = Param(m.ix_set, initialize=init_workaround)
m.v = Var(m.ix_set)
expr = m.p[1] > m.v[1]
self.assertIsInstance(expr, InequalityExpression)
self.assertEqual(str(expr), "v[1] < 0")
expr = m.p[2] > m.v[2]
self.assertIsInstance(expr, InequalityExpression)
self.assertEqual(str(expr), "v[2] < 5")
def _make_stripping_arcs(self):
self._stripping_stream_index = RangeSet(
self.config.feed_tray_location + 1,
self.config.number_of_trays - 1)
def rule_liq_stream(self, i):
return {"source": self.stripping_section[i].liq_out,
"destination": self.stripping_section[i + 1].liq_in}
def rule_vap_stream(self, i):
return {"source": self.stripping_section[i + 1].vap_out,
"destination": self.stripping_section[i].vap_in}
self.stripping_liq_stream = Arc(
self._stripping_stream_index, rule=rule_liq_stream)
self.stripping_vap_stream = Arc(
self._stripping_stream_index, rule=rule_vap_stream)
def test_rule_option2(self):
"""Test rule option"""
model = self.create_model()
model.B = RangeSet(1,4)
def f(model, i):
if i > 2:
return ObjectiveList.End
i = 2*i - 1
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
return ans
model.x = Var(model.B, initialize=2)
model.o = ObjectiveList(rule=f)
self.assertEqual(model.o[1](), 8)
self.assertEqual(len(model.o), 2)
def test_identify_mutable_parameters(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.a = Var(initialize=1)
m.b = Var(m.I, initialize=1)
#
# There are no variables in expressions with only vars
#
self.assertEqual(list(identify_mutable_parameters(m.a)), [])
self.assertEqual(list(identify_mutable_parameters(m.b[1])), [])
self.assertEqual(list(identify_mutable_parameters(m.a + m.b[1])), [])
self.assertEqual(list(identify_mutable_parameters(m.a**m.b[1])), [])
self.assertEqual(
list(identify_mutable_parameters(m.a**m.b[1] + m.b[2])), [])
self.assertEqual(
list(
identify_mutable_parameters(m.a**m.b[1] +
m.b[2] * m.b[3] * m.b[2])), [])
def test_lookup_and_iter_sparse_data(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.x = Var(m.I, m.I, dense=False)
rd = _ReferenceDict(m.x[...])
rs = _ReferenceSet(m.x[...])
self.assertEqual(len(rd), 0)
# Note: we will periodically re-check the dict to ensure
# iteration doesn't accidentally declare data
self.assertEqual(len(rd), 0)
self.assertEqual(len(rs), 9)
self.assertEqual(len(rd), 0)
self.assertIn((1, 1), rs)
self.assertEqual(len(rd), 0)
self.assertEqual(len(rs), 9)
def test_fixed_var_propagate(self):
"""Test for transitivity in a variable equality set."""
m = ConcreteModel()
m.v1 = Var(initialize=1)
m.v2 = Var(initialize=2)
m.v3 = Var(initialize=3)
m.v4 = Var(initialize=4)
m.c1 = Constraint(expr=m.v1 == m.v2)
m.c2 = Constraint(expr=m.v2 == m.v3)
m.c3 = Constraint(expr=m.v3 == m.v4)
m.v2.fix()
m.s = RangeSet(4)
m.x = Var(m.s, initialize=5)
m.c = Constraint(m.s)
m.c.add(1, expr=m.x[1] == m.x[3])
m.c.add(2, expr=m.x[2] == m.x[4])
m.c.add(3, expr=m.x[2] == m.x[3])
m.c.add(4, expr=m.x[1] == 1)
m.y = Var([1, 2], initialize=3)
m.c_too = Constraint(expr=m.y[1] == m.y[2])
m.z1 = Var()
m.z2 = Var()
m.ignore_me = Constraint(expr=m.y[1] + m.z1 + m.z2 <= 0)
TransformationFactory('contrib.propagate_fixed_vars').apply_to(m)
self.assertTrue(m.v1.fixed)
self.assertTrue(m.v2.fixed)
self.assertTrue(m.v3.fixed)
self.assertTrue(m.v4.fixed)
self.assertEquals(value(m.v4), 2)
self.assertTrue(m.x[1].fixed)
self.assertTrue(m.x[2].fixed)
self.assertTrue(m.x[3].fixed)
self.assertTrue(m.x[4].fixed)
self.assertEquals(value(m.x[4]), 1)
self.assertFalse(m.y[1].fixed)
self.assertFalse(m.y[2].fixed)
self.assertFalse(m.z1.fixed)
self.assertFalse(m.z2.fixed)
def Village_economy_model(vmodel):
from pyomo.environ import Param, RangeSet, NonNegativeReals, Var, Set, Objective, maximize
# Time parameters
vmodel.Years = Param() # Number of years of the project
#supporting sets lists and tuples
tupsec = ("Trad", "Modern")
tupvec = ("El", "Modern_NEl","Trad_NEl")
# SETS
vmodel.years = RangeSet(1, vmodel.Years)
vmodel.sectors = Set(dimen=1, initialize = tupsec )
vmodel.envector = Set(dimen=1, initialize = tupvec )
#PARAMETERS
vmodel.delta = Param(vmodel.sectors)
vmodel.endelta = Param()
vmodel.engamma = Param(vmodel.sectors)
vmodel.gamma = Param(vmodel.sectors)
vmodel.disc_rate = Param()
vmodel.enel = Param(vmodel.sectors,vmodel.envector)
vmodel.speclab = Param(vmodel.envector)
vmodel.speccap = Param(vmodel.envector)
vmodel.specvar = Param(vmodel.envector)
vmodel.workingpeople = Param()
vmodel.workinghoursyr = Param()
#VARIABLES
vmodel.Labor=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals)
vmodel.Capital=Var(vmodel.years,vmodel.sectors)
vmodel.Investment=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals)
vmodel.Output=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals)
vmodel.Consumption=Var(vmodel.years,Within=NonNegativeReals)
vmodel.Utility=Var()
#ENERGY VARIABLES
vmodel.Enlabor=Var(vmodel.years,vmodel.envector,Within=NonNegativeReals)
vmodel.Encapital=Var(vmodel.years,vmodel.envector)
vmodel.Eninvestment=Var(vmodel.years,vmodel.envector)
vmodel.Varcost=Var(vmodel.years,vmodel.envector)
vmodel.Energy=Var(vmodel.years,vmodel.envector,Within=NonNegativeReals)
vmodel.Energyinput=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals)
def test_induced_linear_in_disjunct(self):
m = ConcreteModel()
m.x = Var([0], bounds=(-3, 8))
m.y = Var(RangeSet(2), domain=Binary)
m.logical = ConstraintList()
m.logical.add(expr=m.y[1] + m.y[2] == 1)
m.v = Var([1])
m.v[1].setlb(-2)
m.v[1].setub(7)
m.bilinear_outside = Constraint(expr=m.x[0] * m.v[1] >= 2)
m.disjctn = Disjunction(
expr=[[m.x[0] * m.v[1] == 3, 2 * m.x[0] == m.y[1] +
m.y[2]], [m.x[0] * m.v[1] == 4]])
TransformationFactory('contrib.induced_linearity').apply_to(m)
self.assertEqual(
m.disjctn.disjuncts[0].constraint[1].body.polynomial_degree(), 1)
self.assertEqual(m.bilinear_outside.body.polynomial_degree(), 2)
self.assertEqual(
m.disjctn.disjuncts[1].constraint[1].body.polynomial_degree(), 2)
def test_rule_option1a(self):
"""Test rule option"""
model = self.create_model()
model.B = RangeSet(1,4)
@simple_objectivelist_rule
def f(model, i):
if i > 4:
return None
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
return ans
model.x = Var(model.B, initialize=2)
model.o = ObjectiveList(rule=f)
self.assertEqual(model.o[1](), 8)
self.assertEqual(model.o[2](), 16)
self.assertEqual(len(model.o), 4)
def setup_mccormick_cuts(b, name, nsegs, *sets):
print(
'Warning: setup_mccormick_cuts is now deprecated in favor of the util.mccormick.add_mccormick_relaxation function, which automatically performs setup.'
)
cuts = b.mccormick_cuts = Set(initialize=['lb1', 'lb2', 'ub1', 'ub2'])
sets_cuts = sets + (cuts, )
setattr(b, name, Constraint(*sets_cuts))
if nsegs > 1:
# If we are doing piecewise McCormick, set up additional constraints and variables.
b.seg_length = Param(*sets, mutable=True)
segs = b.segs = RangeSet(nsegs)
sets_segs = sets + (segs, )
b.seg_active = Var(*sets_segs, domain=Binary)
b.delta_y = Var(*sets_segs, domain=NonNegativeReals)
b.eq_seg_active_sum = Constraint(*sets)
b.eq_y = Constraint(*sets)
b.eq_dy_ub = Constraint(*sets)
b.eq_x_lb = Constraint(*sets)
b.eq_x_ub = Constraint(*sets)
def test_rule_option3a(self):
model = self.create_model()
model.B = RangeSet(1,4)
@simple_constraint_rule
def f(model, i):
if i%2 == 0:
return None
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
ans = ans <= 0
ans = ans >= 0
return ans
model.x = Var(model.B, initialize=2)
model.c = Constraint(model.A,rule=f)
self.assertEqual(model.c[1](), 8)
self.assertEqual(len(model.c), 2)
def test_rule_option2(self):
model = self.create_model()
model.B = RangeSet(1,4)
def f(model, i):
if i > 2:
return ConstraintList.End
i = 2*i - 1
ans=0
for j in model.B:
ans = ans + model.x[j]
ans *= i
ans = ans <= 0
ans = ans >= 0
return ans
model.x = Var(model.B, initialize=2)
model.c = ConstraintList(rule=f)
self.assertEqual(model.c[1](), 8)
self.assertEqual(len(model.c), 2)
def test_identify_vars_vars(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.a = Var(initialize=1)
m.b = Var(m.I, initialize=1)
m.p = Param(initialize=1, mutable=True)
m.x = ExternalFunction(library='foo.so', function='bar')
#
# Identify variables in various algebraic expressions
#
self.assertEqual( list(identify_variables(m.a)), [m.a] )
self.assertEqual( list(identify_variables(m.b[1])), [m.b[1]] )
self.assertEqual( list(identify_variables(m.a+m.b[1])),
[ m.a, m.b[1] ] )
self.assertEqual( list(identify_variables(m.a**m.b[1])),
[ m.a, m.b[1] ] )
self.assertEqual( list(identify_variables(m.a**m.b[1] + m.b[2])),
[ m.a, m.b[1], m.b[2] ] )
self.assertEqual( list(identify_variables(
m.a**m.b[1] + m.b[2]*m.b[3]*m.b[2])),
[ m.a, m.b[1], m.b[2], m.b[3] ] )
self.assertEqual( list(identify_variables(
m.a**m.b[1] + m.b[2]/m.b[3]*m.b[2])),
[ m.a, m.b[1], m.b[2], m.b[3] ] )
#
# Identify variables in the arguments to functions
#
self.assertEqual( list(identify_variables(
m.x(m.a, 'string_param', 1, [])*m.b[1] )),
[ m.a, m.b[1] ] )
self.assertEqual( list(identify_variables(
m.x(m.p, 'string_param', 1, [])*m.b[1] )),
[ m.b[1] ] )
self.assertEqual( list(identify_variables(
tanh(m.a)*m.b[1] )), [ m.a, m.b[1] ] )
self.assertEqual( list(identify_variables(
abs(m.a)*m.b[1] )), [ m.a, m.b[1] ] )
#
# Check logic for allowing duplicates
#
self.assertEqual( list(identify_variables(m.a**m.a + m.a)),
[ m.a ] )
def test_solve_with_store4(self):
model = ConcreteModel()
model.A = RangeSet(1, 4)
model.b = Block()
model.b.x = Var(model.A, bounds=(-1, 1))
model.b.obj = Objective(expr=sum_product(model.b.x))
model.c = Constraint(expr=model.b.x[1] >= 0)
opt = SolverFactory('glpk')
results = opt.solve(model, load_solutions=False)
self.assertEqual(len(model.solutions), 0)
self.assertEqual(len(results.solution), 1)
model.solutions.load_from(results)
self.assertEqual(len(model.solutions), 1)
self.assertEqual(len(results.solution), 1)
#
model.solutions.store_to(results)
results.write(filename=join(currdir, 'solve_with_store8.out'),
format='json')
self.assertMatchesYamlBaseline(join(currdir, "solve_with_store8.out"),
join(currdir, "solve_with_store4.txt"))
def test_jacobian(self):
m = ConcreteModel()
m.I = RangeSet(4)
m.x = Var(m.I)
idxMap = {}
jacs = []
for i in m.I:
idxMap[i] = len(jacs)
jacs.append(m.x[i])
expr = m.x[1]+m.x[2]*m.x[3]**2
ans = differentiate(expr, wrt_list=jacs)
self.assertEqual(len(ans), len(m.I))
self.assertEqual(str(ans[0]), "1.0")
self.assertEqual(str(ans[1]), "x[3]**2.0")
self.assertEqual(str(ans[2]), "2.0*x[2]*x[3]")
# 0 calculated by bypassing sympy
self.assertEqual(str(ans[3]), "0.0")
def _make_rectification_arcs(self):
self._rectification_stream_index = RangeSet(
1, self.config.feed_tray_location - 2)
def rule_liq_stream(self, i):
return {
"source": self.rectification_section[i].liq_out,
"destination": self.rectification_section[i + 1].liq_in
}
def rule_vap_stream(self, i):
return {
"source": self.rectification_section[i + 1].vap_out,
"destination": self.rectification_section[i].vap_in
}
self.rectification_liq_stream = Arc(self._rectification_stream_index,
rule=rule_liq_stream)
self.rectification_vap_stream = Arc(self._rectification_stream_index,
rule=rule_vap_stream)
def test_optimal_mip(self):
self.model.Idx = RangeSet(2)
self.model.X = Var(self.model.Idx, within=NonNegativeIntegers)
self.model.Y = Var(self.model.Idx, within=Binary)
self.model.C1 = Constraint(expr=self.model.X[1] == self.model.X[2] + 1)
self.model.Obj = Objective(expr=self.model.Y[1] + self.model.Y[2] - self.model.X[1],
sense=maximize)
results = self.opt.solve(self.model)
self.assertEqual(1.0, results.problem.lower_bound)
self.assertEqual(1.0, results.problem.upper_bound)
self.assertEqual(results.problem.number_of_binary_variables, 2)
self.assertEqual(results.problem.number_of_integer_variables, 4)
self.assertEqual(ProblemSense.maximize, results.problem.sense)
self.assertEqual(TerminationCondition.optimal, results.solver.termination_condition)
self.assertEqual(
'Model was solved to optimality (subject to tolerances), and an optimal solution is available.',
results.solver.termination_message)
self.assertEqual(SolverStatus.ok, results.solver.status)
def test_solve_with_pickle(self):
model = ConcreteModel()
model.A = RangeSet(1, 4)
model.b = Block()
model.b.x = Var(model.A, bounds=(-1, 1))
model.b.obj = Objective(expr=sum_product(model.b.x))
model.c = Constraint(expr=model.b.x[1] >= 0)
opt = SolverFactory('glpk')
self.assertEqual(len(model.solutions), 0)
results = opt.solve(model, symbolic_solver_labels=True)
self.assertEqual(len(model.solutions), 1)
#
self.assertEqual(model.solutions[0].gap, 0.0)
#self.assertEqual(model.solutions[0].status, SolutionStatus.feasible)
self.assertEqual(model.solutions[0].message, None)
#
buf = pickle.dumps(model)
tmodel = pickle.loads(buf)
self.assertEqual(len(tmodel.solutions), 1)
self.assertEqual(tmodel.solutions[0].gap, 0.0)
#self.assertEqual(tmodel.solutions[0].status, SolutionStatus.feasible)
self.assertEqual(tmodel.solutions[0].message, None)
def test_solve4(self):
model = ConcreteModel()
model.A = RangeSet(1,4)
model.x = Var(model.A, bounds=(-1,1))
def obj_rule(model):
return sum_product(model.x)
model.obj = Objective(rule=obj_rule)
def c_rule(model):
expr = 0
for i in model.A:
expr += i*model.x[i]
return expr == 0
model.c = Constraint(rule=c_rule)
opt = SolverFactory('glpk')
results = opt.solve(model, symbolic_solver_labels=True)
model.solutions.store_to(results)
results.write(filename=join(currdir,'solve4.out'), format='json')
with open(join(currdir,"solve4.out"), 'r') as out, \
open(join(currdir,"solve1.txt"), 'r') as txt:
self.assertStructuredAlmostEqual(json.load(txt), json.load(out),
abstol=1e-4,
allow_second_superset=True)
