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_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_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_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_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 = ConvergeDivergeGroups() prob.root.ln_solver = ScipyGMRES() prob.root.ln_solver.options['precondition'] = True prob.root.sub1.ln_solver = DirectSolver() prob.root.sub3.ln_solver = DirectSolver() prob.setup(check=False) prob.run() # Make sure value is fine. assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6) indep_list = ['p.x'] unknown_list = ['comp7.y1'] J = prob.calc_gradient(indep_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(indep_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(indep_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_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_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_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_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_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_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)
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_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_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_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_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_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_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_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_fan_in_parallel_sets(self): prob = Problem(impl=impl) prob.root = FanInGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.sub.ln_solver = LinearGaussSeidel() # auto calculated mode is fwd, so we don't have to set it explicitly # in the ln_solvers in order to have our voi subvecs allocated # properly. # Parallel Groups prob.driver.add_param("p1.x1") prob.driver.add_param("p2.x2") prob.driver.add_objective("comp3.y") # make sure we can't mix inputs and outputs in parallel sets try: prob.driver.parallel_derivs(["p1.x1", "comp3.y"]) except Exception as err: self.assertEqual( str(err), "['p1.x1', 'comp3.y'] cannot be grouped because ['p1.x1'] are " "params and ['comp3.y'] are not.", ) else: self.fail("Exception expected") prob.driver.parallel_derivs(["p1.x1", "p2.x2"]) self.assertEqual(prob.driver.params_of_interest(), [("p1.x1", "p2.x2")]) # make sure we can't add a VOI to multiple groups try: prob.driver.parallel_derivs(["p1.x1", "p3.x3"]) except Exception as err: self.assertEqual( str(err), "'p1.x1' cannot be added to VOI set ('p1.x1', 'p3.x3') " "because it already exists in VOI set: ('p1.x1', 'p2.x2')", ) else: self.fail("Exception expected") 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_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_sellar_derivs_grouped(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.root.mda.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'] 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') 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') 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') for key1, val1 in Jbase.items(): for key2, val2 in val1.items(): assert_rel_error(self, J[key1][key2], val2, .00001)
def test_basic_grouped(self): prob = Problem() prob.root = Group() sub1 = prob.root.add('sub1', Group()) sub2 = prob.root.add('sub2', Group()) sub1.add('src', SrcComp()) sub2.add('tgtF', TgtCompF()) sub2.add('tgtC', TgtCompC()) sub2.add('tgtK', TgtCompK()) prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1']) prob.root.connect('x1', 'sub1.src.x1') prob.root.connect('sub1.src.x2', 'sub2.tgtF.x2') prob.root.connect('sub1.src.x2', 'sub2.tgtC.x2') prob.root.connect('sub1.src.x2', 'sub2.tgtK.x2') prob.setup(check=False) prob.run() assert_rel_error(self, prob['sub1.src.x2'], 100.0, 1e-6) assert_rel_error(self, prob['sub2.tgtF.x3'], 212.0, 1e-6) assert_rel_error(self, prob['sub2.tgtC.x3'], 100.0, 1e-6) assert_rel_error(self, prob['sub2.tgtK.x3'], 373.15, 1e-6) # Make sure we don't convert equal units self.assertEqual(prob.root.sub2.params.metadata('tgtC.x2').get('unit_conv'), None) indep_list = ['x1'] unknown_list = ['sub2.tgtF.x3', 'sub2.tgtC.x3', 'sub2.tgtK.x3'] J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6) J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6) J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='dict') assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_sellar_derivs_grouped_GSnested(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.root.ln_solver.options['maxiter'] = 15 #prob.root.ln_solver.options['iprint'] = 1 prob.root.mda.nl_solver.options['atol'] = 1e-12 prob.root.mda.ln_solver = LinearGaussSeidel() prob.root.mda.ln_solver.options['maxiter'] = 15 #prob.root.mda.ln_solver.options['iprint'] = 1 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) indep_list = ['x', 'z'] 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(indep_list, unknown_list, mode='fwd', return_format='dict') 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(indep_list, unknown_list, mode='rev', return_format='dict') 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(indep_list, unknown_list, mode='fd', return_format='dict') for key1, val1 in Jbase.items(): for key2, val2 in val1.items(): assert_rel_error(self, J[key1][key2], val2, .00001)
def test_complex_step2(self): prob = Problem(Group()) comp = prob.root.add('comp', ExecComp('y=x*x + x*2.0')) prob.root.add('p1', ParamComp('x', 2.0)) prob.root.connect('p1.x', 'comp.x') comp.fd_options['force_fd'] = False prob.setup(check=False) prob.run() J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fwd', return_format='dict') assert_rel_error(self, J['comp.y']['p1.x'], np.array([6.0]), 0.00001) J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='rev', return_format='dict') assert_rel_error(self, J['comp.y']['p1.x'], np.array([6.0]), 0.00001)
def test_simple_matvec(self): group = Group() group.add('x_param', ParamComp('x', 1.0), promotes=['*']) group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
def test_simple_matvec(self): group = Group() group.add('x_param', IndepVarComp('x', 1.0), promotes=['*']) group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
def test_simple_jac(self): group = Group() group.add('x_param', ParamComp('x', 1.0), promotes=['*']) group.add('mycomp', ExecComp(['y=2.0*x']), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
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_simple_jac(self): group = Group() group.add('x_param', ParamComp('x', 1.0), promotes=['*']) group.add('mycomp', ExecComp(['y=2.0*x']), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
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', IndepVarComp('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_desvar('p.x', indices=[1,2]) prob.driver.add_constraint('c4.y', upper=0.0, indices=[1]) prob.driver.add_constraint('c5.y', upper=0.0, 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_converge_diverge_groups(self): prob = Problem() prob.root = Group() prob.root.add('sub', ConvergeDivergeGroups()) indep_list = ['sub.p.x'] unknown_list = ['sub.comp7.y1'] prob.setup(check=False) prob.run() J = prob.calc_gradient(indep_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(indep_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_simple_in_group_matvec(self): group = Group() sub = group.add('sub', Group(), promotes=['x', 'y']) group.add('x_param', ParamComp('x', 1.0), promotes=['*']) sub.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = ExplicitSolver() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.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_basic_grouped_bug_from_pycycle(self): prob = Problem() root = prob.root = Group() sub1 = prob.root.add('sub1', Group(), promotes=['x2']) sub1.add('src', SrcComp(), promotes = ['x2']) root.add('tgtF', TgtCompFMulti()) root.add('tgtC', TgtCompC()) root.add('tgtK', TgtCompK()) prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1']) prob.root.connect('x1', 'sub1.src.x1') prob.root.connect('x2', 'tgtF.x2') prob.root.connect('x2', 'tgtC.x2') prob.root.connect('x2', 'tgtK.x2') prob.setup(check=False) prob.run() assert_rel_error(self, prob['x2'], 100.0, 1e-6) assert_rel_error(self, prob['tgtF.x3'], 212.0, 1e-6) assert_rel_error(self, prob['tgtC.x3'], 100.0, 1e-6) assert_rel_error(self, prob['tgtK.x3'], 373.15, 1e-6) indep_list = ['x1'] unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3'] J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6) J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6) J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='dict') assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_fan_out_grouped(self): prob = Problem() prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() param_list = ['p.x'] unknown_list = ['sub.comp2.y', "sub.comp3.y"] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['sub.comp2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['sub.comp3.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['sub.comp2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['sub.comp3.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_no_derivatives(self): prob = Problem() prob.root = Group() comp = prob.root.add('comp', ExecComp('y=x*2.0')) prob.root.add('p1', ParamComp('x', 2.0)) prob.root.connect('p1.x', 'comp.x') comp.fd_options['force_fd'] = True prob.setup(check=False) prob.run() J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fwd', return_format='dict') assert_rel_error(self, J['comp.y']['p1.x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='rev', return_format='dict') assert_rel_error(self, J['comp.y']['p1.x'][0][0], 2.0, 1e-6)
def test_fan_out_grouped(self): prob = Problem() prob.root = FanOutGrouped() prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() indep_list = ['p.x'] unknown_list = ['sub.comp2.y', "sub.comp3.y"] J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['sub.comp2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['sub.comp3.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['sub.comp2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['sub.comp3.y']['p.x'][0][0], 15.0, 1e-6)
def test_fan_in_grouped(self): prob = Problem() prob.root = FanInGrouped() prob.root.ln_solver = LinearGaussSeidel() 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='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(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)
def test_single_diamond(self): prob = Problem() prob.root = SingleDiamond() prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() indep_list = ['p.x'] unknown_list = ['comp4.y1', 'comp4.y2'] J = prob.calc_gradient(indep_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(indep_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)
def benchmark_cadre_mdp_derivs_full(self): # These numbers are for the CADRE problem in the paper. n = 1500 m = 300 npts = 6 # Instantiate model = Problem(impl=impl) root = model.root = CADRE_MDP_Group(n=n, m=m, npts=npts) # Add parameters and constraints to each CADRE instance. names = ["pt%s" % i for i in range(npts)] for i, name in enumerate(names): # add parameters to driver model.driver.add_desvar("%s.CP_Isetpt" % name, lower=0.0, upper=0.4) model.driver.add_desvar("%s.CP_gamma" % name, lower=0, upper=np.pi / 2.0) model.driver.add_desvar("%s.CP_P_comm" % name, lower=0.0, upper=25.0) model.driver.add_desvar("%s.iSOC" % name, indices=[0], lower=0.2, upper=1.0) model.driver.add_constraint("%s.ConCh" % name, upper=0.0) model.driver.add_constraint("%s.ConDs" % name, upper=0.0) model.driver.add_constraint("%s.ConS0" % name, upper=0.0) model.driver.add_constraint("%s.ConS1" % name, upper=0.0) model.driver.add_constraint("%s_con5.val" % name, equals=0.0) # Add Parameter groups model.driver.add_desvar("bp1.cellInstd", lower=0.0, upper=1.0) model.driver.add_desvar("bp2.finAngle", lower=0.0, upper=np.pi / 2.0) model.driver.add_desvar("bp3.antAngle", lower=-np.pi / 4, upper=np.pi / 4) # Add objective model.driver.add_objective("obj.val") model.root.ln_solver = LinearGaussSeidel() model.root.parallel.ln_solver = LinearGaussSeidel() model.root.parallel.pt0.ln_solver = LinearGaussSeidel() model.root.parallel.pt1.ln_solver = LinearGaussSeidel() model.root.parallel.pt2.ln_solver = LinearGaussSeidel() model.root.parallel.pt3.ln_solver = LinearGaussSeidel() model.root.parallel.pt4.ln_solver = LinearGaussSeidel() model.root.parallel.pt5.ln_solver = LinearGaussSeidel() model.setup(check=False) model.run() params = list(model.driver.get_desvars().keys()) unks = list(model.driver.get_objectives().keys()) + list(model.driver.get_constraints().keys()) # ---------------------------------------- # This is what we are really profiling # ---------------------------------------- J = model.calc_gradient(params, unks, mode="rev", return_format="dict") assert_rel_error(self, J["obj.val"]["bp3.antAngle"], 67.15777407, 1e-4) assert_rel_error(self, J["obj.val"]["pt1.CP_gamma"][-1][-1], -0.62410223816776056, 1e-4)
def test_basic_grouped(self): prob = Problem() prob.root = Group() sub1 = prob.root.add('sub1', Group()) sub2 = prob.root.add('sub2', Group()) sub1.add('src', SrcComp()) sub2.add('tgtF', TgtCompF()) sub2.add('tgtC', TgtCompC()) sub2.add('tgtK', TgtCompK()) prob.root.add('px1', ParamComp('x1', 100.0), promotes=['x1']) prob.root.connect('x1', 'sub1.src.x1') prob.root.connect('sub1.src.x2', 'sub2.tgtF.x2') prob.root.connect('sub1.src.x2', 'sub2.tgtC.x2') prob.root.connect('sub1.src.x2', 'sub2.tgtK.x2') prob.setup(check=False) prob.run() assert_rel_error(self, prob['sub1.src.x2'], 100.0, 1e-6) assert_rel_error(self, prob['sub2.tgtF.x3'], 212.0, 1e-6) assert_rel_error(self, prob['sub2.tgtC.x3'], 100.0, 1e-6) assert_rel_error(self, prob['sub2.tgtK.x3'], 373.15, 1e-6) # Make sure we don't convert equal units self.assertEqual(prob.root.sub2.params.metadata('tgtC.x2').get('unit_conv'), None) param_list = ['x1'] unknown_list = ['sub2.tgtF.x3', 'sub2.tgtC.x3', 'sub2.tgtK.x3'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_array2D(self): group = Group() group.add('x_param', ParamComp('x', np.ones((2, 2))), promotes=['*']) group.add('mycomp', ArrayComp2D(), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = LinearGaussSeidel() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') Jbase = prob.root.mycomp._jacobian_cache diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x']) assert_rel_error(self, diff, 0.0, 1e-8) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x']) assert_rel_error(self, diff, 0.0, 1e-8)
def test_two_simple(self): group = Group() group.add('x_param', ParamComp('x', 1.0)) group.add('comp1', ExecComp(['y=2.0*x'])) group.add('comp2', ExecComp(['z=3.0*y'])) prob = Problem() prob.root = group prob.root.ln_solver = LinearGaussSeidel() prob.root.connect('x_param.x', 'comp1.x') prob.root.connect('comp1.y', 'comp2.y') prob.setup(check=False) prob.run() J = prob.calc_gradient(['x_param.x'], ['comp2.z'], mode='fwd', return_format='dict') assert_rel_error(self, J['comp2.z']['x_param.x'][0][0], 6.0, 1e-6) J = prob.calc_gradient(['x_param.x'], ['comp2.z'], mode='rev', return_format='dict') assert_rel_error(self, J['comp2.z']['x_param.x'][0][0], 6.0, 1e-6)
def test_array2D(self): prob = Problem() prob.root = root = Group() root.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*']) root.add('mycomp', ArrayComp2D(), promotes=['x', 'y']) root.mycomp.deriv_options['step_size'] = 1.0e-1 root.mycomp.deriv_options['type'] = 'cs' prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') Jbase = prob.root.mycomp._jacobian_cache diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x']) assert_rel_error(self, diff, 0.0, 1e-8) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x']) assert_rel_error(self, diff, 0.0, 1e-8)
def test_calc_gradient_interface_errors(self): root = Group() prob = Problem(root=root) root.add('comp', ExecComp('y=x*2.0')) try: prob.calc_gradient(['comp.x'], ['comp.y'], mode='junk') except Exception as error: msg = "mode must be 'auto', 'fwd', 'rev', or 'fd'" self.assertEqual(text_type(error), msg) else: self.fail("Error expected") try: prob.calc_gradient(['comp.x'], ['comp.y'], return_format='junk') except Exception as error: msg = "return_format must be 'array' or 'dict'" self.assertEqual(text_type(error), msg) else: self.fail("Error expected")
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_group_fd(self): class SimpleComp(Component): """ A simple component that provides derivatives. """ def __init__(self): super(SimpleComp, self).__init__() # Params self.add_param('x', 2.0) # Unknowns self.add_output('y', 0.0) def solve_nonlinear(self, params, unknowns, resids): """ Doesn't do much. Just multiply by 3""" unknowns['y'] = 3.0 * params['x'] def jacobian(self, params, unknowns, resids): """Analytical derivatives.""" J = {} J[('y', 'x')] = 3.0 return J class Model(Group): """ Simple model to experiment with finite difference.""" def __init__(self): super(Model, self).__init__() self.add('px', ParamComp('x', 2.0)) self.add('comp1', SimpleComp()) sub = self.add('sub', Group()) sub.add('comp2', SimpleComp()) sub.add('comp3', SimpleComp()) self.add('comp4', SimpleComp()) self.connect('px.x', 'comp1.x') self.connect('comp1.y', 'sub.comp2.x') self.connect('sub.comp2.y', 'sub.comp3.x') self.connect('sub.comp3.y', 'comp4.x') self.sub.fd_options['force_fd'] = True prob = Problem() prob.root = Model() prob.setup(check=False) prob.run() J = prob.calc_gradient(['px.x'], ['comp4.y']) assert_rel_error(self, J[0][0], 81.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_basic_grouped_bug_from_pycycle(self): prob = Problem() root = prob.root = Group() sub1 = prob.root.add('sub1', Group(), promotes=['x2']) sub1.add('src', SrcComp(), promotes = ['x2']) root.add('tgtF', TgtCompFMulti()) root.add('tgtC', TgtCompC()) root.add('tgtK', TgtCompK()) prob.root.add('px1', ParamComp('x1', 100.0), promotes=['x1']) prob.root.connect('x1', 'sub1.src.x1') prob.root.connect('x2', 'tgtF.x2') prob.root.connect('x2', 'tgtC.x2') prob.root.connect('x2', 'tgtK.x2') prob.setup(check=False) prob.run() assert_rel_error(self, prob['x2'], 100.0, 1e-6) assert_rel_error(self, prob['tgtF.x3'], 212.0, 1e-6) assert_rel_error(self, prob['tgtC.x3'], 100.0, 1e-6) assert_rel_error(self, prob['tgtK.x3'], 373.15, 1e-6) param_list = ['x1'] unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6) J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict') assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6) assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6) assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_simple_matvec_subbed_like_multipoint(self): group = Group() group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem() prob.root = Group() prob.root.add('sub', group, promotes=['*']) prob.root.sub.add('x_param', ParamComp('x', 1.0), promotes=['*']) prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='fd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6) J = prob.calc_gradient(['x'], ['y'], mode='fd', return_format='array') assert_rel_error(self, J[0][0], 2.0, 1e-6)
def test_fan_out(self): prob = Problem() prob.root = FanOut() prob.root.ln_solver = ScipyGMRES() prob.setup(check=False) prob.run() param_list = ['p.x'] unknown_list = ['comp2.y', "comp3.y"] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['comp2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.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['comp2.y']['p.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['comp3.y']['p.x'][0][0], 15.0, 1e-6)
def test_simple_float(self): prob = Problem() prob.root = root = Group() root.add('x_param', IndepVarComp('x', 17.0), promotes=['x']) root.add('y_param', IndepVarComp('y', 19.0), promotes=['y']) root.add('mycomp', Paraboloid(), promotes=['x', 'y', 'f_xy']) # This will give poor FD, but good CS root.mycomp.fd_options['step_size'] = 1.0e1 root.mycomp.fd_options['force_fd'] = True root.mycomp.fd_options['form'] = 'complex_step' prob.setup(check=False) prob.run() J = prob.calc_gradient(['x'], ['f_xy'], mode='fwd', return_format='dict') assert_rel_error(self, J['f_xy']['x'][0][0], 47.0, 1e-6)
def test_full_model_fd_simple_comp_promoted(self): prob = Problem() prob.root = Group() sub = prob.root.add('sub', Group(), promotes=['*']) sub.add('comp', SimpleCompDerivMatVec(), promotes=['*']) prob.root.add('p1', ParamComp('x', 1.0), promotes=['*']) prob.root.fd_options['force_fd'] = True prob.setup(check=False) prob.run() param_list = ['x'] unknown_list = ['y'] J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict') assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
self.add('comp4', SimpleComp()) self.connect('px.x', 'comp1.x') self.connect('comp1.y', 'comp2.x') self.connect('comp2.y', 'comp3.x') self.connect('comp3.y', 'comp4.x') # Tell these components to finite difference self.comp2.fd_options['force_fd'] = True self.comp2.fd_options['form'] = 'central' self.comp2.fd_options['step_size'] = 1.0e-4 self.comp4.fd_options['force_fd'] = True self.comp4.fd_options['form'] = 'central' self.comp4.fd_options['step_size'] = 1.0e-4 if __name__ == '__main__': # Setup and run the model. top = Problem() top.root = Model() top.setup() top.run() print('\n\nStart Calc Gradient') print('-' * 25) J = top.calc_gradient(['px.x'], ['comp4.y']) print(J)