def test_unconnected_param_access_with_promotes(self): prob = Problem(root=Group()) G1 = prob.root.add('G1', Group()) G2 = G1.add('G2', Group(), promotes=['x']) C1 = G2.add('C1', ExecComp(['y=2.0*x', 'z=x*x-2.0']), promotes=['x']) C2 = G2.add('C2', ExecComp(['y=2.0*x', 'z=x*x-2.0'])) G2.connect('C1.y', 'C2.x') # ignore warning about the unconnected param with warnings.catch_warnings(record=True) as w: warnings.simplefilter("ignore") prob.setup(check=False) prob.run() # still must use absolute naming to find params even if they're # promoted. Promoted names for params can refer to more than one param. C1.params['x'] = 2. self.assertEqual(prob['G1.x'], 2.0) self.assertEqual(prob.root.G1.G2.C1.params['x'], 2.0) prob['G1.x'] = 99. self.assertEqual(C1.params['x'], 99.) prob['G1.x'] = 12. self.assertEqual(C1.params['x'], 12.) prob['G1.x'] = 17. self.assertEqual(prob.root.G1.G2.C1.params['x'], 17.0) prob.run()
def test_simple_paraboloid_equality(self): prob = Problem() root = prob.root = Group() root.add("p1", ParamComp("x", 50.0), promotes=["*"]) root.add("p2", ParamComp("y", 50.0), promotes=["*"]) root.add("comp", Paraboloid(), promotes=["*"]) root.add("con", ExecComp("c = 15.0 - x + y"), promotes=["*"]) prob.driver = ScipyOptimizer() prob.driver.options["optimizer"] = "SLSQP" prob.driver.options["tol"] = 1.0e-8 prob.driver.add_param("x", low=-50.0, high=50.0) prob.driver.add_param("y", low=-50.0, high=50.0) prob.driver.add_objective("f_xy") prob.driver.add_constraint("c", ctype="ineq") prob.setup(check=False) prob.run() # Minimum should be at (7.166667, -7.833334) assert_rel_error(self, prob["x"], 7.16667, 1e-6) assert_rel_error(self, prob["y"], -7.833334, 1e-6)
def test_fd_skip_keys(self): prob = Problem() root = prob.root = Group() comp = Component() comp.add_param('x', 0.) comp.add_param('y', 0.) comp.add_output('z', 0.) comp.solve_nonlinear = lambda p, u, r: u.__setitem__('z', 1.) comp._get_fd_params = lambda: ['x'] comp.jacobian = lambda a,b,c: {('z', 'x'): 0.} root.add('comp', comp, promotes=['x', 'y']) root.add('px', ParamComp('x', 0.), promotes=['*']) root.add('py', ParamComp('y', 0.), promotes=['*']) prob.setup(check=False) prob.run() try: prob.check_partial_derivatives() except KeyError as err: self.fail('KeyError raised: {0}'.format(str(err)))
def test_fd_skip_keys(self): prob = Problem() root = prob.root = Group() comp = Component() comp.add_param('x', 0.) comp.add_param('y', 0.) comp.add_output('z', 0.) comp.solve_nonlinear = lambda p, u, r: u.__setitem__('z', 1.) comp._get_fd_params = lambda: ['x'] comp.jacobian = lambda a, b, c: {('z', 'x'): 0.} root.add('comp', comp, promotes=['x', 'y']) root.add('px', ParamComp('x', 0.), promotes=['*']) root.add('py', ParamComp('y', 0.), promotes=['*']) prob.setup(check=False) prob.run() try: prob.check_partial_derivatives(out_stream=None) except KeyError as err: self.fail('KeyError raised: {0}'.format(str(err)))
def test_byobj_run(self): prob = Problem(root=ExampleByObjGroup()) prob.setup(check=False) prob.run() self.assertEqual(prob['G3.C4.y'], 'fooC2C3C4')
def test_bad_size(self): class BadComp(SimpleArrayComp): def jacobian(self, params, unknowns, resids): """Analytical derivatives""" J = {} J[('y', 'x')] = np.zeros((3, 3)) return J prob = Problem() prob.root = Group() prob.root.add('comp', BadComp()) prob.root.add('p1', ParamComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() try: data = prob.check_partial_derivatives(out_stream=None) except Exception as err: msg = "Jacobian in component 'comp' between the" + \ " variables 'x' and 'y' is the wrong size. " + \ "It should be 2 by 2" self.assertEqual(str(err), msg) else: self.fail("Error expected")
def test_simple_matvec(self): class VerificationComp(SimpleCompDerivMatVec): def jacobian(self, params, unknowns, resids): raise RuntimeError( "Derivative functions on this comp should not run.") def apply_linear(self, params, unknowns, dparams, dunknowns, dresids, mode): raise RuntimeError( "Derivative functions on this comp should not run.") sub = Group() sub.add('mycomp', VerificationComp()) prob = Problem() prob.root = Group() prob.root.add('sub', sub) prob.root.add('x_param', ParamComp('x', 1.0)) prob.root.connect('x_param.x', "sub.mycomp.x") sub.fd_options['force_fd'] = True prob.setup(check=False) prob.run() J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'], mode='fwd', return_format='dict') assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'], mode='rev', return_format='dict') assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6)
def test_simple_paraboloid_equality(self): prob = Problem() root = prob.root = Group() root.add('p1', ParamComp('x', 50.0), promotes=['*']) root.add('p2', ParamComp('y', 50.0), promotes=['*']) root.add('comp', Paraboloid(), promotes=['*']) root.add('con', ExecComp('c = 15.0 - x + y'), promotes=['*']) prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.add_param('x', low=-50.0, high=50.0) prob.driver.add_param('y', low=-50.0, high=50.0) prob.driver.add_objective('f_xy') prob.driver.add_constraint('c', ctype='ineq') prob.driver.options['disp'] = False prob.setup(check=False) prob.run() # Minimum should be at (7.166667, -7.833334) assert_rel_error(self, prob['x'], 7.16667, 1e-6) assert_rel_error(self, prob['y'], -7.833334, 1e-6)
def test_simple_array_comp2D(self): prob = Problem() root = prob.root = Group() root.add('p1', ParamComp('x', np.zeros((2, 2))), promotes=['*']) root.add('comp', ArrayComp2D(), promotes=['*']) root.add('con', ExecComp('c = y - 20.0', c=np.zeros((2, 2)), y=np.zeros((2, 2))), promotes=['*']) root.add('obj', ExecComp('o = y[0, 0]', y=np.zeros((2, 2))), promotes=['*']) prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.add_param('x', low=-50.0, high=50.0) prob.driver.add_objective('o') prob.driver.add_constraint('c', ctype='eq') prob.driver.options['disp'] = False prob.setup(check=False) prob.run() obj = prob['o'] assert_rel_error(self, obj, 20.0, 1e-6)
def test_parallel_diamond(self): size = 3 prob = Problem(Group(), impl=impl) root = prob.root root.add('P1', ParamComp('x', np.ones(size, float) * 1.1)) G1 = root.add('G1', ParallelGroup()) G1.add('C1', ABCDArrayComp(size)) G1.add('C2', ABCDArrayComp(size)) root.add('C3', ABCDArrayComp(size)) root.connect('P1.x', 'G1.C1.a') root.connect('P1.x', 'G1.C2.b') root.connect('G1.C1.c', 'C3.a') root.connect('G1.C2.d', 'C3.b') prob.setup(check=False) prob.run() if not MPI or self.comm.rank == 0: assert_rel_error(self, prob.root.G1.C1.unknowns['c'], np.ones(size) * 2.1, 1.e-10) assert_rel_error(self, prob.root.G1.C1.unknowns['d'], np.ones(size) * .1, 1.e-10) assert_rel_error(self, prob.root.C3.params['a'], np.ones(size) * 2.1, 1.e-10) assert_rel_error(self, prob.root.C3.params['b'], np.ones(size) * -.1, 1.e-10) if not MPI or self.comm.rank == 1: assert_rel_error(self, prob.root.G1.C2.unknowns['c'], np.ones(size) * 2.1, 1.e-10) assert_rel_error(self, prob.root.G1.C2.unknowns['d'], np.ones(size) * -.1, 1.e-10)
def test_simple(self): prob = Problem(Group(), impl=impl) size = 5 A1 = prob.root.add('A1', ParamComp('a', np.zeros(size, float))) B1 = prob.root.add('B1', ParamComp('b', np.zeros(size, float))) B2 = prob.root.add('B2', ParamComp('b', np.zeros(size, float))) S1 = prob.root.add('S1', ParamComp('s', '')) L1 = prob.root.add('L1', ParamComp('l', [])) C1 = prob.root.add('C1', ABCDArrayComp(size)) C2 = prob.root.add('C2', ABCDArrayComp(size)) prob.root.connect('A1.a', 'C1.a') prob.root.connect('B1.b', 'C1.b') # prob.root.connect('S1:s', 'C1.in_string') # prob.root.connect('L1:l', 'C1.in_list') prob.root.connect('C1.c', 'C2.a') prob.root.connect('B2.b', 'C2.b') # prob.root.connect('C1.out_string', 'C2.in_string') # prob.root.connect('C1.out_list', 'C2.in_list') prob.setup(check=False) prob['A1.a'] = np.ones(size, float) * 3.0 prob['B1.b'] = np.ones(size, float) * 7.0 prob['B2.b'] = np.ones(size, float) * 5.0 prob.run() self.assertTrue(all(prob['C2.a'] == np.ones(size, float) * 10.)) self.assertTrue(all(prob['C2.b'] == np.ones(size, float) * 5.)) self.assertTrue(all(prob['C2.c'] == np.ones(size, float) * 15.)) self.assertTrue(all(prob['C2.d'] == np.ones(size, float) * 5.))
def test_single_diamond_grouped(self): prob = Problem() prob.root = SingleDiamondGrouped() prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() param_list = ['p.x'] unknown_list = ['comp4.y1', 'comp4.y2'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp4.y1']['p.x'][0][0], 25, 1e-6) assert_rel_error(self, J['comp4.y2']['p.x'][0][0], -40.5, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['comp4.y1']['p.x'][0][0], 25, 1e-6) assert_rel_error(self, J['comp4.y2']['p.x'][0][0], -40.5, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict') assert_rel_error(self, J['comp4.y1']['p.x'][0][0], 25, 1e-6) assert_rel_error(self, J['comp4.y2']['p.x'][0][0], -40.5, 1e-6)
def test_record_derivs_dicts(self): if OPT is None: raise unittest.SkipTest("pyoptsparse is not installed") if OPTIMIZER is None: raise unittest.SkipTest( "pyoptsparse is not providing SNOPT or SLSQP") prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = pyOptSparseDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.opt_settings['ACC'] = 1e-9 prob.driver.options['print_results'] = False prob.driver.add_desvar('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar('x', lower=0.0, upper=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False self.recorder.options['record_derivs'] = True prob.setup(check=False) prob.run() prob.cleanup() hdf = h5py.File(self.filename, 'r') deriv_group = hdf['rank0:SLSQP|1']['Derivs'] self.assertEqual(deriv_group.attrs['success'], 1) self.assertEqual(deriv_group.attrs['msg'], '') J1 = deriv_group['Derivatives'] Jbase = {} Jbase['con1'] = {} Jbase['con1']['x'] = -0.98061433 Jbase['con1']['z'] = np.array([-9.61002285, -0.78449158]) Jbase['con2'] = {} Jbase['con2']['x'] = 0.09692762 Jbase['con2']['z'] = np.array([1.94989079, 1.0775421]) Jbase['obj'] = {} Jbase['obj']['x'] = 2.98061392 Jbase['obj']['z'] = np.array([9.61001155, 1.78448534]) for key1, val1 in Jbase.items(): for key2, val2 in val1.items(): assert_rel_error(self, J1[key1][key2][:], val2, .00001) hdf.close()
def test_converge_diverge_groups(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() # Make sure value is fine. assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6) param_list = ['p.x'] unknown_list = ['comp7.y1'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict') assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6)
def test_fan_in_grouped(self): prob = Problem() prob.root = FanInGrouped() prob.root.ln_solver = ScipyGMRES() param_list = ['p1.x1', 'p2.x2'] unknown_list = ['comp3.y'] prob.setup(check=False) prob.run() J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
def test_double_arraycomp(self): # Mainly testing a bug in the array return for multiple arrays group = Group() group.add('x_param1', ParamComp('x1', np.ones((2))), promotes=['*']) group.add('x_param2', ParamComp('x2', np.ones((2))), promotes=['*']) group.add('mycomp', DoubleArrayComp(), promotes=['*']) prob = Problem() prob.root = group prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() Jbase = group.mycomp.JJ J = prob.calc_gradient(['x1', 'x2'], ['y1', 'y2'], mode='fwd', return_format='array') diff = np.linalg.norm(J - Jbase) assert_rel_error(self, diff, 0.0, 1e-8) J = prob.calc_gradient(['x1', 'x2'], ['y1', 'y2'], mode='fd', return_format='array') diff = np.linalg.norm(J - Jbase) assert_rel_error(self, diff, 0.0, 1e-8) J = prob.calc_gradient(['x1', 'x2'], ['y1', 'y2'], mode='rev', return_format='array') diff = np.linalg.norm(J - Jbase) assert_rel_error(self, diff, 0.0, 1e-8)
def test_Sellar_state_SLSQP(self): prob = Problem() prob.root = SellarStateConnection() prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.add_param('z', low=np.array([-10.0, 0.0]), high=np.array([10.0, 10.0])) prob.driver.add_param('x', low=0.0, high=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1') prob.driver.add_constraint('con2') prob.driver.options['disp'] = False prob.setup(check=False) prob.run() assert_rel_error(self, prob['z'][0], 1.9776, 1e-3) assert_rel_error(self, prob['z'][1], 0.0, 1e-3) assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_simple_matvec(self): class VerificationComp(SimpleCompDerivMatVec): def jacobian(self, params, unknowns, resids): raise RuntimeError("Derivative functions on this comp should not run.") def apply_linear(self, params, unknowns, dparams, dunknowns, dresids, mode): raise RuntimeError("Derivative functions on this comp should not run.") sub = Group() sub.add('mycomp', VerificationComp()) prob = Problem() prob.root = Group() prob.root.add('sub', sub) prob.root.add('x_param', IndepVarComp('x', 1.0)) prob.root.connect('x_param.x', "sub.mycomp.x") sub.fd_options['force_fd'] = True prob.setup(check=False) prob.run() J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'], mode='fwd', return_format='dict') assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'], mode='rev', return_format='dict') assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6)
def test_read3(self): # Parse a single group in a deck with non-unique group names namelist1 = "Testing\n" + \ "$GROUP\n" + \ " intvar = 99\n" + \ "$END\n" + \ "$GROUP\n" + \ " floatvar = 3.5e-23\n" + \ "$END\n" outfile = open(self.filename, 'w') outfile.write(namelist1) outfile.close() top = Problem() top.root = Group() top.root.add('my_comp', VarComponent()) top.setup(check=False) top.run() sb = Namelist(top.root.my_comp) sb.set_filename(self.filename) sb.parse_file() sb.load_model(single_group=1) # Unchanged self.assertEqual(top['my_comp.intvar'], 333) # Changed self.assertEqual(top['my_comp.floatvar'], 3.5e-23)
def test_inp_inp_promoted_w_explicit_src(self): p = Problem(root=Group()) root = p.root G1 = root.add("G1", Group()) G2 = G1.add("G2", Group(), promotes=['x']) C1 = G2.add("C1", ExecComp('y=x*2.0')) C2 = G2.add("C2", ParamComp('x', 1.0), promotes=['x']) G3 = root.add("G3", Group()) G4 = G3.add("G4", Group(), promotes=['x']) C3 = G4.add("C3", ExecComp('y=x*2.0'), promotes=['x']) C4 = G4.add("C4", ExecComp('y=x*2.0'), promotes=['x']) p.root.connect('G1.x', 'G3.x') p.setup(check=False) self.assertEqual(p._dangling['G1.G2.C1.x'], set(['G1.G2.C1.x'])) self.assertEqual(len(p._dangling), 1) # setting promoted name will set the value into the unknowns, but will # not propagate it to the params. That will happen during run(). p['G1.x'] = 999. self.assertEqual(p.root.G3.G4.C3.params['x'], 0.) self.assertEqual(p.root.G3.G4.C4.params['x'], 0.) p.run() self.assertEqual(p.root.G3.G4.C3.params['x'], 999.) self.assertEqual(p.root.G3.G4.C4.params['x'], 999.)
def test_noncontiguous_idxs(self): # take even input indices in 0 rank and odd ones in 1 rank size = 11 p = Problem(root=Group(), impl=impl) top = p.root top.add("C1", InOutArrayComp(size)) top.add("C2", DistribNoncontiguousComp(size)) top.add("C3", DistribGatherComp(size)) top.connect('C1.outvec', 'C2.invec') top.connect('C2.outvec', 'C3.invec') p.setup(check=False) top.C1.params['invec'] = np.array(range(size), float) p.run() if MPI: if self.comm.rank == 0: self.assertTrue(all(top.C2.unknowns['outvec'] == np.array(list(take_nth(0, 2, range(size))), 'f')*4)) else: self.assertTrue(all(top.C2.unknowns['outvec'] == np.array(list(take_nth(1, 2, range(size))), 'f')*4)) full_list = list(take_nth(0, 2, range(size))) + list(take_nth(1, 2, range(size))) self.assertTrue(all(top.C3.unknowns['outvec'] == np.array(full_list, 'f')*4)) else: self.assertTrue(all(top.C2.unknowns['outvec']==top.C1.unknowns['outvec']*2.)) self.assertTrue(all(top.C3.unknowns['outvec']==top.C2.unknowns['outvec']))
def test_driver_param_indices_snopt(self): """ Test driver param indices with pyOptSparse and force_fd=False """ prob = Problem() prob.root = SellarStateConnection() prob.root.fd_options['force_fd'] = False prob.driver = pyOptSparseDriver() prob.driver.add_desvar('z', low=np.array([-10.0]), high=np.array([10.0]),indices=[0]) prob.driver.add_desvar('x', low=0.0, high=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.setup(check=False) prob['z'][1] = 0.0 prob.run() assert_rel_error(self, prob['z'][0], 1.9776, 1e-3) assert_rel_error(self, prob['z'][1], 0.0, 1e-3) assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_Sellar_state_SLSQP(self): """ Baseline Sellar test case without specifying indices. """ prob = Problem() prob.root = SellarStateConnection() prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.add_desvar('z', low=np.array([-10.0, 0.0]), high=np.array([10.0, 10.0])) prob.driver.add_desvar('x', low=0.0, high=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.options['disp'] = False prob.setup(check=False) prob.run() assert_rel_error(self, prob['z'][0], 1.9776, 1e-3) assert_rel_error(self, prob['z'][1], 0.0, 1e-3) assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_calc_gradient_multiple_params(self): prob = Problem() prob.root = FanIn() prob.setup(check=False) prob.run() param_list = ['p1.x1', 'p2.x2'] unknown_list = ['comp3.y'] # check that calc_gradient returns proper dict value when mode is 'fwd' J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[ 35.]])) np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[ -6.]])) # check that calc_gradient returns proper array value when mode is 'fwd' J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='array') np.testing.assert_almost_equal(J, np.array([[-6., 35.]])) # check that calc_gradient returns proper dict value when mode is 'rev' J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[ 35.]])) np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[ -6.]])) # check that calc_gradient returns proper array value when mode is 'rev' J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='array') np.testing.assert_almost_equal(J, np.array([[-6., 35.]])) # check that calc_gradient returns proper dict value when mode is 'fd' J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict') np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[ 35.]])) np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[ -6.]])) # check that calc_gradient returns proper array value when mode is 'fd' J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='array') np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
def test_fan_out_serial_sets(self): prob = Problem(impl=impl) prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # Parallel Groups prob.driver.add_desvar('p.x') prob.driver.add_constraint('c2.y', upper=0.0) prob.driver.add_constraint('c3.y', upper=0.0) prob.setup(check=False) prob.run() unknown_list = ['c2.y', 'c3.y'] indep_list = ['p.x'] J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6) J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
def test_fan_out_parallel_sets(self): prob = Problem(impl=impl) prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # need to set mode to rev before setup. Otherwise the sub-vectors # for the parallel set vars won't get allocated. prob.root.ln_solver.options["mode"] = "rev" prob.root.sub.ln_solver.options["mode"] = "rev" # Parallel Groups prob.driver.add_param("p.x") prob.driver.add_constraint("c2.y") prob.driver.add_constraint("c3.y") prob.driver.parallel_derivs(["c2.y", "c3.y"]) self.assertEqual(prob.driver.outputs_of_interest(), [("c2.y", "c3.y")]) prob.setup(check=False) prob.run() unknown_list = ["c2.y", "c3.y"] param_list = ["p.x"] J = prob.calc_gradient(param_list, unknown_list, mode="rev", return_format="dict") assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6) assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode="fwd", return_format="dict") assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6) assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6)
def test_full_model_fd_double_diamond_grouped(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.setup(check=False) prob.run() prob.root.fd_options['force_fd'] = True param_list = ['sub1.comp1.x1'] unknown_list = ['comp7.y1'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp7.y1']['sub1.comp1.x1'][0][0], -40.75, 1e-6) prob.root.fd_options['form'] = 'central' J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp7.y1']['sub1.comp1.x1'][0][0], -40.75, 1e-6)
def test_simple(self): prob = Problem(Group(), impl=impl) size = 5 A1 = prob.root.add('A1', ParamComp('a', np.zeros(size, float))) B1 = prob.root.add('B1', ParamComp('b', np.zeros(size, float))) B2 = prob.root.add('B2', ParamComp('b', np.zeros(size, float))) S1 = prob.root.add('S1', ParamComp('s', '')) L1 = prob.root.add('L1', ParamComp('l', [])) C1 = prob.root.add('C1', ABCDArrayComp(size)) C2 = prob.root.add('C2', ABCDArrayComp(size)) prob.root.connect('A1.a', 'C1.a') prob.root.connect('B1.b', 'C1.b') # prob.root.connect('S1:s', 'C1.in_string') # prob.root.connect('L1:l', 'C1.in_list') prob.root.connect('C1.c', 'C2.a') prob.root.connect('B2.b', 'C2.b') # prob.root.connect('C1.out_string', 'C2.in_string') # prob.root.connect('C1.out_list', 'C2.in_list') prob.setup(check=False) prob['A1.a'] = np.ones(size, float) * 3.0 prob['B1.b'] = np.ones(size, float) * 7.0 prob['B2.b'] = np.ones(size, float) * 5.0 prob.run() self.assertTrue(all(prob['C2.a']==np.ones(size, float)*10.)) self.assertTrue(all(prob['C2.b']==np.ones(size, float)*5.)) self.assertTrue(all(prob['C2.c']==np.ones(size, float)*15.)) self.assertTrue(all(prob['C2.d']==np.ones(size, float)*5.))
def test_parallel_diamond(self): size = 3 prob = Problem(Group(), impl=impl) root = prob.root root.add('P1', ParamComp('x', np.ones(size, float) * 1.1)) G1 = root.add('G1', ParallelGroup()) G1.add('C1', ABCDArrayComp(size)) G1.add('C2', ABCDArrayComp(size)) root.add('C3', ABCDArrayComp(size)) root.connect('P1.x', 'G1.C1.a') root.connect('P1.x', 'G1.C2.b') root.connect('G1.C1.c', 'C3.a') root.connect('G1.C2.d', 'C3.b') prob.setup(check=False) prob.run() if not MPI or self.comm.rank == 0: assert_rel_error(self, prob.root.G1.C1.unknowns['c'], np.ones(size)*2.1, 1.e-10) assert_rel_error(self, prob.root.G1.C1.unknowns['d'], np.ones(size)*.1, 1.e-10) assert_rel_error(self, prob.root.C3.params['a'], np.ones(size)*2.1, 1.e-10) assert_rel_error(self, prob.root.C3.params['b'], np.ones(size)*-.1, 1.e-10) if not MPI or self.comm.rank == 1: assert_rel_error(self, prob.root.G1.C2.unknowns['c'], np.ones(size)*2.1, 1.e-10) assert_rel_error(self, prob.root.G1.C2.unknowns['d'], np.ones(size)*-.1, 1.e-10)
def test_fan_out_serial_sets(self): prob = Problem(impl=impl) prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # Parallel Groups prob.driver.add_param('p.x') prob.driver.add_constraint('c2.y') prob.driver.add_constraint('c3.y') prob.setup(check=False) prob.run() unknown_list = ['c2.y', 'c3.y'] param_list = ['p.x'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
def test_2Darray_write(self): top = Problem() top.root = Group() top.root.add('my_comp', VarComponent()) top.setup(check=False) top.run() sb = Namelist(top.root.my_comp) top['my_comp.arrayvar'] = zeros([3, 2], dtype=numpy_float32) top['my_comp.arrayvar'][0, 1] = 3.7 top['my_comp.arrayvar'][2, 0] = 7.88 sb.set_filename(self.filename) sb.add_group('Test') sb.add_var("arrayvar") sb.generate() f = open(self.filename, 'r') contents = f.read() compare = "\n" + \ "&Test\n" + \ " arrayvar(1,1) = 0.0, 3.700000047683716, \n" + \ "arrayvar(1,2) = 0.0, 0.0, \n" + \ "arrayvar(1,3) = 7.880000114440918, 0.0, \n" + \ "/\n" self.assertEqual(contents, compare)
def test_fan_in_serial_sets(self): prob = Problem(impl=impl) prob.root = FanInGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # Parallel Groups prob.driver.add_param("p1.x1") prob.driver.add_param("p2.x2") prob.driver.add_objective("comp3.y") prob.setup(check=False) prob.run() param_list = ["p1.x1", "p2.x2"] unknown_list = ["comp3.y"] J = prob.calc_gradient(param_list, unknown_list, mode="rev", return_format="dict") assert_rel_error(self, J["comp3.y"]["p1.x1"][0][0], -6.0, 1e-6) assert_rel_error(self, J["comp3.y"]["p2.x2"][0][0], 35.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode="fwd", return_format="dict") assert_rel_error(self, J["comp3.y"]["p1.x1"][0][0], -6.0, 1e-6) assert_rel_error(self, J["comp3.y"]["p2.x2"][0][0], 35.0, 1e-6)
def test_index_error_messages_con(self): prob = Problem() prob.root = Group() prob.root.fd_options['force_fd'] = True prob.root.ln_solver.options['mode'] = 'auto' prob.root.add('myparams', IndepVarComp('x', np.zeros(4))) prob.root.add('rosen', Rosenbrock(4)) prob.root.connect('myparams.x', 'rosen.x') prob.driver = MySimpleDriver() prob.driver.add_desvar('myparams.x') prob.driver.add_constraint('rosen.xxx', upper=0.0, indices=[4]) prob.setup(check=False) # Make sure we can't do this with self.assertRaises(IndexError) as cm: prob.run() msg = "Index for constraint 'rosen.xxx' is out of bounds. " msg += "Requested index: [4], " msg += "shape: (4,)." raised_error = str(cm.exception) raised_error = raised_error.replace('(4L,', '(4,') self.assertEqual(msg, raised_error)
def test_fan_out_serial_sets(self): prob = Problem(impl=impl) prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # Parallel Groups prob.driver.add_param("p.x") prob.driver.add_constraint("c2.y") prob.driver.add_constraint("c3.y") prob.setup(check=False) prob.run() unknown_list = ["c2.y", "c3.y"] param_list = ["p.x"] J = prob.calc_gradient(param_list, unknown_list, mode="fwd", return_format="dict") assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6) assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode="rev", return_format="dict") assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6) assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6)
def test_fan_in_serial_sets(self): prob = Problem(impl=impl) prob.root = FanInGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # Parallel Groups prob.driver.add_param('p1.x1') prob.driver.add_param('p2.x2') prob.driver.add_objective('comp3.y') prob.setup(check=False) prob.run() param_list = ['p1.x1', 'p2.x2'] unknown_list = ['comp3.y'] J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
def test_converge_diverge_groups(self): prob = Problem() prob.root = Group() prob.root.add('sub', ConvergeDivergeGroups()) param_list = ['sub.p.x'] unknown_list = ['sub.comp7.y1'] prob.setup(check=False) prob.run() J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['sub.comp7.y1']['sub.p.x'][0][0], -40.75, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['sub.comp7.y1']['sub.p.x'][0][0], -40.75, 1e-6)
def test_includes_and_excludes(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['includes'] = ['comp1.*'] self.recorder.options['excludes'] = ["*.y2"] prob.setup(check=False) prob.run() expected_params = [ ("comp1.x1", 2.0) ] expected_unknowns = [ ("comp1.y1", 8.0) ] expected_resids = [ ("comp1.y1", 0.0) ] expected = (expected_params, expected_unknowns, expected_resids) self.assertDatasetEquals( [(['Driver', (1,)], expected)], self.eps )
def test_basic_run(self): prob = Problem(root=ExampleGroup()) prob.setup(check=False) prob.run() self.assertAlmostEqual(prob['G3.C4.y'], 40.)
def test_driver_param_indices_snopt_force_fd_shift(self): """ Testt driver param indices with pyOptSparse and force_fd=True """ prob = Problem() prob.root = SellarStateConnection() prob.root.fd_options['force_fd'] = True prob.driver.add_desvar('z', low=np.array([-10.0, -10.0]), high=np.array([10.0, 10.0]), indices=[1]) prob.driver.add_desvar('x', low=0.0, high=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) #prob.driver.options['disp'] = False prob.setup(check=False) prob['z'][1] = 0.0 prob.run() J = prob.calc_gradient(['x', 'z'], ['obj'], mode='fd', return_format='array') assert_rel_error(self, J[0][1], 1.78402, 1e-3)
def test_mode_auto(self): # Make sure mode=auto chooses correctly for all prob sizes as well # as for abs/rel/etc paths prob = Problem() root = prob.root = Group() root.add('p1', ParamComp('a', 1.0), promotes=['*']) root.add('p2', ParamComp('b', 1.0), promotes=['*']) root.add('comp', ExecComp(['x = 2.0*a + 3.0*b', 'y=4.0*a - 1.0*b']), promotes=['*']) root.ln_solver.options['mode'] = 'auto' prob.setup(check=False) prob.run() mode = prob._mode('auto', ['a'], ['x']) self.assertEqual(mode, 'fwd') mode = prob._mode('auto', ['a', 'b'], ['x']) self.assertEqual(mode, 'rev') # make sure _check function does it too #try: #mode = prob._check_for_matrix_matrix(['a'], ['x']) #except Exception as err: #msg = "Group '' must have the same mode as root to use Matrix Matrix." #self.assertEqual(text_type(err), msg) #else: #self.fail('Exception expected') root.ln_solver.options['mode'] = 'fwd' mode = prob._check_for_matrix_matrix(['a', 'b'], ['x']) self.assertEqual(mode, 'fwd')
def test_driver_param_indices_slsqp_force_fd(self): """ Test driver param indices with ScipyOptimizer SLSQP and force_fd=True """ prob = Problem() prob.root = SellarStateConnection() prob.root.fd_options['force_fd'] = True prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.add_desvar('z', low=np.array([-10.0]), high=np.array([10.0]),indices=[0]) prob.driver.add_desvar('x', low=0.0, high=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) #prob.driver.options['disp'] = False prob.setup(check=False) prob['z'][1] = 0.0 prob.run() assert_rel_error(self, prob['z'][0], 1.9776, 1e-3) assert_rel_error(self, prob['z'][1], 0.0, 1e-3) assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_index_error_messages_con(self): prob = Problem() prob.root = Group() prob.root.fd_options['force_fd'] = True prob.root.ln_solver.options['mode'] = 'auto' prob.root.add('myparams', ParamComp('x', np.zeros(4))) prob.root.add('rosen', Rosenbrock(4)) prob.root.connect('myparams.x', 'rosen.x') prob.driver = MySimpleDriver() prob.driver.add_param('myparams.x') prob.driver.add_constraint('rosen.xxx', indices=[4]) prob.setup(check=False) # Make sure we can't do this with self.assertRaises(IndexError) as cm: prob.run() msg = "Index for constraint 'rosen.xxx' is out of bounds. " msg += "Requested index: [4], " msg += "Parameter shape: (4,)." raised_error = str(cm.exception) raised_error = raised_error.replace('(4L,', '(4,') self.assertEqual(msg, raised_error)
def test_array2D_index_connection(self): group = Group() group.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*']) sub = group.add('sub', Group(), promotes=['*']) sub.add('mycomp', ArrayComp2D(), promotes=['x', 'y']) group.add('obj', ExecComp('b = a')) group.connect('y', 'obj.a', src_indices=[3]) prob = Problem() prob.root = group prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['obj.b'], mode='fwd', return_format='dict') Jbase = prob.root.sub.mycomp._jacobian_cache assert_rel_error(self, Jbase[('y', 'x')][3][0], J['obj.b']['x'][0][0], 1e-8) assert_rel_error(self, Jbase[('y', 'x')][3][1], J['obj.b']['x'][0][1], 1e-8) assert_rel_error(self, Jbase[('y', 'x')][3][2], J['obj.b']['x'][0][2], 1e-8) assert_rel_error(self, Jbase[('y', 'x')][3][3], J['obj.b']['x'][0][3], 1e-8) J = prob.calc_gradient(['x'], ['obj.b'], mode='rev', return_format='dict') Jbase = prob.root.sub.mycomp._jacobian_cache assert_rel_error(self, Jbase[('y', 'x')][3][0], J['obj.b']['x'][0][0], 1e-8) assert_rel_error(self, Jbase[('y', 'x')][3][1], J['obj.b']['x'][0][1], 1e-8) assert_rel_error(self, Jbase[('y', 'x')][3][2], J['obj.b']['x'][0][2], 1e-8) assert_rel_error(self, Jbase[('y', 'x')][3][3], J['obj.b']['x'][0][3], 1e-8)
def test_fan_out_parallel_sets(self): prob = Problem(impl=impl) prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # need to set mode to rev before setup. Otherwise the sub-vectors # for the parallel set vars won't get allocated. prob.root.ln_solver.options['mode'] = 'rev' prob.root.sub.ln_solver.options['mode'] = 'rev' # Parallel Groups prob.driver.add_param('p.x') prob.driver.add_constraint('c2.y') prob.driver.add_constraint('c3.y') prob.driver.parallel_derivs(['c2.y','c3.y']) self.assertEqual(prob.driver.outputs_of_interest(), [('c2.y','c3.y')]) prob.setup(check=False) prob.run() unknown_list = ['c2.y', 'c3.y'] param_list = ['p.x'] J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
def test_overlapping_inputs_idxs(self): # distrib comp with src_indices that overlap, i.e. the same # entries are distributed to multiple processes size = 11 p = Problem(root=Group(), impl=impl) top = p.root top.add("C1", InOutArrayComp(size)) top.add("C2", DistribOverlappingInputComp(size)) top.connect('C1.outvec', 'C2.invec') p.setup(check=False) top.C1.params['invec'] = np.array(range(size, 0, -1), float) p.run() self.assertTrue( all(top.C2.unknowns['outvec'][:4] == np.array(range(size, 0, -1), float)[:4] * 4)) self.assertTrue( all(top.C2.unknowns['outvec'][8:] == np.array(range(size, 0, -1), float)[8:] * 4)) # overlapping part should be double size of the rest self.assertTrue( all(top.C2.unknowns['outvec'][4:8] == np.array(range(size, 0, -1), float)[4:8] * 8))
def test_2Darray_read(self): namelist1 = "Testing\n" + \ "$GROUP\n" + \ " arrayvartwod(1,1) = 12, 24, 36\n" + \ " arrayvartwod(1,2) = 33, 66, 99\n" + \ "$END\n" outfile = open(self.filename, 'w') outfile.write(namelist1) outfile.close() top = Problem() top.root = Group() top.root.add('my_comp', VarComponent()) top.setup(check=False) top.run() sb = Namelist(top.root.my_comp) sb.set_filename(self.filename) sb.parse_file() sb.load_model() # Unchanged self.assertEqual(top['my_comp.arrayvartwod'][0][0], 12) self.assertEqual(top['my_comp.arrayvartwod'][1][2], 99)
def test_array_values(self): prob = Problem() prob.root = Group() prob.root.add('pc', ParamComp('x', np.zeros((2, 3)), units='degC'), promotes=['x']) prob.root.add('uc', UnitComp(shape=(2, 3), param_name='x', out_name='x_out', units='degF'), promotes=['x', 'x_out']) prob.setup(check=False) prob.run() assert_rel_error(self, prob['x_out'], np.array([[32., 32., 32.], [32., 32., 32.]]), 1e-6) param_list = ['x'] unknown_list = ['x_out'] # Forward Mode J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['x_out']['x'], 1.8 * np.eye(6), 1e-6) # Reverse Mode J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['x_out']['x'], 1.8 * np.eye(6), 1e-6)
def test_unsupported_array(self): top = Problem() top.root = Group() top.root.add('my_comp', VarComponent()) top.setup(check=False) top.run() sb = Namelist(top.root.my_comp) top['my_comp.arrayvar'] = zeros([2, 2, 2], dtype=numpy_float32) sb.set_filename(self.filename) sb.add_group('Test') sb.add_var("arrayvar") try: sb.generate() except RuntimeError as err: self.assertEqual(str(err), "Don't know how to handle array of" + \ " 3 dimensions") else: self.fail('RuntimeError expected')
def test_simple_array_comp(self): prob = Problem() root = prob.root = Group() root.add('p1', ParamComp('x', np.zeros([2])), promotes=['*']) root.add('comp', SimpleArrayComp(), promotes=['*']) root.add('con', ExecComp('c = y - 20.0', c=np.array([0.0, 0.0]), y=np.array([0.0, 0.0])), promotes=['*']) root.add('obj', ExecComp('o = y[0]', y=np.array([0.0, 0.0])), promotes=['*']) prob.driver = pyOptSparseDriver() prob.driver.add_param('x', low=-50.0, high=50.0) prob.driver.add_objective('o') prob.driver.add_constraint('c', ctype='eq') prob.setup(check=False) prob.run() obj = prob['o'] assert_rel_error(self, obj, 20.0, 1e-6)
def test_fan_in_serial_sets(self): prob = Problem(impl=impl) prob.root = FanInGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # Parallel Groups prob.driver.add_desvar('p1.x1') prob.driver.add_desvar('p2.x2') prob.driver.add_objective('comp3.y') prob.setup(check=False) prob.run() indep_list = ['p1.x1', 'p2.x2'] unknown_list = ['comp3.y'] J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6) J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
def test_calc_gradient_multiple_params(self): prob = Problem() prob.root = FanIn() prob.setup(check=False) prob.run() param_list = ['p1.x1', 'p2.x2'] unknown_list = ['comp3.y'] # check that calc_gradient returns proper dict value when mode is 'fwd' J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[35.]])) np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[-6.]])) # check that calc_gradient returns proper array value when mode is 'fwd' J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='array') np.testing.assert_almost_equal(J, np.array([[-6., 35.]])) # check that calc_gradient returns proper dict value when mode is 'rev' J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[35.]])) np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[-6.]])) # check that calc_gradient returns proper array value when mode is 'rev' J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='array') np.testing.assert_almost_equal(J, np.array([[-6., 35.]])) # check that calc_gradient returns proper dict value when mode is 'fd' J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict') np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[35.]])) np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[-6.]])) # check that calc_gradient returns proper array value when mode is 'fd' J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='array') np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
def test_unknown_vec(self): top = Problem() top.root = Group() top.root.add('comp', ArrayComp2D(), promotes=['x', 'y']) top.root.add('p1', IndepVarComp('x', np.array([[1.0, 2.0], [3.0, 4.0]])), promotes=['x']) top.root.add('comp2', SimpleComp()) top.root.add('p2', IndepVarComp('x', 3.0)) top.root.connect('p2.x', 'comp2.x') top.setup(check=False) top.run() unknowns = ComplexStepSrcVecWrapper(top.root.comp.unknowns) # Unknowns are always complex y = unknowns['y'] self.assertTrue(y.dtype == np.complex) self.assertEquals(y[0, 1], 46.0 + 0j) # Set an unknown unknowns['y'][0, 1] = 13.0 + 17.0j self.assertEquals(unknowns['y'][0, 1], 13.0 + 17.0j) # Extract flat var cval = unknowns.flat('y') self.assertEquals(cval[1], 13.0 + 17.0j) self.assertEquals(cval.shape[0], 4) unknowns = ComplexStepSrcVecWrapper(top.root.comp2.unknowns) # Unknowns are always complex y = unknowns['y'] self.assertTrue(y.dtype == np.complex) self.assertEquals(y, 6.0 + 0j) # Set an unknown unknowns['y'] = 13.0 + 17.0j self.assertEquals(unknowns['y'], 13.0 + 17.0j) # Extract flat var cval = unknowns.flat('y') self.assertEquals(cval, 13.0 + 17.0j) self.assertEquals(cval.shape[0], 1) # Make sure all other functions work for coverage self.assertEquals(len(unknowns), 1) self.assertTrue('y' in unknowns) plist = [z for z in unknowns] self.assertEquals(plist, ['y']) self.assertEquals(unknowns.keys(), top.root.comp2.unknowns.keys()) self.assertEquals(unknowns.metadata('y'), top.root.comp2.unknowns.metadata('y')) plist1 = [z for z in unknowns.iterkeys()] plist2 = [z for z in top.root.comp2.unknowns.iterkeys()]
def test_indices(self): asize = 3 prob = Problem(root=Group(), impl=impl) root = prob.root root.ln_solver = LinearGaussSeidel() root.ln_solver.options['mode'] = 'rev' p = root.add('p', ParamComp('x', np.arange(asize, dtype=float) + 1.0)) G1 = root.add('G1', ParallelGroup()) G1.ln_solver = LinearGaussSeidel() G1.ln_solver.options['mode'] = 'rev' c2 = G1.add( 'c2', ExecComp4Test('y = x * 2.0', x=np.zeros(asize), y=np.zeros(asize))) c3 = G1.add( 'c3', ExecComp4Test('y = numpy.ones(3).T*x.dot(numpy.arange(3.,6.))', x=np.zeros(asize), y=np.zeros(asize))) c4 = root.add( 'c4', ExecComp4Test('y = x * 4.0', x=np.zeros(asize), y=np.zeros(asize))) c5 = root.add( 'c5', ExecComp4Test('y = x * 5.0', x=np.zeros(asize), y=np.zeros(asize))) prob.driver.add_param('p.x', indices=[1, 2]) prob.driver.add_constraint('c4.y', indices=[1]) prob.driver.add_constraint('c5.y', indices=[2]) prob.driver.parallel_derivs(['c4.y', 'c5.y']) root.connect('p.x', 'G1.c2.x') root.connect('p.x', 'G1.c3.x') root.connect('G1.c2.y', 'c4.x') root.connect('G1.c3.y', 'c5.x') prob.setup(check=False) prob.run() J = prob.calc_gradient(['p.x'], ['c4.y', 'c5.y'], mode='fwd', return_format='dict') assert_rel_error(self, J['c5.y']['p.x'][0], np.array([20., 25.]), 1e-6) assert_rel_error(self, J['c4.y']['p.x'][0], np.array([8., 0.]), 1e-6) J = prob.calc_gradient(['p.x'], ['c4.y', 'c5.y'], mode='rev', return_format='dict') assert_rel_error(self, J['c5.y']['p.x'][0], np.array([20., 25.]), 1e-6) assert_rel_error(self, J['c4.y']['p.x'][0], np.array([8., 0.]), 1e-6)
def test_sellar_derivs(self): prob = Problem() prob.root = SellarDerivatives() prob.root.ln_solver = LinearGaussSeidel() prob.root.ln_solver.options['maxiter'] = 4 prob.root.nl_solver.options['atol'] = 1e-12 prob.setup(check=False) prob.run() # Just make sure we are at the right answer assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['y2'], 12.05848819, .00001) param_list = ['x', 'z'] param_list = ['x'] unknown_list = ['obj', 'con1', 'con2'] Jbase = {} Jbase['con1'] = {} Jbase['con1']['x'] = -0.98061433 Jbase['con1']['z'] = np.array([-9.61002285, -0.78449158]) Jbase['con2'] = {} Jbase['con2']['x'] = 0.09692762 Jbase['con2']['z'] = np.array([1.94989079, 1.0775421 ]) Jbase['obj'] = {} Jbase['obj']['x'] = 2.98061392 Jbase['obj']['z'] = np.array([9.61001155, 1.78448534]) J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') print(J) #for key1, val1 in Jbase.items(): #for key2, val2 in val1.items(): #assert_rel_error(self, J[key1][key2], val2, .00001) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') print(J) #for key1, val1 in Jbase.items(): #for key2, val2 in val1.items(): #assert_rel_error(self, J[key1][key2], val2, .00001) prob.root.fd_options['form'] = 'central' J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict') print(J) #for key1, val1 in Jbase.items(): #for key2, val2 in val1.items(): #assert_rel_error(self, J[key1][key2], val2, .00001) # Obviously this test doesn't do much right now, but I need to verify # we don't get a keyerror here. J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='array')
def test_scaler_adder(self): class ScaleAddDriver(Driver): def run(self, problem): """ Save away scaled info.""" params = self.get_params() param_meta = self.get_param_metadata() self.set_param('x', 0.5) problem.root.solve_nonlinear() objective = self.get_objectives() constraint = self.get_constraints() # Stuff we saved should be in the scaled coordinates. self.param = params['x'] self.obj_scaled = objective['f_xy'] self.con_scaled = constraint['con'] self.param_high = param_meta['x']['high'] self.param_low = param_meta['x']['low'] prob = Problem() root = prob.root = Group() driver = prob.driver = ScaleAddDriver() root.add('p1', ParamComp([('x', 60000.0, { 'desc': 'my x' }), ('y', 60000.0, { 'desc': 'my y' })]), promotes=['*']) root.add('comp', Paraboloid(), promotes=['*']) root.add('constraint', ExecComp('con=f_xy + x + y'), promotes=['*']) driver.add_param('x', low=59000.0, high=61000.0, adder=-60000.0, scaler=1 / 1000.0) driver.add_objective('f_xy', adder=-10890367002.0, scaler=1.0 / 20) driver.add_constraint('con', adder=-10890487502.0, scaler=1.0 / 20) prob.setup(check=False) prob.run() self.assertEqual(driver.param_high, 1.0) self.assertEqual(driver.param_low, -1.0) self.assertEqual(driver.param, 0.0) self.assertEqual(prob['x'], 60500.0) self.assertEqual(driver.obj_scaled[0], 1.0) self.assertEqual(driver.con_scaled[0], 1.0)