def _test_disc_first(self, tname): ofile = join(currdir, tname + '.' + self.sim_mod + '.out') bfile = join(currdir, tname + '.' + self.sim_mod + '.txt') setup_redirect(ofile) # create model exmod = import_file(join(exdir, tname + '.py')) m = exmod.create_model() # Discretize model discretizer = TransformationFactory('dae.collocation') discretizer.apply_to(m, nfe=10, ncp=5) # Simulate model sim = Simulator(m, package=self.sim_mod) if hasattr(m, 'var_input'): tsim, profiles = sim.simulate(numpoints=100, varying_inputs=m.var_input) else: tsim, profiles = sim.simulate(numpoints=100) # Initialize model sim.initialize_model() self._print(m, profiles) reset_redirect() if not os.path.exists(bfile): os.rename(ofile, bfile) # os.system('diff ' + ofile + ' ' + bfile) self.assertFileEqualsBaseline(ofile, bfile, tolerance=0.01)
def test_disc_invalid_options(self): m = self.m.clone() with self.assertRaises(TypeError): TransformationFactory('dae.collocation').apply_to(m, wrt=m.s) with self.assertRaises(ValueError): TransformationFactory('dae.collocation').apply_to(m, nfe=-1) with self.assertRaises(ValueError): TransformationFactory('dae.collocation').apply_to(m, ncp=0) with self.assertRaises(ValueError): TransformationFactory('dae.collocation').apply_to(m, scheme='foo') with self.assertRaises(ValueError): TransformationFactory('dae.collocation').apply_to(m, foo=True) TransformationFactory('dae.collocation').apply_to(m, wrt=m.t) with self.assertRaises(ValueError): TransformationFactory('dae.collocation').apply_to(m, wrt=m.t) m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m) with self.assertRaises(ValueError): disc.apply_to(m)
def run_bilevel(self, *args, **kwds): module = import_file(args[0]) instance = module.pyomo_create_model(None, None) xfrm = TransformationFactory('bilevel.linear_mpec') xfrm.apply_to(instance, deterministic=True) instance.pprint(filename=join(currdir, self.problem + '_linear_mpec.out'))
def test_disc_multi_index(self): m = self.m.clone() m.v2 = Var(m.t, m.s) m.dv2 = DerivativeVar(m.v2) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(hasattr(m, 'dv2_disc_eq')) self.assertTrue(len(m.dv2_disc_eq) == 45) self.assertTrue(len(m.v2) == 48) expected_tau_points = [0.0, 0.1550510257216822, 0.64494897427831788, 1.0] expected_disc_points = [0, 0.310102, 1.289898, 2.0, 2.310102, 3.289898, 4.0, 4.310102, 5.289898, 6.0, 6.310102, 7.289898, 8.0, 8.310102, 9.289898, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-RADAU') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue( hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv2 in m._pyomo_dae_reclassified_derivativevars)
def test_disc_invalid_options(self): m = self.m.clone() with self.assertRaises(TypeError): TransformationFactory('dae.finite_difference').apply_to(m, wrt=m.s) with self.assertRaises(ValueError): TransformationFactory('dae.finite_difference').apply_to(m, nfe=-1) with self.assertRaises(ValueError): TransformationFactory('dae.finite_difference').apply_to(m, scheme='foo') with self.assertRaises(ValueError): TransformationFactory('dae.finite_difference').apply_to(m, foo=True) TransformationFactory('dae.finite_difference').apply_to(m, wrt=m.t) with self.assertRaises(ValueError): TransformationFactory('dae.finite_difference').apply_to(m, wrt=m.t) m = self.m.clone() disc = TransformationFactory('dae.finite_difference') disc.apply_to(m) with self.assertRaises(ValueError): disc.apply_to(m)
def test_disc_single_index_central(self): m = self.m.clone() disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=5, scheme='CENTRAL') self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertEqual(len(m.dv1_disc_eq), 4) self.assertEqual(len(m.v1), 6) expected_disc_points = [0, 2.0, 4.0, 6.0, 8.0, 10] disc_info = m.t.get_discretization_info() self.assertEqual(disc_info['scheme'], 'CENTRAL Difference') for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) output = \ """\ dv1_disc_eq : Size=4, Index=t, Active=True Key : Lower : Body : Upper : Active 2.0 : 0.0 : dv1[2.0] - 0.25*(v1[4.0] - v1[0]) : 0.0 : True 4.0 : 0.0 : dv1[4.0] - 0.25*(v1[6.0] - v1[2.0]) : 0.0 : True 6.0 : 0.0 : dv1[6.0] - 0.25*(v1[8.0] - v1[4.0]) : 0.0 : True 8.0 : 0.0 : dv1[8.0] - 0.25*(v1[10] - v1[6.0]) : 0.0 : True """ out = StringIO() m.dv1_disc_eq.pprint(ostream=out) self.assertEqual(output, out.getvalue())
def test_disc_single_index_backward(self): m = self.m.clone() disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=5) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertEqual(len(m.dv1_disc_eq), 5) self.assertEqual(len(m.v1), 6) expected_disc_points = [0, 2.0, 4.0, 6.0, 8.0, 10] disc_info = m.t.get_discretization_info() self.assertEqual(disc_info['scheme'], 'BACKWARD Difference') for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertIn(m.dv1, m._pyomo_dae_reclassified_derivativevars) output = \ """\ dv1_disc_eq : Size=5, Index=t, Active=True Key : Lower : Body : Upper : Active 2.0 : 0.0 : dv1[2.0] - 0.5*(v1[2.0] - v1[0]) : 0.0 : True 4.0 : 0.0 : dv1[4.0] - 0.5*(v1[4.0] - v1[2.0]) : 0.0 : True 6.0 : 0.0 : dv1[6.0] - 0.5*(v1[6.0] - v1[4.0]) : 0.0 : True 8.0 : 0.0 : dv1[8.0] - 0.5*(v1[8.0] - v1[6.0]) : 0.0 : True 10 : 0.0 : dv1[10] - 0.5*(v1[10] - v1[8.0]) : 0.0 : True """ out = StringIO() m.dv1_disc_eq.pprint(ostream=out) self.assertEqual(output, out.getvalue())
def test_disc_multidimen_index(self): m = self.m.clone() m.s2 = Set(initialize=[('A', 'B'), ('C', 'D'), ('E', 'F')]) m.v2 = Var(m.t, m.s2) m.dv2 = DerivativeVar(m.v2) m.v3 = Var(m.s2, m.t) m.dv3 = DerivativeVar(m.v3) disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=5) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(hasattr(m, 'dv2_disc_eq')) self.assertTrue(hasattr(m, 'dv3_disc_eq')) self.assertEqual(len(m.dv2_disc_eq), 15) self.assertEqual(len(m.v2), 18) self.assertEqual(len(m.dv3_disc_eq), 15) self.assertEqual(len(m.v3), 18) expected_disc_points = [0, 2.0, 4.0, 6.0, 8.0, 10] disc_info = m.t.get_discretization_info() self.assertEqual(disc_info['scheme'], 'BACKWARD Difference') for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx])
def test_var_bound_propagate_revert(self): """Test to make sure bound propagation revert works.""" m = ConcreteModel() m.v1 = Var(initialize=1, bounds=(1, 3)) m.v2 = Var(initialize=2, bounds=(0, 8)) m.v3 = Var(initialize=3, bounds=(2, 4)) m.v4 = Var(initialize=4, bounds=(0, 5)) m.c1 = Constraint(expr=m.v1 == m.v2) m.c2 = Constraint(expr=m.v2 == m.v3) m.c3 = Constraint(expr=m.v3 == m.v4) xfrm = TransformationFactory('contrib.propagate_eq_var_bounds') xfrm.apply_to(m, tmp=True) self.assertEquals(value(m.v1.lb), 2) self.assertEquals(value(m.v1.lb), value(m.v2.lb)) self.assertEquals(value(m.v1.lb), value(m.v3.lb)) self.assertEquals(value(m.v1.lb), value(m.v4.lb)) self.assertEquals(value(m.v1.ub), 3) self.assertEquals(value(m.v1.ub), value(m.v2.ub)) self.assertEquals(value(m.v1.ub), value(m.v3.ub)) self.assertEquals(value(m.v1.ub), value(m.v4.ub)) xfrm.revert(m) self.assertEquals(value(m.v1.lb), 1) self.assertEquals(value(m.v2.lb), 0) self.assertEquals(value(m.v3.lb), 2) self.assertEquals(value(m.v4.lb), 0) self.assertEquals(value(m.v1.ub), 3) self.assertEquals(value(m.v2.ub), 8) self.assertEquals(value(m.v3.ub), 4) self.assertEquals(value(m.v4.ub), 5)
def _test(self, tname): ofile = join(currdir, tname + '.' + self.sim_mod + '.out') bfile = join(currdir, tname + '.' + self.sim_mod + '.txt') setup_redirect(ofile) # create model exmod = import_file(join(exdir, tname + '.py')) m = exmod.create_model() # Simulate model sim = Simulator(m, package=self.sim_mod) if hasattr(m, 'var_input'): tsim, profiles = sim.simulate(numpoints=100, varying_inputs=m.var_input) else: tsim, profiles = sim.simulate(numpoints=100) # Discretize model discretizer = TransformationFactory('dae.collocation') discretizer.apply_to(m, nfe=10, ncp=5) # Initialize model sim.initialize_model() self._print(m, profiles) reset_redirect() if not os.path.exists(bfile): os.rename(ofile, bfile) # os.system('diff ' + ofile + ' ' + bfile) self.assertFileEqualsBaseline(ofile, bfile, tolerance=0.01)
def test_disc_single_index_backward(self): m = self.m.clone() disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=5) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 5) self.assertTrue(len(m.v1) == 6) expected_disc_points = [0, 2.0, 4.0, 6.0, 8.0, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'BACKWARD Difference') for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) output = \ """\ dv1_disc_eq : Size=5, Index=t, Active=True Key : Lower : Body : Upper : Active 2.0 : 0.0 : dv1[2.0] - 0.5*(v1[2.0] - v1[0]) : 0.0 : True 4.0 : 0.0 : dv1[4.0] - 0.5*(v1[4.0] - v1[2.0]) : 0.0 : True 6.0 : 0.0 : dv1[6.0] - 0.5*(v1[6.0] - v1[4.0]) : 0.0 : True 8.0 : 0.0 : dv1[8.0] - 0.5*(v1[8.0] - v1[6.0]) : 0.0 : True 10 : 0.0 : dv1[10] - 0.5*(v1[10] - v1[8.0]) : 0.0 : True """ out = StringIO() m.dv1_disc_eq.pprint(ostream=out) self.assertEqual(output, out.getvalue())
def test_disc_multi_index2(self): m = self.m.clone() m.t2 = ContinuousSet(bounds=(0, 5)) m.v2 = Var(m.t, m.t2) m.dv2dt = DerivativeVar(m.v2, wrt=m.t) m.dv2dt2 = DerivativeVar(m.v2, wrt=m.t2) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=2, ncp=2) self.assertTrue(hasattr(m, 'dv2dt_disc_eq')) self.assertTrue(hasattr(m, 'dv2dt2_disc_eq')) self.assertTrue(len(m.dv2dt_disc_eq) == 20) self.assertTrue(len(m.dv2dt2_disc_eq) == 20) self.assertTrue(len(m.v2) == 25) expected_t_disc_points = [0, 1.666667, 5.0, 6.666667, 10] expected_t2_disc_points = [0, 0.833333, 2.5, 3.333333, 5] for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_t_disc_points[idx]) for idx, val in enumerate(list(m.t2)): self.assertAlmostEqual(val, expected_t2_disc_points[idx]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv2dt in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv2dt2 in m._pyomo_dae_reclassified_derivativevars)
def test_disc_second_order_legendre(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=2, ncp=2, scheme='LAGRANGE-LEGENDRE') self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertTrue(hasattr(m, 'v1_t_cont_eq')) self.assertTrue(len(m.dv1dt2_disc_eq) == 4) self.assertTrue(len(m.v1_t_cont_eq) == 2) self.assertTrue(len(m.v1) == 7) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv1dt2 in m._pyomo_dae_reclassified_derivativevars) repn_baseline = {id(m.dv1dt2[1.056624]): 1, id(m.v1[0]): -0.48, id(m.v1[1.056624]): 0.65569, id(m.v1[3.943376]): -0.17569} repn = generate_standard_repn(m.dv1dt2_disc_eq[1.056624].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = {id(m.dv1dt2[6.056624]): 1, id(m.v1[5.0]): -0.48, id(m.v1[6.056624]): 0.65569, id(m.v1[8.943376]): -0.17569} repn = generate_standard_repn(m.dv1dt2_disc_eq[6.056624].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_disc_second_order_legendre(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=2, ncp=2, scheme='LAGRANGE-LEGENDRE') self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertTrue(hasattr(m, 'v1_t_cont_eq')) self.assertTrue(len(m.dv1dt2_disc_eq) == 4) self.assertTrue(len(m.v1_t_cont_eq) == 2) self.assertTrue(len(m.v1) == 7) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv1dt2 in m._pyomo_dae_reclassified_derivativevars) repn_baseline = {id(m.dv1dt2[1.056624]): 1, id(m.v1[0]): -0.48, id(m.v1[1.056624]): 0.65569, id(m.v1[3.943376]): -0.17569} repn = generate_standard_repn(m.dv1dt2_disc_eq[1.056624].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = {id(m.dv1dt2[6.056624]): 1, id(m.v1[5.0]): -0.48, id(m.v1[6.056624]): 0.65569, id(m.v1[8.943376]): -0.17569} repn = generate_standard_repn(m.dv1dt2_disc_eq[6.056624].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_disc_second_order_radau(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=2, ncp=2) self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertTrue(len(m.dv1dt2_disc_eq) == 4) self.assertTrue(len(m.v1) == 5) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv1dt2 in m._pyomo_dae_reclassified_derivativevars) repn_baseline = {id(m.dv1dt2[5.0]): 1, id(m.v1[0]): -0.24, id(m.v1[1.666667]): 0.36, id(m.v1[5.0]): -0.12} repn = generate_standard_repn(m.dv1dt2_disc_eq[5.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = {id(m.dv1dt2[10]): 1, id(m.v1[5.0]): -0.24, id(m.v1[6.666667]): 0.36, id(m.v1[10]): -0.12} repn = generate_standard_repn(m.dv1dt2_disc_eq[10.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_disc_multi_index(self): m = self.m.clone() m.v2 = Var(m.t, m.s) m.dv2 = DerivativeVar(m.v2) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(hasattr(m, 'dv2_disc_eq')) self.assertTrue(len(m.dv2_disc_eq) == 45) self.assertTrue(len(m.v2) == 48) expected_tau_points = [0.0, 0.1550510257216822, 0.64494897427831788, 1.0] expected_disc_points = [0, 0.310102, 1.289898, 2.0, 2.310102, 3.289898, 4.0, 4.310102, 5.289898, 6.0, 6.310102, 7.289898, 8.0, 8.310102, 9.289898, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-RADAU') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue( hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv2 in m._pyomo_dae_reclassified_derivativevars)
def test_disc_multi_index2(self): m = self.m.clone() m.t2 = ContinuousSet(bounds=(0, 5)) m.v2 = Var(m.t, m.t2) m.dv2dt = DerivativeVar(m.v2, wrt=m.t) m.dv2dt2 = DerivativeVar(m.v2, wrt=m.t2) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=2, ncp=2) self.assertTrue(hasattr(m, 'dv2dt_disc_eq')) self.assertTrue(hasattr(m, 'dv2dt2_disc_eq')) self.assertTrue(len(m.dv2dt_disc_eq) == 20) self.assertTrue(len(m.dv2dt2_disc_eq) == 20) self.assertTrue(len(m.v2) == 25) expected_t_disc_points = [0, 1.666667, 5.0, 6.666667, 10] expected_t2_disc_points = [0, 0.833333, 2.5, 3.333333, 5] for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_t_disc_points[idx]) for idx, val in enumerate(list(m.t2)): self.assertAlmostEqual(val, expected_t2_disc_points[idx]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv2dt in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv2dt2 in m._pyomo_dae_reclassified_derivativevars)
def test_var_bound_propagate_revert(self): """Test to make sure bound propagation revert works.""" m = ConcreteModel() m.v1 = Var(initialize=1, bounds=(1, 3)) m.v2 = Var(initialize=2, bounds=(0, 8)) m.v3 = Var(initialize=3, bounds=(2, 4)) m.v4 = Var(initialize=4, bounds=(0, 5)) m.c1 = Constraint(expr=m.v1 == m.v2) m.c2 = Constraint(expr=m.v2 == m.v3) m.c3 = Constraint(expr=m.v3 == m.v4) xfrm = TransformationFactory('contrib.propagate_eq_var_bounds') xfrm.apply_to(m, tmp=True) self.assertEquals(value(m.v1.lb), 2) self.assertEquals(value(m.v1.lb), value(m.v2.lb)) self.assertEquals(value(m.v1.lb), value(m.v3.lb)) self.assertEquals(value(m.v1.lb), value(m.v4.lb)) self.assertEquals(value(m.v1.ub), 3) self.assertEquals(value(m.v1.ub), value(m.v2.ub)) self.assertEquals(value(m.v1.ub), value(m.v3.ub)) self.assertEquals(value(m.v1.ub), value(m.v4.ub)) xfrm.revert(m) self.assertEquals(value(m.v1.lb), 1) self.assertEquals(value(m.v2.lb), 0) self.assertEquals(value(m.v3.lb), 2) self.assertEquals(value(m.v4.lb), 0) self.assertEquals(value(m.v1.ub), 3) self.assertEquals(value(m.v2.ub), 8) self.assertEquals(value(m.v3.ub), 4) self.assertEquals(value(m.v4.ub), 5)
def test_disc_second_order_radau(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=2, ncp=2) self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertTrue(len(m.dv1dt2_disc_eq) == 4) self.assertTrue(len(m.v1) == 5) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv1dt2 in m._pyomo_dae_reclassified_derivativevars) repn_baseline = {id(m.dv1dt2[5.0]): 1, id(m.v1[0]): -0.24, id(m.v1[1.666667]): 0.36, id(m.v1[5.0]): -0.12} repn = generate_standard_repn(m.dv1dt2_disc_eq[5.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = {id(m.dv1dt2[10]): 1, id(m.v1[5.0]): -0.24, id(m.v1[6.666667]): 0.36, id(m.v1[10]): -0.12} repn = generate_standard_repn(m.dv1dt2_disc_eq[10.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_get_index_information(self): m = ConcreteModel() m.t = ContinuousSet(bounds=(0, 10)) m.x = ContinuousSet(bounds=(0, 10)) m.s = Set(initialize=['a', 'b', 'c']) m.v = Var(m.t, m.x, m.s, initialize=1) m.v2 = Var(m.t, m.s, initialize=1) disc = TransformationFactory('dae.collocation') disc.apply_to(m, wrt=m.t, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') disc.apply_to(m, wrt=m.x, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') info = get_index_information(m.v, m.t) nts = info['non_ds'] index_getter = info['index function'] self.assertEqual(len(nts), 33) self.assertTrue(m.x in nts.set_tuple) self.assertTrue(m.s in nts.set_tuple) self.assertEqual(index_getter((8.0, 'a'), 1, 0), (2.0, 8.0, 'a')) info = get_index_information(m.v2, m.t) nts = info['non_ds'] index_getter = info['index function'] self.assertEqual(len(nts), 3) self.assertTrue(m.s is nts) self.assertEqual(index_getter('a', 1, 0), (2.0, 'a'))
def _test_disc_first(self, tname): bfile = join(currdir, tname + '.' + self.sim_mod + '.json') # create model exmod = import_file(join(exdir, tname + '.py')) m = exmod.create_model() # Discretize model discretizer = TransformationFactory('dae.collocation') discretizer.apply_to(m, nfe=10, ncp=5) # Simulate model sim = Simulator(m, package=self.sim_mod) if hasattr(m, 'var_input'): tsim, profiles = sim.simulate(numpoints=100, varying_inputs=m.var_input) else: tsim, profiles = sim.simulate(numpoints=100) # Initialize model sim.initialize_model() results = self._store_results(m, profiles) # Used to regenerate baseline files if not os.path.exists(bfile): with open(bfile, 'w') as f1: json.dump(results, f1) # Compare results to baseline with open(bfile, 'r') as f2: baseline = json.load(f2) self.assertStructuredAlmostEqual(results, baseline, abstol=1e-2)
def test_disc_multidimen_index(self): m = self.m.clone() m.s2 = Set(initialize=[('A', 'B'), ('C', 'D'), ('E', 'F')]) m.v2 = Var(m.t, m.s2) m.dv2 = DerivativeVar(m.v2) m.v3 = Var(m.s2, m.t) m.dv3 = DerivativeVar(m.v3) disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=5) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(hasattr(m, 'dv2_disc_eq')) self.assertTrue(hasattr(m, 'dv3_disc_eq')) self.assertTrue(len(m.dv2_disc_eq) == 15) self.assertTrue(len(m.v2) == 18) self.assertTrue(len(m.dv3_disc_eq) == 15) self.assertTrue(len(m.v3) == 18) expected_disc_points = [0, 2.0, 4.0, 6.0, 8.0, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'BACKWARD Difference') for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx])
def test_var_bound_propagate_crossover(self): """Test for error message when variable bound crosses over.""" m = ConcreteModel() m.v1 = Var(initialize=1, bounds=(1, 3)) m.v2 = Var(initialize=5, bounds=(4, 8)) m.c1 = Constraint(expr=m.v1 == m.v2) xfrm = TransformationFactory('contrib.propagate_eq_var_bounds') with self.assertRaises(ValueError): xfrm.apply_to(m)
def test_var_bound_propagate_crossover(self): """Test for error message when variable bound crosses over.""" m = ConcreteModel() m.v1 = Var(initialize=1, bounds=(1, 3)) m.v2 = Var(initialize=5, bounds=(4, 8)) m.c1 = Constraint(expr=m.v1 == m.v2) xfrm = TransformationFactory('contrib.propagate_eq_var_bounds') with self.assertRaises(ValueError): xfrm.apply_to(m)
def test_disc_single_index_legendre(self): m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3, scheme='LAGRANGE-LEGENDRE') self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(hasattr(m, 'v1_t_cont_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1_t_cont_eq) == 5) self.assertTrue(len(m.v1) == 21) expected_tau_points = [ 0.0, 0.11270166537925834, 0.49999999999999989, 0.88729833462074226 ] expected_disc_points = [ 0, 0.225403, 1.0, 1.774597, 2.0, 2.225403, 3.0, 3.774597, 4.0, 4.225403, 5.0, 5.774597, 6.0, 6.225403, 7.0, 7.774597, 8.0, 8.225403, 9.0, 9.774597, 10 ] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-LEGENDRE') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue(type(val) in [float, int]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) repn_baseline = { id(m.dv1[3.0]): 1, id(m.v1[2.0]): -1.5, id(m.v1[2.225403]): 2.86374, id(m.v1[3.0]): -1.0, id(m.v1[3.774597]): -0.36374 } repn = generate_standard_repn(m.dv1_disc_eq[3.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = { id(m.dv1[5.0]): 1, id(m.v1[4.0]): -1.5, id(m.v1[4.225403]): 2.86374, id(m.v1[5.0]): -1.0, id(m.v1[5.774597]): -0.36374 } repn = generate_standard_repn(m.dv1_disc_eq[5.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_discretize_twice(self): m = self.m.clone() disc1 = TransformationFactory('dae.finite_difference') disc1.apply_to(m, nfe=5) disc2 = TransformationFactory('dae.finite_difference') with self.assertRaises(DAE_Error): disc2.apply_to(m, nfe=5)
def test_discretize_twice(self): m = self.m.clone() disc1 = TransformationFactory('dae.collocation') disc1.apply_to(m, nfe=5, ncp=3) disc2 = TransformationFactory('dae.collocation') with self.assertRaises(DAE_Error): disc2.apply_to(m, nfe=5, ncp=3)
def test_discretize_twice(self): m = self.m.clone() disc1 = TransformationFactory('dae.collocation') disc1.apply_to(m, nfe=5, ncp=3) disc2 = TransformationFactory('dae.collocation') with self.assertRaises(DAE_Error): disc2.apply_to(m, nfe=5, ncp=3)
def test_discretize_twice(self): m = self.m.clone() disc1 = TransformationFactory('dae.finite_difference') disc1.apply_to(m, nfe=5) disc2 = TransformationFactory('dae.finite_difference') with self.assertRaises(DAE_Error): disc2.apply_to(m, nfe=5)
def make_model(): m = ConcreteModel() m.time = ContinuousSet(bounds=(0, 10)) m.space = ContinuousSet(bounds=(0, 5)) m.set1 = Set(initialize=['a', 'b', 'c']) m.set2 = Set(initialize=['d', 'e', 'f']) m.fs = Block() m.fs.v0 = Var(m.space, initialize=1) @m.fs.Block() def b1(b): b.v = Var(m.time, m.space, initialize=1) b.dv = DerivativeVar(b.v, wrt=m.time, initialize=0) b.con = Constraint(m.time, m.space, rule=lambda b, t, x: b.dv[t, x] == 7 - b.v[t, x]) # Inconsistent @b.Block(m.time) def b2(b, t): b.v = Var(initialize=2) @m.fs.Block(m.time, m.space) def b2(b, t, x): b.v = Var(m.set1, initialize=2) @b.Block(m.set1) def b3(b, c): b.v = Var(m.set2, initialize=3) @b.Constraint(m.set2) def con(b, s): return (5 * b.v[s] == m.fs.b2[m.time.first(), m.space.first()].v[c]) # inconsistent @m.fs.Constraint(m.time) def con1(fs, t): return fs.b1.v[t, m.space.last()] == 5 # Will be inconsistent @m.fs.Constraint(m.space) def con2(fs, x): return fs.b1.v[m.time.first(), x] == fs.v0[x] # will be consistent disc = TransformationFactory('dae.collocation') disc.apply_to(m, wrt=m.time, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') disc.apply_to(m, wrt=m.space, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') return m
def test_var_bound_propagate_crossover(self): """Test for error message when variable bound crosses over.""" m = ConcreteModel() m.v1 = Var(initialize=1, bounds=(1, 3)) m.v2 = Var(initialize=5, bounds=(4, 8)) m.c1 = Constraint(expr=m.v1 == m.v2) xfrm = TransformationFactory('contrib.propagate_eq_var_bounds') with self.assertRaisesRegex(InfeasibleConstraintException, "Variable v2 has a lower bound 4 > the " "upper bound 3 of variable v1, but they " "are linked by equality constraints"): xfrm.apply_to(m)
def test_disc_single_index_radau(self): m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1) == 16) expected_tau_points = [ 0.0, 0.1550510257216822, 0.64494897427831788, 1.0 ] expected_disc_points = [ 0, 0.310102, 1.289898, 2.0, 2.310102, 3.289898, 4.0, 4.310102, 5.289898, 6.0, 6.310102, 7.289898, 8.0, 8.310102, 9.289898, 10 ] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-RADAU') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue(type(val) in [float, int]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m._pyomo_dae_reclassified_derivativevars[0] is m.dv1) repn_baseline = { id(m.dv1[2.0]): 1.0, id(m.v1[0]): 1.5, id(m.v1[0.310102]): -2.76599, id(m.v1[1.289898]): 3.76599, id(m.v1[2.0]): -2.5 } repn = generate_standard_repn(m.dv1_disc_eq[2.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = { id(m.dv1[4.0]): 1.0, id(m.v1[2.0]): 1.5, id(m.v1[2.310102]): -2.76599, id(m.v1[3.289898]): 3.76599, id(m.v1[4.0]): -2.5 } repn = generate_standard_repn(m.dv1_disc_eq[4.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_initialize_dyn(build_turbine_dyn): """Initialize a turbine model""" m = build_turbine_dyn hin = iapws95.htpx(T=880, P=2.4233e7) discretizer = TransformationFactory('dae.finite_difference') discretizer.apply_to(m, nfe=4, wrt=m.fs.time, scheme='BACKWARD') # fix inlet m.fs.turb.inlet.enth_mol.fix(hin) m.fs.turb.inlet.flow_mol.fix(26000 / 4.0) m.fs.turb.inlet.pressure.fix(2.4233e7) m.fs.turb.initialize()
def initialize_model(m, nfe): u_profile = {0: -0.06} m.u_input = Suffix(direction=Suffix.LOCAL) m.u_input[m.u] = u_profile sim = Simulator(m, package='scipy') tsim, profiles = sim.simulate(numpoints=100, varying_inputs=m.u_input) discretizer = TransformationFactory('dae.collocation') discretizer.apply_to(m, nfe=nfe, ncp=1, scheme='LAGRANGE-RADAU') sim.initialize_model()
def test_relax_integrality_only_active_blocks(self): self.model.x = Var(domain=NonNegativeIntegers) self.model.b = Block() self.model.b.x = Var(domain=Binary) self.model.b.y = Var(domain=Integers, bounds=(-3,2)) instance = self.model.create_instance() instance.b.deactivate() relax_integrality = TransformationFactory('core.relax_integer_vars') relax_integrality.apply_to(instance, transform_deactivated_blocks=False) self.assertIs(instance.b.x.domain, Binary) self.assertIs(instance.b.y.domain, Integers) self.assertIs(instance.x.domain, Reals) self.assertEqual(instance.x.lb, 0) self.assertIsNone(instance.x.ub)
def test_disc_single_index_legendre(self): m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3, scheme='LAGRANGE-LEGENDRE') self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(hasattr(m, 'v1_t_cont_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1_t_cont_eq) == 5) self.assertTrue(len(m.v1) == 21) expected_tau_points = [0.0, 0.11270166537925834, 0.49999999999999989, 0.88729833462074226] expected_disc_points = [0, 0.225403, 1.0, 1.774597, 2.0, 2.225403, 3.0, 3.774597, 4.0, 4.225403, 5.0, 5.774597, 6.0, 6.225403, 7.0, 7.774597, 8.0, 8.225403, 9.0, 9.774597, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-LEGENDRE') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) repn_baseline = {id(m.dv1[3.0]): 1, id(m.v1[2.0]): -1.5, id(m.v1[2.225403]): 2.86374, id(m.v1[3.0]): -1.0, id(m.v1[3.774597]): -0.36374} repn = generate_standard_repn(m.dv1_disc_eq[3.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = {id(m.dv1[5.0]): 1, id(m.v1[4.0]): -1.5, id(m.v1[4.225403]): 2.86374, id(m.v1[5.0]): -1.0, id(m.v1[5.774597]): -0.36374} repn = generate_standard_repn(m.dv1_disc_eq[5.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_strip_bounds_maps_exist(self): """Tests if component maps for reversion already exist.""" m = ConcreteModel() m.v0 = Var(bounds=(2, 4)) m.v1 = Var(domain=NonNegativeReals) m.v2 = Var(domain=PositiveReals) m.v3 = Var(bounds=(-1, 1)) m.v4 = Var(domain=Binary) m.v5 = Var(domain=Integers, bounds=(15, 16)) xfrm = TransformationFactory('contrib.strip_var_bounds') xfrm.apply_to(m, reversible=True) # At this point, component maps for reversion already exist. with self.assertRaises(RuntimeError): xfrm.apply_to(m, reversible=True)
def test_fixed_var_revert(self): """Test for reversion of fixed variables.""" m = ConcreteModel() m.v1 = Var(initialize=1) m.v2 = Var(initialize=2) m.v1.setub(2) m.v1.setlb(2) xfrm = TransformationFactory('contrib.detect_fixed_vars') xfrm.apply_to(m, tmp=True) self.assertTrue(m.v1.fixed) self.assertFalse(m.v2.fixed) xfrm.revert(m) self.assertFalse(m.v1.fixed) self.assertEqual(value(m.v1), 1)
def test_fixed_var_revert(self): """Test for reversion of fixed variables.""" m = ConcreteModel() m.v1 = Var(initialize=1) m.v2 = Var(initialize=2) m.v1.setub(2) m.v1.setlb(2) xfrm = TransformationFactory('contrib.detect_fixed_vars') xfrm.apply_to(m, tmp=True) self.assertTrue(m.v1.fixed) self.assertFalse(m.v2.fixed) xfrm.revert(m) self.assertFalse(m.v1.fixed) self.assertEqual(value(m.v1), 1)
def initialize_model(m, n_sim, n_nfe, n_ncp): vp_profile = {0: 0.75} vt_profile = {0: 0.75} m.u_input = Suffix(direction=Suffix.LOCAL) m.u_input[m.vp] = vp_profile m.u_input[m.vt] = vt_profile sim = Simulator(m, package='scipy') tsim, profiles = sim.simulate(numpoints=n_sim, varying_inputs=m.u_input) discretizer = TransformationFactory('dae.collocation') discretizer.apply_to(m, nfe=n_nfe, ncp=n_ncp, scheme='LAGRANGE-RADAU') sim.initialize_model()
def test_disc_single_index_radau(self): m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1) == 16) expected_tau_points = [0.0, 0.1550510257216822, 0.64494897427831788, 1.0] expected_disc_points = [0, 0.310102, 1.289898, 2.0, 2.310102, 3.289898, 4.0, 4.310102, 5.289898, 6.0, 6.310102, 7.289898, 8.0, 8.310102, 9.289898, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-RADAU') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m._pyomo_dae_reclassified_derivativevars[0] is m.dv1) repn_baseline = {id(m.dv1[2.0]): 1.0, id(m.v1[0]): 1.5, id(m.v1[0.310102]): -2.76599, id(m.v1[1.289898]): 3.76599, id(m.v1[2.0]): -2.5} repn = generate_standard_repn(m.dv1_disc_eq[2.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen) repn_baseline = {id(m.dv1[4.0]): 1.0, id(m.v1[2.0]): 1.5, id(m.v1[2.310102]): -2.76599, id(m.v1[3.289898]): 3.76599, id(m.v1[4.0]): -2.5} repn = generate_standard_repn(m.dv1_disc_eq[4.0].body) repn_gen = repn_to_rounded_dict(repn, 5) self.assertEqual(repn_baseline, repn_gen)
def test_lookup_legendre_collocation_points(self): # Save initial flag value colloc_numpy_avail = pyomo.dae.plugins.colloc.numpy_available # Numpy flag must be False to test lookup pyomo.dae.plugins.colloc.numpy_available = False m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3, scheme='LAGRANGE-LEGENDRE') self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1) == 21) expected_tau_points = [ 0.0, 0.11270166537925834, 0.49999999999999989, 0.88729833462074226 ] expected_disc_points = [ 0, 0.225403, 1.0, 1.774597, 2.0, 2.225403, 3.0, 3.774597, 4.0, 4.225403, 5.0, 5.774597, 6.0, 6.225403, 7.0, 7.774597, 8.0, 8.225403, 9.0, 9.774597, 10 ] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-LEGENDRE') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) m = self.m.clone() try: disc = TransformationFactory('dae.collocation') disc.apply_to(m, ncp=15, scheme='LAGRANGE-LEGENDRE') self.fail('Expected ValueError') except ValueError: pass # Restore initial flag value pyomo.dae.plugins.colloc.numpy_available = colloc_numpy_avail
def test_deactivate_trivial_constraints_revert(self): """Test for reversion of trivial constraint deactivation.""" m = ConcreteModel() m.v1 = Var(initialize=1) m.v2 = Var(initialize=2) m.v3 = Var(initialize=3) m.c = Constraint(expr=m.v1 <= m.v2) m.c2 = Constraint(expr=m.v2 >= m.v3) m.c3 = Constraint(expr=m.v1 <= 5) m.v1.fix() xfrm = TransformationFactory('contrib.deactivate_trivial_constraints') xfrm.apply_to(m, tmp=True) self.assertTrue(m.c.active) self.assertTrue(m.c2.active) self.assertFalse(m.c3.active) xfrm.revert(m) self.assertTrue(m.c3.active)
def test_disc_second_order_central(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=2, scheme='CENTRAL') self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertEqual(len(m.dv1dt2_disc_eq), 1) self.assertEqual(len(m.v1), 3) output = \ """\ dv1dt2_disc_eq : Size=1, Index=t, Active=True Key : Lower : Body : Upper : Active 5.0 : 0.0 : dv1dt2[5.0] - 0.04*(v1[10] - 2*v1[5.0] + v1[0]) : 0.0 : True """ out = StringIO() m.dv1dt2_disc_eq.pprint(ostream=out) self.assertEqual(output, out.getvalue())
def test_disc_second_order_central(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=2, scheme='CENTRAL') self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertTrue(len(m.dv1dt2_disc_eq) == 1) self.assertTrue(len(m.v1) == 3) output = \ """\ dv1dt2_disc_eq : Size=1, Index=t, Active=True Key : Lower : Body : Upper : Active 5.0 : 0.0 : dv1dt2[5.0] - 0.04*(v1[10] - 2*v1[5.0] + v1[0]) : 0.0 : True """ out = StringIO() m.dv1dt2_disc_eq.pprint(ostream=out) self.assertEqual(output, out.getvalue())
def test_lookup_radau_collocation_points(self): # Save initial flag value colloc_numpy_avail = pyomo.dae.plugins.colloc.numpy_available # Numpy flag must be False to test lookup pyomo.dae.plugins.colloc.numpy_available = False m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1) == 16) expected_tau_points = [ 0.0, 0.1550510257216822, 0.64494897427831788, 1.0 ] expected_disc_points = [ 0, 0.310102, 1.289898, 2.0, 2.310102, 3.289898, 4.0, 4.310102, 5.289898, 6.0, 6.310102, 7.289898, 8.0, 8.310102, 9.289898, 10 ] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-RADAU') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) m = self.m.clone() try: disc = TransformationFactory('dae.collocation') disc.apply_to(m, ncp=15, scheme='LAGRANGE-RADAU') self.fail('Expected ValueError') except ValueError: pass # Restore initial flag value pyomo.dae.plugins.colloc.numpy_available = colloc_numpy_avail
def test_deactivate_trivial_constraints_revert(self): """Test for reversion of trivial constraint deactivation.""" m = ConcreteModel() m.v1 = Var(initialize=1) m.v2 = Var(initialize=2) m.v3 = Var(initialize=3) m.c = Constraint(expr=m.v1 <= m.v2) m.c2 = Constraint(expr=m.v2 >= m.v3) m.c3 = Constraint(expr=m.v1 <= 5) m.v1.fix() xfrm = TransformationFactory( 'contrib.deactivate_trivial_constraints') xfrm.apply_to(m, tmp=True) self.assertTrue(m.c.active) self.assertTrue(m.c2.active) self.assertFalse(m.c3.active) xfrm.revert(m) self.assertTrue(m.c3.active)
def test_reduce_colloc_multi_index(self): m = self.m.clone() m.u = Var(m.t, m.s) m2 = m.clone() m3 = m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) disc.reduce_collocation_points(m, contset=m.t, var=m.u, ncp=1) self.assertTrue(hasattr(m, 'u_interpolation_constraints')) self.assertEqual(len(m.u_interpolation_constraints), 30) disc2 = TransformationFactory('dae.collocation') disc2.apply_to(m2, wrt=m2.t, nfe=5, ncp=3) disc2.reduce_collocation_points(m2, contset=m2.t, var=m2.u, ncp=3) self.assertFalse(hasattr(m2, 'u_interpolation_constraints')) disc3 = TransformationFactory('dae.collocation') disc3.apply_to(m3, wrt=m3.t, nfe=5, ncp=3) disc3.reduce_collocation_points(m3, contset=m3.t, var=m3.u, ncp=2) self.assertTrue(hasattr(m3, 'u_interpolation_constraints')) self.assertEqual(len(m3.u_interpolation_constraints), 15)
def test_var_fix_revert(self): """Test to make sure that variable fixing reversion works.""" 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() fvp = TransformationFactory('contrib.propagate_fixed_vars') fvp.apply_to(m, tmp=True) self.assertTrue(m.v1.fixed) self.assertTrue(m.v2.fixed) self.assertTrue(m.v3.fixed) self.assertTrue(m.v4.fixed) fvp.revert(m) self.assertFalse(m.v1.fixed) self.assertTrue(m.v2.fixed) self.assertFalse(m.v3.fixed) self.assertFalse(m.v4.fixed)
def test_lookup_radau_collocation_points(self): # Save initial flag value colloc_numpy_avail = pyomo.dae.plugins.colloc.numpy_available # Numpy flag must be False to test lookup pyomo.dae.plugins.colloc.numpy_available = False m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1) == 16) expected_tau_points = [0.0, 0.1550510257216822, 0.64494897427831788, 1.0] expected_disc_points = [0, 0.310102, 1.289898, 2.0, 2.310102, 3.289898, 4.0, 4.310102, 5.289898, 6.0, 6.310102, 7.289898, 8.0, 8.310102, 9.289898, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-RADAU') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) m = self.m.clone() with self.assertRaises(ValueError): disc = TransformationFactory('dae.collocation') disc.apply_to(m, ncp=15, scheme='LAGRANGE-RADAU') # Restore initial flag value pyomo.dae.plugins.colloc.numpy_available = colloc_numpy_avail
def test_lookup_legendre_collocation_points(self): # Save initial flag value colloc_numpy_avail = pyomo.dae.plugins.colloc.numpy_available # Numpy flag must be False to test lookup pyomo.dae.plugins.colloc.numpy_available = False m = self.m.clone() disc = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3, scheme='LAGRANGE-LEGENDRE') self.assertTrue(hasattr(m, 'dv1_disc_eq')) self.assertTrue(len(m.dv1_disc_eq) == 15) self.assertTrue(len(m.v1) == 21) expected_tau_points = [0.0, 0.11270166537925834, 0.49999999999999989, 0.88729833462074226] expected_disc_points = [0, 0.225403, 1.0, 1.774597, 2.0, 2.225403, 3.0, 3.774597, 4.0, 4.225403, 5.0, 5.774597, 6.0, 6.225403, 7.0, 7.774597, 8.0, 8.225403, 9.0, 9.774597, 10] disc_info = m.t.get_discretization_info() self.assertTrue(disc_info['scheme'] == 'LAGRANGE-LEGENDRE') for idx, val in enumerate(disc_info['tau_points']): self.assertAlmostEqual(val, expected_tau_points[idx]) for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_disc_points[idx]) m = self.m.clone() with self.assertRaises(ValueError): disc = TransformationFactory('dae.collocation') disc.apply_to(m, ncp=15, scheme='LAGRANGE-LEGENDRE') # Restore initial flag value pyomo.dae.plugins.colloc.numpy_available = colloc_numpy_avail
def test_disc_second_order_backward(self): m = self.m.clone() m.dv1dt2 = DerivativeVar(m.v1, wrt=(m.t, m.t)) disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=2) self.assertTrue(hasattr(m, 'dv1dt2_disc_eq')) self.assertTrue(len(m.dv1dt2_disc_eq) == 1) self.assertTrue(len(m.v1) == 3) self.assertTrue(hasattr(m, '_pyomo_dae_reclassified_derivativevars')) self.assertTrue(m.dv1 in m._pyomo_dae_reclassified_derivativevars) self.assertTrue(m.dv1dt2 in m._pyomo_dae_reclassified_derivativevars) output = \ """\ dv1dt2_disc_eq : Size=1, Index=t, Active=True Key : Lower : Body : Upper : Active 10 : 0.0 : dv1dt2[10] - 0.04*(v1[10] - 2*v1[5.0] + v1[0]) : 0.0 : True """ out = StringIO() m.dv1dt2_disc_eq.pprint(ostream=out) self.assertEqual(output, out.getvalue())
def test_disc_multi_index2(self): m = self.m.clone() m.t2 = ContinuousSet(bounds=(0, 5)) m.v2 = Var(m.t, m.t2) m.dv2dt = DerivativeVar(m.v2, wrt=m.t) m.dv2dt2 = DerivativeVar(m.v2, wrt=m.t2) disc = TransformationFactory('dae.finite_difference') disc.apply_to(m, nfe=2) self.assertTrue(hasattr(m, 'dv2dt_disc_eq')) self.assertTrue(hasattr(m, 'dv2dt2_disc_eq')) self.assertTrue(len(m.dv2dt_disc_eq) == 6) self.assertTrue(len(m.dv2dt2_disc_eq) == 6) self.assertTrue(len(m.v2) == 9) expected_t_disc_points = [0, 5.0, 10] expected_t2_disc_points = [0, 2.5, 5] for idx, val in enumerate(list(m.t)): self.assertAlmostEqual(val, expected_t_disc_points[idx]) for idx, val in enumerate(list(m.t2)): self.assertAlmostEqual(val, expected_t2_disc_points[idx])
def test_reduce_colloc_invalid(self): m = self.m.clone() m.u = Var(m.t) m2 = m.clone() disc = TransformationFactory('dae.collocation') disc2 = TransformationFactory('dae.collocation') disc.apply_to(m, nfe=5, ncp=3) # No ContinuousSet specified with self.assertRaises(TypeError): disc.reduce_collocation_points(m, contset=None) # Component passed in is not a ContinuousSet with self.assertRaises(TypeError): disc.reduce_collocation_points(m, contset=m.s) # Call reduce_collocation_points method before applying discretization with self.assertRaises(RuntimeError): disc2.reduce_collocation_points(m2, contset=m2.t) # Call reduce_collocation_points on a ContinuousSet that hasn't been # discretized m2.tt = ContinuousSet(bounds=(0, 1)) disc2.apply_to(m2, wrt=m2.t) with self.assertRaises(ValueError): disc2.reduce_collocation_points(m2, contset=m2.tt) # No Var specified with self.assertRaises(TypeError): disc.reduce_collocation_points(m, contset=m.t, var=None) # Component passed in is not a Var with self.assertRaises(TypeError): disc.reduce_collocation_points(m, contset=m.t, var=m.s) # New ncp not specified with self.assertRaises(TypeError): disc.reduce_collocation_points(m, contset=m.t, var=m.v1, ncp=None) # Negative ncp specified with self.assertRaises(ValueError): disc.reduce_collocation_points(m, contset=m.t, var=m.v1, ncp=-3) # Too large ncp specified with self.assertRaises(ValueError): disc.reduce_collocation_points(m, contset=m.t, var=m.v1, ncp=10) # Passing Vars not indexed by the ContinuousSet m.v2 = Var() m.v3 = Var(m.s) m.v4 = Var(m.s, m.s) with self.assertRaises(IndexError): disc.reduce_collocation_points(m, contset=m.t, var=m.v2, ncp=1) with self.assertRaises(IndexError): disc.reduce_collocation_points(m, contset=m.t, var=m.v3, ncp=1) with self.assertRaises(IndexError): disc.reduce_collocation_points(m, contset=m.t, var=m.v4, ncp=1) # Calling reduce_collocation_points more than once disc.reduce_collocation_points(m, contset=m.t, var=m.u, ncp=1) with self.assertRaises(RuntimeError): disc.reduce_collocation_points(m, contset=m.t, var=m.u, ncp=1)