def test_derivatives(self): meta = MetaModel() meta.add_param('x', 0.) meta.add_output('f', 0.) meta.default_surrogate = FloatKrigingSurrogate() prob = Problem(Group()) prob.root.add('meta', meta, promotes=['x']) prob.root.add('p', IndepVarComp('x', 0.), promotes=['x']) prob.setup(check=False) prob['meta.train:x'] = [0., .25, .5, .75, 1.] prob['meta.train:f'] = [1., .75, .5, .25, 0.] prob['x'] = 0.125 prob.run() Jf = prob.calc_gradient(['x'], ['meta.f'], mode='fwd') Jr = prob.calc_gradient(['x'], ['meta.f'], mode='rev') assert_rel_error(self, Jf[0][0], -1., 1.e-5) assert_rel_error(self, Jr[0][0], -1., 1.e-5) stream = cStringIO() prob.check_partial_derivatives(out_stream=stream, global_options={'check_type': 'cs'}) abs_errors = findall('Absolute Error \(.+\) : (.+)', stream.getvalue()) self.assertTrue(len(abs_errors) > 0) for match in abs_errors: abs_error = float(match) self.assertTrue(abs_error < 1.e-6)
def test_derivatives(self): meta = MetaModel() meta.add_param('x', 0.) meta.add_output('f', 0.) meta.default_surrogate = FloatKrigingSurrogate() prob = Problem(Group()) prob.root.add('meta', meta, promotes=['x']) prob.root.add('p', IndepVarComp('x', 0.), promotes=['x']) prob.setup(check=False) prob['meta.train:x'] = [0., .25, .5, .75, 1.] prob['meta.train:f'] = [1., .75, .5, .25, 0.] prob['x'] = 0.125 prob.run() Jf = prob.calc_gradient(['x'], ['meta.f'], mode='fwd') Jr = prob.calc_gradient(['x'], ['meta.f'], mode='rev') assert_rel_error(self, Jf[0][0], -1., 1.e-5) assert_rel_error(self, Jr[0][0], -1., 1.e-5) stream = cStringIO() prob.check_partial_derivatives(out_stream=stream, global_options={'check_type': 'cs'}) abs_errors = findall('Absolute Error \(.+\) : (.+)', stream.getvalue()) self.assertTrue(len(abs_errors) > 0) for match in abs_errors: abs_error = float(match) self.assertTrue(abs_error < 1.e-6)
def test_overrides(self): prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SimpleImplicitComp()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.root.comp.deriv_options['check_type'] = 'fd' prob.root.comp.deriv_options['check_step_size'] = 1e25 prob.setup(check=False) prob.run() # This should override the bad stepsize. opts = {'check_step_size' : 1e-6} mystream = StringIO() data = prob.check_partial_derivatives(out_stream=mystream, global_options=opts) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5) prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SimpleImplicitComp()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.root.comp.deriv_options['check_type'] = 'fd' prob.root.comp.deriv_options['check_step_size'] = 1e25 prob.setup(check=False) prob.run() mystream = StringIO() opts = {'check_form' : 'central'} data = prob.check_partial_derivatives(out_stream=mystream, global_options=opts, compact_print=True) text = mystream.getvalue() self.assertTrue('fd:central' in text) self.assertTrue('complex_step' not in text) mystream = StringIO() opts = {'check_type' : 'cs'} data = prob.check_partial_derivatives(out_stream=mystream, global_options=opts, compact_print=True) text = mystream.getvalue() self.assertTrue('fd:central' not in text) self.assertTrue('complex step' in text)
def test_check_derivs_param(self): class Comp(Component): def __init__(self): super(Comp, self).__init__() self.add_param('x', val=0.0) self.add_param('y', val=3, pass_by_obj=True) self.add_output('z', val=0.0) def solve_nonlinear(self, params, unknowns, resids): unknowns['z'] = params['y'] * params['x'] def linearize(self, params, unknowns, resids): J = {} J['z', 'x'] = params['y'] return J prob = Problem() prob.root = Group() prob.root.add('comp', Comp(), promotes=['*']) prob.root.add('p1', IndepVarComp('x', 0.0), promotes=['x']) prob.root.add('p2', IndepVarComp('y', 3, pass_by_obj=True), promotes=['y']) prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) self.assertEqual(data['comp'][('z', 'x')]['J_fwd'][0][0], 3.0) data = prob.check_total_derivatives(out_stream=None) self.assertEqual(data[('z', 'x')]['J_fwd'][0][0], 3.0)
def test_simple_implicit_complex_step(self): prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add("comp", SimpleImplicitComp()) prob.root.add("p1", IndepVarComp("x", 0.5)) prob.root.connect("p1.x", "comp.x") prob.root.comp.fd_options["step_size"] = 1.0e4 prob.root.comp.fd_options["form"] = "complex_step" prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2["abs error"][0], 0.0, 1e-5) assert_rel_error(self, val2["abs error"][1], 0.0, 1e-5) assert_rel_error(self, val2["abs error"][2], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][0], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][1], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][2], 0.0, 1e-5)
def test_check_partials_calls_run_once(self): prob = Problem() root = prob.root = Group() root.add('p1', IndepVarComp('x', 1.0), promotes=['*']) root.add('p2', IndepVarComp('y', 1.0), promotes=['*']) root.add('comp', Paraboloid(), promotes=['*']) prob.driver.add_desvar('x') prob.driver.add_desvar('y') prob.driver.add_objective('f_xy') prob.setup(check=False) prob['x'] = 5.0 prob['y'] = 2.0 iostream = StringIO() data = prob.check_partial_derivatives(out_stream=iostream) self.assertAlmostEqual(first=prob["f_xy"], second= (prob['x']-3.0)**2 \ + prob['x']*prob['y'] \ + (prob['y']+4.0)**2 - 3.0, places=5, msg="check partial derivatives did not call" "run_once on the driver as expected.") self.assertEqual( first=iostream.getvalue()[:39], second="Executing model to populate unknowns...", msg="check partial derivatives failed to run driver once")
def test_double_diamond_model_complex_step(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.root.sub1.comp1.fd_options['form'] = 'complex_step' prob.root.sub1.sub2.comp2.fd_options['form'] = 'complex_step' prob.root.sub1.sub2.comp3.fd_options['form'] = 'complex_step' prob.root.sub1.comp4.fd_options['form'] = 'complex_step' prob.root.sub3.comp5.fd_options['form'] = 'complex_step' prob.root.sub3.comp6.fd_options['form'] = 'complex_step' prob.root.comp7.fd_options['form'] = 'complex_step' prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_extra_fd(self): class CSTestComp(Component): def __init__(self): super(CSTestComp, self).__init__() self.add_param('x', val=1.5, step_size=1e-2) # pick a big step to make sure FD sucks self.add_output('f', val=0.) def solve_nonlinear(self, p, u, r): x = p['x'] u['f'] = np.exp(x)/np.sqrt(np.sin(x)**3 + np.cos(x)**3) p = Problem() p.root = Group() p.root.add('des_vars', IndepVarComp('x', 1.5), promotes=['*']) c = p.root.add('comp', CSTestComp(), promotes=["*"]) c.fd_options['force_fd'] = True c.fd_options['form'] = "complex_step" c.fd_options['extra_check_partials_form'] = "forward" p.setup(check=False) p.run_once() check_data = p.check_partial_derivatives(out_stream=None) cs_val = check_data['comp']['f','x']['J_fd'][0,0] # should be the complex steped value! assert_rel_error(self, cs_val, 4.05289181447, 1e-8) fd2_val = check_data['comp']['f','x']['J_fd2'][0,0] # should be the real-fd'd value! assert_rel_error(self, fd2_val, 4.10128351131, 1e-8)
def test_check_derivs_param(self): class Comp(Component): def __init__(self): super(Comp, self).__init__() self.add_param('x', val=0.0) self.add_param('y', val=3, pass_by_obj=True) self.add_output('z', val=0.0) def solve_nonlinear(self, params, unknowns, resids): unknowns['z'] = params['y']*params['x'] def linearize(self, params, unknowns, resids): J = {} J['z', 'x'] = params['y'] return J prob = Problem() prob.root = Group() prob.root.add('comp', Comp(), promotes=['*']) prob.root.add('p1', IndepVarComp('x', 0.0), promotes=['x']) prob.root.add('p2', IndepVarComp('y', 3, pass_by_obj=True), promotes=['y']) prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) self.assertEqual(data['comp'][('z', 'x')]['J_fwd'][0][0], 3.0) data = prob.check_total_derivatives(out_stream=None) self.assertEqual(data[('z', 'x')]['J_fwd'][0][0], 3.0)
def test_simple_implicit_run_once(self): class SIC2(SimpleImplicitComp): def solve_nonlinear(self, params, unknowns, resids): """ Simple iterative solve. (Babylonian method).""" super(SIC2, self).solve_nonlinear(params, unknowns, resids) # This mimics a problem with residuals that aren't up-to-date # with the solve resids['z'] = 999.999 prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SIC2()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run_once() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_problem_deriv_test(self): prob = Problem() prob.root = Group() prob.root.add('comp', SimpleCompWrongDeriv()) prob.root.add('p1', IndepVarComp('x', 2.0)) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) # suppress printed output from problem_derivatives_check() sysout = sys.stdout devnull = open(os.devnull, 'w') try: sys.stdout = devnull problem_derivatives_check(self, prob) except AssertionError as err: sys.stdout = sysout self.assertIn("not less than or equal to 1e-05", err.args[0]) finally: sys.stdout = sysout
def test_simple_array_model2_colons(self): prob = Problem() prob.root = Group() comp = prob.root.add( 'comp', ExecComp('foo:y = foo:mat.dot(x)', inits={ 'foo:y': np.zeros((2, )), 'foo:mat': np.array([[2., 7.], [5., -3.]]) }, x=np.zeros((2, )))) p1 = prob.root.add('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) assert_rel_error(self, data['comp'][('foo:y', 'x')]['abs error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('foo:y', 'x')]['abs error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('foo:y', 'x')]['abs error'][2], 0.0, 1e-5) assert_rel_error(self, data['comp'][('foo:y', 'x')]['rel error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('foo:y', 'x')]['rel error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('foo:y', 'x')]['rel error'][2], 0.0, 1e-5)
def test_simple_implicit_run_once(self): class SIC2(SimpleImplicitComp): def solve_nonlinear(self, params, unknowns, resids): """ Simple iterative solve. (Babylonian method).""" super(SIC2, self).solve_nonlinear(params, unknowns, resids) # This mimics a problem with residuals that aren't up-to-date # with the solve resids['z'] = 999.999 prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SIC2()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run_once() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_simple_array_model(self): prob = Problem() prob.root = Group() prob.root.add( 'comp', ExecComp(['y[0]=2.0*x[0]+7.0*x[1]', 'y[1]=5.0*x[0]-3.0*x[1]'], x=np.zeros([2]), y=np.zeros([2]))) prob.root.add('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) assert_rel_error(self, data['comp'][('y', 'x')]['abs error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['abs error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['abs error'][2], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['rel error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['rel error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['rel error'][2], 0.0, 1e-5)
def test_bad_size(self): class BadComp(SimpleArrayComp): def linearize(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', IndepVarComp('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 = "derivative in component 'comp' of 'y' wrt 'x' is the wrong size. It should be (2, 2), but got (3, 3)" # Good ole Numpy raised_error = str(err) raised_error = raised_error.replace('3L', '3') self.assertEqual(raised_error, msg) else: self.fail("Error expected")
def test_simple_implicit_complex_step(self): prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SimpleImplicitComp()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.root.comp.fd_options['step_size'] = 1.0e4 prob.root.comp.fd_options['form'] = 'complex_step' prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_check_partials_calls_run_once(self): prob = Problem() root = prob.root = Group() root.add('p1', IndepVarComp('x', 1.0), promotes=['*']) root.add('p2', IndepVarComp('y', 1.0), promotes=['*']) root.add('comp', Paraboloid(), promotes=['*']) prob.driver.add_desvar('x') prob.driver.add_desvar('y') prob.driver.add_objective('f_xy') prob.setup(check=False) prob['x'] = 5.0 prob['y'] = 2.0 iostream = StringIO() data = prob.check_partial_derivatives(out_stream=iostream) self.assertAlmostEqual(first=prob["f_xy"], second= (prob['x']-3.0)**2 \ + prob['x']*prob['y'] \ + (prob['y']+4.0)**2 - 3.0, places=5, msg="check partial derivatives did not call" "run_once on the driver as expected.") self.assertEqual(first=iostream.getvalue()[:39], second="Executing model to populate unknowns...", msg="check partial derivatives failed to run driver once")
def test_bad_size(self): class BadComp(SimpleArrayComp): def linearize(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', IndepVarComp('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 = "derivative in component 'comp' of 'y' wrt 'x' is the wrong size. It should be (2, 2), but got (3, 3)" # Good ole Numpy raised_error = str(err) raised_error = raised_error.replace('3L', '3') self.assertEqual(raised_error, msg) else: self.fail("Error expected")
def test_message_no_connections(self): p = Problem() p.root = Group() c = p.root.add('comp', Paraboloid()) p.setup(check=False) p.run_once() mystream = StringIO() p.check_partial_derivatives(out_stream=mystream) text = mystream.getvalue() expected = 'Skipping because component has no connected inputs.' self.assertTrue(expected in text)
def test_double_diamond_model_complex_step(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.root.sub1.comp1.fd_options['form'] = 'complex_step' prob.root.sub1.sub2.comp2.fd_options['form'] = 'complex_step' prob.root.sub1.sub2.comp3.fd_options['form'] = 'complex_step' prob.root.sub1.comp4.fd_options['form'] = 'complex_step' prob.root.sub3.comp5.fd_options['form'] = 'complex_step' prob.root.sub3.comp6.fd_options['form'] = 'complex_step' prob.root.comp7.fd_options['form'] = 'complex_step' prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_simple_implicit_complex_step(self): prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SimpleImplicitComp()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.root.comp.fd_options['step_size'] = 1.0e4 prob.root.comp.fd_options['form'] = 'complex_step' prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_simple_array_model2(self): raise unittest.SkipTest("no check_partial_derivatives function") prob = Problem() prob.root = Group() comp = prob.root.add_subsystem( 'comp', ExecComp('y = mat.dot(x)', x=np.zeros((2, )), y=np.zeros((2, )), mat=np.array([[2., 7.], [5., -3.]]))) p1 = prob.root.add_subsystem('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) assert_rel_error(self, data['comp'][('y', 'x')]['abs error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['abs error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['abs error'][2], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['rel error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['rel error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['rel error'][2], 0.0, 1e-5)
def test_problem_deriv_test(self): prob = Problem() prob.root = Group() prob.root.add('comp', SimpleCompWrongDeriv()) prob.root.add('p1', IndepVarComp('x', 2.0)) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) # suppress printed output from problem_derivatives_check() sysout = sys.stdout devnull = open(os.devnull, 'w') try: sys.stdout = devnull problem_derivatives_check(self, prob) except AssertionError as err: sys.stdout = sysout self.assertIn("not less than or equal to 1e-05", err.args[0]) finally: sys.stdout = sysout
def test_simple_implicit(self): prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add('comp', SimpleImplicitComp()) prob.root.add('p1', IndepVarComp('x', 0.5)) prob.root.connect('p1.x', 'comp.x') prob.root.comp.deriv_options['check_type'] = 'cs' prob.setup(check=False) prob.run() # Correct total derivatives (we can do this one manually) J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fwd') assert_rel_error(self, J[0][0], -2.5555511, 1e-5) J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='rev') assert_rel_error(self, J[0][0], -2.5555511, 1e-5) J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fd') assert_rel_error(self, J[0][0], -2.5555511, 1e-5) # Clean up old FD prob.run() # Partials data = prob.check_partial_derivatives(out_stream=None) #data = prob.check_partial_derivatives() for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y', 'x')]['J_fwd'][0][0], 1.0, 1e-6) assert_rel_error(self, data['comp'][('y', 'z')]['J_fwd'][0][0], 2.0, 1e-6) assert_rel_error(self, data['comp'][('z', 'x')]['J_fwd'][0][0], 2.66666667, 1e-6) assert_rel_error(self, data['comp'][('z', 'z')]['J_fwd'][0][0], 1.5, 1e-6) # Clean up old FD prob.run() # Make sure check_totals works too data = prob.check_total_derivatives(out_stream=None) for key1, val1 in iteritems(data): assert_rel_error(self, val1['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val1['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val1['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val1['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val1['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val1['rel error'][2], 0.0, 1e-5)
def test_simple_implicit(self): prob = Problem() prob.root = Group() prob.root.ln_solver = ScipyGMRES() prob.root.add("comp", SimpleImplicitComp()) prob.root.add("p1", IndepVarComp("x", 0.5)) prob.root.connect("p1.x", "comp.x") prob.root.comp.fd_options["extra_check_partials_form"] = "complex_step" prob.setup(check=False) prob.run() # Correct total derivatives (we can do this one manually) J = prob.calc_gradient(["p1.x"], ["comp.y"], mode="fwd") assert_rel_error(self, J[0][0], -2.5555511, 1e-5) J = prob.calc_gradient(["p1.x"], ["comp.y"], mode="rev") assert_rel_error(self, J[0][0], -2.5555511, 1e-5) J = prob.calc_gradient(["p1.x"], ["comp.y"], mode="fd") assert_rel_error(self, J[0][0], -2.5555511, 1e-5) # Clean up old FD prob.run() # Partials data = prob.check_partial_derivatives(out_stream=None) # data = prob.check_partial_derivatives() for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2["abs error"][0], 0.0, 1e-5) assert_rel_error(self, val2["abs error"][1], 0.0, 1e-5) assert_rel_error(self, val2["abs error"][2], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][0], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][1], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][2], 0.0, 1e-5) assert_rel_error(self, data["comp"][("y", "x")]["J_fwd"][0][0], 1.0, 1e-6) assert_rel_error(self, data["comp"][("y", "z")]["J_fwd"][0][0], 20.0, 1e-6) assert_rel_error(self, data["comp"][("z", "x")]["J_fwd"][0][0], 2.66666667, 1e-6) assert_rel_error(self, data["comp"][("z", "z")]["J_fwd"][0][0], 15.0, 1e-6) # Clean up old FD prob.run() # Make sure check_totals works too data = prob.check_total_derivatives(out_stream=None) for key1, val1 in iteritems(data): assert_rel_error(self, val1["abs error"][0], 0.0, 1e-5) assert_rel_error(self, val1["abs error"][1], 0.0, 1e-5) assert_rel_error(self, val1["abs error"][2], 0.0, 1e-5) assert_rel_error(self, val1["rel error"][0], 0.0, 1e-5) assert_rel_error(self, val1["rel error"][1], 0.0, 1e-5) assert_rel_error(self, val1["rel error"][2], 0.0, 1e-5)
def test_double_diamond_model(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5) self.assertEqual(len(data), 7) # Piggyback a test for the 'comps' option. data = prob.check_partial_derivatives(out_stream=None, comps=['sub1.sub2.comp3', 'comp7']) self.assertEqual(len(data), 2) self.assertTrue('sub1.sub2.comp3' in data) self.assertTrue('comp7' in data) with self.assertRaises(RuntimeError) as cm: data = prob.check_partial_derivatives(out_stream=None, comps=['sub1', 'bogus']) expected_msg = "The following are not valid comp names: ['bogus', 'sub1']" self.assertEqual(str(cm.exception), expected_msg) # This is a good test to piggyback the compact_print test mystream = StringIO() prob.check_partial_derivatives(out_stream=mystream, compact_print=True) text = mystream.getvalue() expected = "'y1' wrt 'x1' | 8.0000e+00 | 8.0000e+00 | 8.0000e+00 | 2.0013e-06 | 2.0013e-06 | 2.5016e-07 | 2.5016e-07" self.assertTrue(expected in text)
def test_double_diamond_model(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5) self.assertEqual(len(data), 7) # Piggyback a test for the 'comps' option. data = prob.check_partial_derivatives(out_stream=None, comps=['sub1.sub2.comp3', 'comp7']) self.assertEqual(len(data), 2) self.assertTrue('sub1.sub2.comp3' in data) self.assertTrue('comp7' in data) with self.assertRaises(RuntimeError) as cm: data = prob.check_partial_derivatives(out_stream=None, comps=['sub1', 'bogus']) expected_msg = "The following are not valid comp names: ['bogus', 'sub1']" self.assertEqual(str(cm.exception), expected_msg) # This is a good test to piggyback the compact_print test mystream = StringIO() prob.check_partial_derivatives(out_stream=mystream, compact_print=True) text = mystream.getvalue() expected = "'y1' wrt 'x1' | 8.0000e+00 | 8.0000e+00 | 8.0000e+00 | 2.0013e-06 | 2.0013e-06 | 2.5016e-07 | 2.5016e-07" self.assertTrue(expected in text)
def test_check_derivs_unknowns(self): class Comp1(Component): def __init__(self): super(Comp1, self).__init__() self.add_param('x', shape=1) self.add_output('y', shape=1) self.add_output('dz_dy', shape=1, pass_by_obj=True) def solve_nonlinear(self, params, unknowns, resids): x = params['x'] unknowns['y'] = 4.0*x + 1.0 unknowns['dz_dy'] = 2.0 def linearize(self, params, unknowns, resids): J = {} J['y', 'x'] = 4.0 return J class Comp2(Component): def __init__(self): super(Comp2, self).__init__() self.add_param('y', shape=1) self.add_param('dz_dy', shape=1, pass_by_obj=True) self.add_output('z', shape=1) def solve_nonlinear(self, params, unknowns, resids): y = params['y'] unknowns['z'] = y*2.0 def linearize(self, params, unknowns, resids): J = {} J['z', 'y'] = params['dz_dy'] return J class TestGroup(Group): def __init__(self): super(TestGroup, self).__init__() self.add('x', IndepVarComp('x', 0.0), promotes=['*']) self.add('c1', Comp1(), promotes=['*']) self.add('c2', Comp2(), promotes=['*']) prob = Problem() prob.root = TestGroup() prob.setup(check=False) prob['x'] = 2.0 prob.run() data = prob.check_partial_derivatives(out_stream=None) self.assertEqual(data['c1'][('y', 'x')]['J_fwd'][0][0], 4.0) self.assertEqual(data['c1'][('y', 'x')]['J_rev'][0][0], 4.0) self.assertEqual(data['c2'][('z', 'y')]['J_fwd'][0][0], 2.0) self.assertEqual(data['c2'][('z', 'y')]['J_rev'][0][0], 2.0) data = prob.check_total_derivatives(out_stream=None) self.assertEqual(data[('z', 'x')]['J_fwd'][0][0], 8.0)
def test_check_derivs_unknowns(self): class Comp1(Component): def __init__(self): super(Comp1, self).__init__() self.add_param('x', shape=1) self.add_output('y', shape=1) self.add_output('dz_dy', shape=1, pass_by_obj=True) def solve_nonlinear(self, params, unknowns, resids): x = params['x'] unknowns['y'] = 4.0 * x + 1.0 unknowns['dz_dy'] = 2.0 def linearize(self, params, unknowns, resids): J = {} J['y', 'x'] = 4.0 return J class Comp2(Component): def __init__(self): super(Comp2, self).__init__() self.add_param('y', shape=1) self.add_param('dz_dy', shape=1, pass_by_obj=True) self.add_output('z', shape=1) def solve_nonlinear(self, params, unknowns, resids): y = params['y'] unknowns['z'] = y * 2.0 def linearize(self, params, unknowns, resids): J = {} J['z', 'y'] = params['dz_dy'] return J class TestGroup(Group): def __init__(self): super(TestGroup, self).__init__() self.add('x', IndepVarComp('x', 0.0), promotes=['*']) self.add('c1', Comp1(), promotes=['*']) self.add('c2', Comp2(), promotes=['*']) prob = Problem() prob.root = TestGroup() prob.setup(check=False) prob['x'] = 2.0 prob.run() data = prob.check_partial_derivatives(out_stream=None) self.assertEqual(data['c1'][('y', 'x')]['J_fwd'][0][0], 4.0) self.assertEqual(data['c1'][('y', 'x')]['J_rev'][0][0], 4.0) self.assertEqual(data['c2'][('z', 'y')]['J_fwd'][0][0], 2.0) self.assertEqual(data['c2'][('z', 'y')]['J_rev'][0][0], 2.0) data = prob.check_total_derivatives(out_stream=None) self.assertEqual(data[('z', 'x')]['J_fwd'][0][0], 8.0)
def test_extra_fd(self): class CSTestComp(Component): def __init__(self): super(CSTestComp, self).__init__() self.add_param( 'x', val=1.5, step_size=1e-2) # pick a big step to make sure FD sucks self.add_output('f', val=0.) def solve_nonlinear(self, p, u, r): x = p['x'] u['f'] = np.exp(x) / np.sqrt(np.sin(x)**3 + np.cos(x)**3) p = Problem() p.root = Group() p.root.add('des_vars', IndepVarComp('x', 1.5), promotes=['*']) c = p.root.add('comp', CSTestComp(), promotes=["*"]) c.fd_options['force_fd'] = True c.fd_options['form'] = "complex_step" c.fd_options['extra_check_partials_form'] = "forward" p.setup(check=False) p.run_once() check_data = p.check_partial_derivatives(out_stream=None) cs_val = check_data['comp']['f', 'x']['J_fd'][ 0, 0] # should be the complex steped value! assert_rel_error(self, cs_val, 4.05289181447, 1e-8) fd2_val = check_data['comp']['f', 'x']['J_fd2'][ 0, 0] # should be the real-fd'd value! assert_rel_error(self, fd2_val, 4.10128351131, 1e-8) # For coverage mystream = StringIO() p.check_partial_derivatives(out_stream=mystream, compact_print=True) text = mystream.getvalue() expected = "'f' wrt 'x' | 4.052892e+00 | 4.101284e+00 | 4.839170e-02 | 1.194004e-02" self.assertTrue(expected in text)
def test_basic_gmres(self): top = Problem() root = top.root = Group() root.add("p", IndepVarComp("x", 2000.0)) root.add("comp1", BasicComp()) root.add("comp2", ExecComp(["y = 2.0*x"])) root.connect("p.x", "comp1.x") root.connect("comp1.y", "comp2.x") top.driver.add_desvar("p.x", 2000.0) top.driver.add_objective("comp2.y") root.ln_solver = ScipyGMRES() top.setup(check=False) top.run() # correct execution assert_rel_error(self, top["comp2.y"], 12000.0, 1e-6) # in-component query is unscaled assert_rel_error(self, root.comp1.store_y, 6000.0, 1e-6) # afterwards direct query is unscaled assert_rel_error(self, root.unknowns["comp1.y"], 6000.0, 1e-6) # OpenMDAO behind-the-scenes query is scaled # (So, internal storage is scaled) assert_rel_error(self, root.unknowns._dat["comp1.y"].val, 6.0, 1e-6) # Correct derivatives J = top.calc_gradient(["p.x"], ["comp2.y"], mode="fwd") assert_rel_error(self, J[0][0], 6.0, 1e-6) J = top.calc_gradient(["p.x"], ["comp2.y"], mode="rev") assert_rel_error(self, J[0][0], 6.0, 1e-6) J = top.calc_gradient(["p.x"], ["comp2.y"], mode="fd") assert_rel_error(self, J[0][0], 6.0, 1e-6) # Clean up old FD top.run() # Make sure check_partials works too data = top.check_partial_derivatives(out_stream=None) # data = top.check_partial_derivatives() for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2["abs error"][0], 0.0, 1e-5) assert_rel_error(self, val2["abs error"][1], 0.0, 1e-5) assert_rel_error(self, val2["abs error"][2], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][0], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][1], 0.0, 1e-5) assert_rel_error(self, val2["rel error"][2], 0.0, 1e-5)
def test_message_root_is_fd(self): p = Problem() p.root = Group() p.root.add('p1', IndepVarComp('x', 1.0)) c = p.root.add('comp', Paraboloid()) p.root.connect('p1.x', 'comp.x') p.root.deriv_options['type'] = 'fd' p.setup(check=False) with self.assertRaises(RuntimeError) as cm: p.check_partial_derivatives() msg = "You cannot run check_partial_derivatives when option 'type' " msg += "in `root` is set to 'fd' or 'cs' because no derivative " msg += "vectors are allocated in that case." self.assertEqual(str(cm.exception), msg)
def test_message_check_types_are_same(self): p = Problem() p.root = Group() p.root.add('p1', IndepVarComp('x', 1.0)) c = p.root.add('comp', Paraboloid()) p.root.connect('p1.x', 'comp.x') p.root.comp.deriv_options['type'] = 'fd' p.root.comp.deriv_options['check_type'] = 'fd' p.setup(check=False) p.run_once() mystream = StringIO() p.check_partial_derivatives(out_stream=mystream) text = mystream.getvalue() expected = 'Skipping because type == check_type.' self.assertTrue(expected in text)
def test_incorrect_jacobian(self): class MyComp(Component): def __init__(self, multiplier=2.0): super(MyComp, self).__init__() # Params self.add_param('x1', 3.0) self.add_param('x2', 5.0) # Unknowns self.add_output('y', 5.5) def solve_nonlinear(self, params, unknowns, resids): """ Doesn't do much. """ unknowns['y'] = 3.0*params['x1'] + 4.0*params['x2'] def linearize(self, params, unknowns, resids): """Intentionally incorrect derivative.""" J = {} J['y', 'x1'] = np.array([4.0]) J['y', 'x2'] = np.array([40]) return J prob = Problem() prob.root = Group() prob.root.add('comp', MyComp()) prob.root.add('p1', IndepVarComp('x1', 3.0)) prob.root.add('p2', IndepVarComp('x2', 5.0)) prob.root.connect('p1.x1', 'comp.x1') prob.root.connect('p2.x2', 'comp.x2') prob.setup(check=False) prob.run() stringstream = StringIO() data = prob.check_partial_derivatives(out_stream=stringstream) lines = stringstream.getvalue().split("\n") y_wrt_x1_line = lines.index(" comp: 'y' wrt 'x1'") self.assertTrue(lines[y_wrt_x1_line+6].endswith('*'), msg='Error flag expected in output but not displayed') self.assertTrue(lines[y_wrt_x1_line+7].endswith('*'), msg='Error flag expected in output but not displayed') self.assertFalse(lines[y_wrt_x1_line+8].endswith('*'), msg='Error flag not expected in output but displayed')
def test_incorrect_jacobian(self): class MyComp(Component): def __init__(self, multiplier=2.0): super(MyComp, self).__init__() # Params self.add_param('x1', 3.0) self.add_param('x2', 5.0) # Unknowns self.add_output('y', 5.5) def solve_nonlinear(self, params, unknowns, resids): """ Doesn't do much. """ unknowns['y'] = 3.0*params['x1'] + 4.0*params['x2'] def linearize(self, params, unknowns, resids): """Intentionally incorrect derivative.""" J = {} J['y', 'x1'] = np.array([4.0]) J['y', 'x2'] = np.array([40]) return J prob = Problem() prob.root = Group() prob.root.add('comp', MyComp()) prob.root.add('p1', IndepVarComp('x1', 3.0)) prob.root.add('p2', IndepVarComp('x2', 5.0)) prob.root.connect('p1.x1', 'comp.x1') prob.root.connect('p2.x2', 'comp.x2') prob.setup(check=False) prob.run() stringstream = StringIO() data = prob.check_partial_derivatives(out_stream=stringstream) lines = stringstream.getvalue().split("\n") y_wrt_x1_line = lines.index(" comp: 'y' wrt 'x1'") self.assertTrue(lines[y_wrt_x1_line+6].endswith('*'), msg='Error flag expected in output but not displayed') self.assertTrue(lines[y_wrt_x1_line+7].endswith('*'), msg='Error flag expected in output but not displayed') self.assertFalse(lines[y_wrt_x1_line+8].endswith('*'), msg='Error flag not expected in output but displayed')
def test_problem_deriv_test(self): prob = Problem() prob.root = Group() prob.root.add('comp', SimpleCompWrongDeriv()) prob.root.add('p1', IndepVarComp('x', 2.0)) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) try: problem_derivatives_check(self, prob) except AssertionError as err: self.assertIn("not less than or equal to 1e-05", err.args[0])
def test_double_diamond_model(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_double_diamond_model(self): prob = Problem() prob.root = ConvergeDivergeGroups() prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_big_boy_Jacobian(self): class MyComp(Component): def __init__(self, multiplier=2.0): super(MyComp, self).__init__() # Params self.add_param('x1', 3.0) self.add_param('x2', 5.0) # Unknowns self.add_output('y', 5.5) def solve_nonlinear(self, params, unknowns, resids): """ Doesn't do much. """ unknowns['y'] = 3.0*params['x1'] + 4.0*params['x2'] def linearize(self, params, unknowns, resids): """Intentionally left out x2 derivative.""" J = {} J[('y', 'x1')] = np.array([[3.0]]) return J prob = Problem() prob.root = Group() prob.root.add('comp', MyComp()) prob.root.add('p1', IndepVarComp('x1', 3.0)) prob.root.add('p2', IndepVarComp('x2', 5.0)) prob.root.connect('p1.x1', 'comp.x1') prob.root.connect('p2.x2', 'comp.x2') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) self.assertTrue(('y', 'x1') in data['comp']) self.assertTrue(('y', 'x2') in data['comp'])
def test_big_boy_Jacobian(self): class MyComp(Component): def __init__(self, multiplier=2.0): super(MyComp, self).__init__() # Params self.add_param('x1', 3.0) self.add_param('x2', 5.0) # Unknowns self.add_output('y', 5.5) def solve_nonlinear(self, params, unknowns, resids): """ Doesn't do much. """ unknowns['y'] = 3.0*params['x1'] + 4.0*params['x2'] def linearize(self, params, unknowns, resids): """Intentionally left out x2 derivative.""" J = {} J[('y', 'x1')] = np.array([[3.0]]) return J prob = Problem() prob.root = Group() prob.root.add('comp', MyComp()) prob.root.add('p1', IndepVarComp('x1', 3.0)) prob.root.add('p2', IndepVarComp('x2', 5.0)) prob.root.connect('p1.x1', 'comp.x1') prob.root.connect('p2.x2', 'comp.x2') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) self.assertTrue(('y', 'x1') in data['comp']) self.assertTrue(('y', 'x2') in data['comp'])
def test_simple_array_model2(self): prob = Problem() prob.root = Group() comp = prob.root.add('comp', ExecComp('y = mat.dot(x)', x=np.zeros((2,)), y=np.zeros((2,)), mat=np.array([[2.,7.],[5.,-3.]]))) p1 = prob.root.add('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) assert_rel_error(self, data['comp'][('y','x')]['abs error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['abs error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['abs error'][2], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['rel error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['rel error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['rel error'][2], 0.0, 1e-5)
def test_simple_array_model(self): prob = Problem() prob.root = Group() prob.root.add('comp', ExecComp(['y[0]=2.0*x[0]+7.0*x[1]', 'y[1]=5.0*x[0]-3.0*x[1]'], x=np.zeros([2]), y=np.zeros([2]))) prob.root.add('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) assert_rel_error(self, data['comp'][('y','x')]['abs error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['abs error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['abs error'][2], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['rel error'][0], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['rel error'][1], 0.0, 1e-5) assert_rel_error(self, data['comp'][('y','x')]['rel error'][2], 0.0, 1e-5)
def test_simple_array_model(self): prob = Problem() prob.root = Group() prob.root.add('comp', SimpleArrayComp()) prob.root.add('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def setUp(self): top = Problem() root = top.root = Group() root.add('p', MyComp()) self.x, self.y, self.A = 3.0, -4.0, np.random.randn(2,2) root.add('p1', IndepVarComp('x', self.x)) root.add('p2', IndepVarComp('y', self.y)) root.add('p3', IndepVarComp('A', self.A)) root.connect('p1.x', 'p.x') root.connect('p2.y', 'p.y') root.connect('p3.A', 'p.A') top.setup(check=False) top.run() self.deriv = top.check_partial_derivatives(out_stream=None)['p']
def test_simple_array_model(self): prob = Problem() prob.root = Group() prob.root.add('comp', SimpleArrayComp()) prob.root.add('p1', IndepVarComp('x', np.ones([2]))) prob.root.connect('p1.x', 'comp.x') prob.setup(check=False) prob.run() data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
prob.setup() t0 = time.time() prob.run() t1 = time.time() #print t1-t0 nodes0 = nodes nodes1 = nodes + prob['disp'] #writeBDF('jig.bdf', nodes0, elements+1) #writeBDF('deflected.bdf', nodes1, elements+1) if 0: prob.check_partial_derivatives(compact_print=True) exit() prob.driver = pyOptSparseDriver() prob.driver.options['optimizer'] = "SNOPT" prob.driver.opt_settings = {'Major optimality tolerance': 1.0e-7, 'Major feasibility tolerance': 1.0e-7, 'Iterations limit': int(1e8), } prob.driver.add_desvar('areas',lower=area_low, upper=area_up, scaler=1e0) # test prob.driver.add_objective('volume', scaler=1e0) prob.driver.add_constraint('minstress', upper=0.) prob.driver.add_constraint('maxstress', upper=0.) prob.driver.add_constraint('neg_stress_plus_buckling_con', upper=0.)
# ('P_generated', np.random.randn(n)**2, {'units' : 'W'}), # ('array_power', 100, {'units' : 'W'}), # ('P_consumption', np.random.randn(n)**2, {'units' : 'W'}), # ('power_capacity', 50.0, {'units' : 'W*h'}), # ) top.root.add("batt", BatteryConstraints(n), promotes=["*"]) top.root.batt.fd_options['form'] = 'complex_step' dvar = (('SOC', np.random.rand(n)), ) # top.root.add("loads", Loads(n), promotes=["*"]) # dvar = ( # ('P_generated', np.random.randn(n) * 4, {'units' : 'W'}), # ('ambient_temperatures', np.random.randn(n)**2, {'units' : 'W'}), # ('irradiance', np.random.randn(n)*20, {'units' : 'W/m**2'}), # ('array_power', 1000.0, {'units' : 'W'}), # ('P_constant', 4.0, {'units' : 'W'}), # ('P_direct', 3.0, {'units' : 'W'}), # ('P_daytime', 2.0, {'units' : 'W'}), # ('P_nighttime', 1.0, {'units' : 'W'}), # ('power_capacity', 50.0, {'units' : 'W*h'}), # ) top.root.add("dvar", IndepVarComp(dvar), promotes=["*"]) top.setup() top.run() top.check_partial_derivatives()
J['thrust', 'Vu'] = 4.0 * a_area_rho_vu * (one_minus_a) J['Cp', 'a'] = 4.0 * a * (2.0 * a - 2.0) + 4.0 * (one_minus_a)**2 J['power', 'a'] = 2.0 * Area * Vu**3 * a * rho * ( 2.0 * a - 2.0) + 2.0 * Area * Vu**3 * rho * one_minus_a**2 J['power', 'Area'] = 2.0 * Vu**3 * a * rho * one_minus_a**2 J['power', 'rho'] = 2.0 * a_times_area * Vu**3 * (one_minus_a)**2 J['power', 'Vu'] = 6.0 * Area * Vu**2 * a * rho * one_minus_a**2 return J if __name__ == "__main__": from openmdao.api import Problem, Group, IndepVarComp prob = Problem() prob.root = Group() prob.root.add('disc', ActuatorDisc(), promotes=['a', 'Area', 'rho', 'Vu']) prob.root.add('p_a', IndepVarComp('a', 0.5), promotes=['*']) prob.root.add('p_Area', IndepVarComp('Area', 10.0), promotes=['*']) prob.root.add('p_rho', IndepVarComp('rho', 1.225), promotes=['*']) prob.root.add('p_Vu', IndepVarComp('Vu', 10.0), promotes=['*']) prob.setup() prob.run() prob.check_partial_derivatives()
def test_apply_linear_units(self): # Make sure we can index into dparams class Attitude_Angular(Component): """ Calculates angular velocity vector from the satellite's orientation matrix and its derivative. """ def __init__(self, n=2): super(Attitude_Angular, self).__init__() self.n = n # Inputs self.add_param( 'O_BI', np.zeros((3, 3, n)), units="ft", desc= "Rotation matrix from body-fixed frame to Earth-centered " "inertial frame over time") self.add_param('Odot_BI', np.zeros((3, 3, n)), units="km", desc="First derivative of O_BI over time") # Outputs self.add_output( 'w_B', np.zeros((3, n)), units="1/s", scaler=12.0, desc="Angular velocity vector in body-fixed frame over time" ) self.dw_dOdot = np.zeros((n, 3, 3, 3)) self.dw_dO = np.zeros((n, 3, 3, 3)) def solve_nonlinear(self, params, unknowns, resids): """ Calculate output. """ O_BI = params['O_BI'] Odot_BI = params['Odot_BI'] w_B = unknowns['w_B'] for i in range(0, self.n): w_B[0, i] = np.dot(Odot_BI[2, :, i], O_BI[1, :, i]) w_B[1, i] = np.dot(Odot_BI[0, :, i], O_BI[2, :, i]) w_B[2, i] = np.dot(Odot_BI[1, :, i], O_BI[0, :, i]) #print(unknowns['w_B']) def linearize(self, params, unknowns, resids): """ Calculate and save derivatives. (i.e., Jacobian) """ O_BI = params['O_BI'] Odot_BI = params['Odot_BI'] for i in range(0, self.n): self.dw_dOdot[i, 0, 2, :] = O_BI[1, :, i] self.dw_dO[i, 0, 1, :] = Odot_BI[2, :, i] self.dw_dOdot[i, 1, 0, :] = O_BI[2, :, i] self.dw_dO[i, 1, 2, :] = Odot_BI[0, :, i] self.dw_dOdot[i, 2, 1, :] = O_BI[0, :, i] self.dw_dO[i, 2, 0, :] = Odot_BI[1, :, i] def apply_linear(self, params, unknowns, dparams, dunknowns, dresids, mode): """ Matrix-vector product with the Jacobian. """ dw_B = dresids['w_B'] if mode == 'fwd': for k in range(3): for i in range(3): for j in range(3): if 'O_BI' in dparams: dw_B[k, :] += self.dw_dO[:, k, i, j] * \ dparams['O_BI'][i, j, :] if 'Odot_BI' in dparams: dw_B[k, :] += self.dw_dOdot[:, k, i, j] * \ dparams['Odot_BI'][i, j, :] else: for k in range(3): for i in range(3): for j in range(3): if 'O_BI' in dparams: dparams['O_BI'][i, j, :] += self.dw_dO[:, k, i, j] * \ dw_B[k, :] if 'Odot_BI' in dparams: dparams['Odot_BI'][i, j, :] -= -self.dw_dOdot[:, k, i, j] * \ dw_B[k, :] prob = Problem() root = prob.root = Group() prob.root.add('comp', Attitude_Angular(n=5), promotes=['*']) prob.root.add('p1', IndepVarComp('O_BI', np.ones((3, 3, 5))), promotes=['*']) prob.root.add('p2', IndepVarComp('Odot_BI', np.ones((3, 3, 5))), promotes=['*']) prob.setup(check=False) prob.run() indep_list = ['O_BI', 'Odot_BI'] unknown_list = ['w_B'] Jf = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') indep_list = ['O_BI', 'Odot_BI'] unknown_list = ['w_B'] Jr = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') for key, val in iteritems(Jr): for key2 in val: diff = abs(Jf[key][key2] - Jr[key][key2]) assert_rel_error(self, diff, 0.0, 1e-10) # Clean up old FD prob.run() # Partials data = prob.check_partial_derivatives(out_stream=None) #data = prob.check_partial_derivatives() for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
prob['Ct_in'] = Ct prob['Cp_in'] = Cp # assign boundary values prob['boundary_center'] = np.array([boundary_center_x, boundary_center_y]) prob['boundary_radius'] = boundary_radius # set options # prob['floris_params:FLORISoriginal'] = True # prob['floris_params:CPcorrected'] = False # prob['floris_params:CTcorrected'] = False prob.run_once() AEP_init = prob['AEP'] # pass results to self for use with unit test Jp = prob.check_partial_derivatives(out_stream=None) Jt = prob.check_total_derivatives(out_stream=None) # run the problem mpi_print(prob, 'start Bastankhah run') tic = time.time() # cProfile.run('prob.run()') prob.run() toc = time.time() # print the results mpi_print(prob, ('Opt. calculation took %.03f sec.' % (toc - tic))) for direction_id in range(0, windDirections.size): mpi_print(prob, 'yaw%i (deg) = ' % direction_id, prob['yaw%i' % direction_id])
def test_apply_linear_units(self): # Make sure we can index into dparams class Attitude_Angular(Component): """ Calculates angular velocity vector from the satellite's orientation matrix and its derivative. """ def __init__(self, n=2): super(Attitude_Angular, self).__init__() self.n = n # Inputs self.add_param('O_BI', np.zeros((3, 3, n)), units="ft", desc="Rotation matrix from body-fixed frame to Earth-centered " "inertial frame over time") self.add_param('Odot_BI', np.zeros((3, 3, n)), units="km", desc="First derivative of O_BI over time") # Outputs self.add_output('w_B', np.zeros((3, n)), units="1/s", scaler=12.0, desc="Angular velocity vector in body-fixed frame over time") self.dw_dOdot = np.zeros((n, 3, 3, 3)) self.dw_dO = np.zeros((n, 3, 3, 3)) def solve_nonlinear(self, params, unknowns, resids): """ Calculate output. """ O_BI = params['O_BI'] Odot_BI = params['Odot_BI'] w_B = unknowns['w_B'] for i in range(0, self.n): w_B[0, i] = np.dot(Odot_BI[2, :, i], O_BI[1, :, i]) w_B[1, i] = np.dot(Odot_BI[0, :, i], O_BI[2, :, i]) w_B[2, i] = np.dot(Odot_BI[1, :, i], O_BI[0, :, i]) #print(unknowns['w_B']) def linearize(self, params, unknowns, resids): """ Calculate and save derivatives. (i.e., Jacobian) """ O_BI = params['O_BI'] Odot_BI = params['Odot_BI'] for i in range(0, self.n): self.dw_dOdot[i, 0, 2, :] = O_BI[1, :, i] self.dw_dO[i, 0, 1, :] = Odot_BI[2, :, i] self.dw_dOdot[i, 1, 0, :] = O_BI[2, :, i] self.dw_dO[i, 1, 2, :] = Odot_BI[0, :, i] self.dw_dOdot[i, 2, 1, :] = O_BI[0, :, i] self.dw_dO[i, 2, 0, :] = Odot_BI[1, :, i] def apply_linear(self, params, unknowns, dparams, dunknowns, dresids, mode): """ Matrix-vector product with the Jacobian. """ dw_B = dresids['w_B'] if mode == 'fwd': for k in range(3): for i in range(3): for j in range(3): if 'O_BI' in dparams: dw_B[k, :] += self.dw_dO[:, k, i, j] * \ dparams['O_BI'][i, j, :] if 'Odot_BI' in dparams: dw_B[k, :] += self.dw_dOdot[:, k, i, j] * \ dparams['Odot_BI'][i, j, :] else: for k in range(3): for i in range(3): for j in range(3): if 'O_BI' in dparams: dparams['O_BI'][i, j, :] += self.dw_dO[:, k, i, j] * \ dw_B[k, :] if 'Odot_BI' in dparams: dparams['Odot_BI'][i, j, :] -= -self.dw_dOdot[:, k, i, j] * \ dw_B[k, :] prob = Problem() root = prob.root = Group() prob.root.add('comp', Attitude_Angular(n=5), promotes=['*']) prob.root.add('p1', IndepVarComp('O_BI', np.ones((3, 3, 5))), promotes=['*']) prob.root.add('p2', IndepVarComp('Odot_BI', np.ones((3, 3, 5))), promotes=['*']) prob.setup(check=False) prob.run() indep_list = ['O_BI', 'Odot_BI'] unknown_list = ['w_B'] Jf = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') indep_list = ['O_BI', 'Odot_BI'] unknown_list = ['w_B'] Jr = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') for key, val in iteritems(Jr): for key2 in val: diff = abs(Jf[key][key2] - Jr[key][key2]) assert_rel_error(self, diff, 0.0, 1e-10) # Clean up old FD prob.run() # Partials data = prob.check_partial_derivatives(out_stream=None) #data = prob.check_partial_derivatives() for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
prob.setup() t0 = time.time() prob.run() t1 = time.time() #print t1-t0 nodes0 = nodes nodes1 = nodes + prob['disp'] writeBDF('jig.bdf', nodes0, elements+1) writeBDF('deflected.bdf', nodes1, elements+1) if 0: prob.check_partial_derivatives(compact_print=True) exit() prob.driver = pyOptSparseDriver() prob.driver.options['optimizer'] = "SNOPT" prob.driver.opt_settings = {'Major optimality tolerance': 1.0e-7, 'Major feasibility tolerance': 1.0e-7, 'Iterations limit': int(1e6), } prob.driver.add_desvar('areas',lower=0.0001, upper=0.1, scaler=1e0) # test prob.driver.add_objective('volume', scaler=1e0) prob.driver.add_constraint('minstress', upper=0.) prob.driver.add_constraint('maxstress', upper=0.) # setup data recording prob.driver.add_recorder(SqliteRecorder('data.db'))
def test_scaler_on_src_with_unit_conversion(self): from openmdao.core.test.test_units import TgtCompC, TgtCompF, TgtCompK class SrcComp(Component): def __init__(self): super(SrcComp, self).__init__() self.add_param("x1", 100.0) self.add_output("x2", 100.0, units="degC", scaler=10.0) def solve_nonlinear(self, params, unknowns, resids): """ No action.""" unknowns["x2"] = params["x1"] def linearize(self, params, unknowns, resids): """ Derivative is 1.0""" J = {} J[("x2", "x1")] = np.array([1.0]) return J prob = Problem() prob.root = Group() prob.root.add("src", SrcComp()) prob.root.add("tgtF", TgtCompF()) prob.root.add("tgtC", TgtCompC()) prob.root.add("tgtK", TgtCompK()) prob.root.add("px1", IndepVarComp("x1", 100.0), promotes=["x1"]) prob.root.connect("x1", "src.x1") prob.root.connect("src.x2", "tgtF.x2") prob.root.connect("src.x2", "tgtC.x2") prob.root.connect("src.x2", "tgtK.x2") prob.setup(check=False) prob.run() assert_rel_error(self, prob["src.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) # Make sure the scale factor is included here, even though no unit conversion self.assertEqual(prob.root.params.metadata("tgtC.x2").get("unit_conv"), (10.0, 0.0)) 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) # Need to clean up after FD gradient call, so just rerun. prob.run() # Make sure check partials handles conversion data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2["abs error"][0], 0.0, 1e-6) assert_rel_error(self, val2["abs error"][1], 0.0, 1e-6) assert_rel_error(self, val2["abs error"][2], 0.0, 1e-6) assert_rel_error(self, val2["rel error"][0], 0.0, 1e-6) assert_rel_error(self, val2["rel error"][1], 0.0, 1e-6) assert_rel_error(self, val2["rel error"][2], 0.0, 1e-6) stream = cStringIO() conv = prob.root.list_unit_conv(stream=stream) self.assertTrue((("src.x2", "tgtF.x2"), ("degC", "degF")) in conv) self.assertTrue((("src.x2", "tgtK.x2"), ("degC", "degK")) in conv)
prob['Ct_in'] = Ct prob['Cp_in'] = Cp # assign boundary values prob['boundary_center'] = np.array([boundary_center_x, boundary_center_y]) prob['boundary_radius'] = boundary_radius # set options # prob['floris_params:FLORISoriginal'] = True # prob['floris_params:CPcorrected'] = False # prob['floris_params:CTcorrected'] = False prob.run_once() AEP_init = prob['AEP'] # pass results to self for use with unit test Jp = prob.check_partial_derivatives(out_stream=None) Jt = prob.check_total_derivatives(out_stream=None) # run the problem mpi_print(prob, 'start Bastankhah run') tic = time.time() # cProfile.run('prob.run()') prob.run() toc = time.time() # print the results mpi_print(prob, ('Opt. calculation took %.03f sec.' % (toc-tic))) for direction_id in range(0, windDirections.size): mpi_print(prob, 'yaw%i (deg) = ' % direction_id, prob['yaw%i' % direction_id]) # for direction_id in range(0, windDirections.size):
def solve_nonlinear(self, params, unknowns, resids): x = params['x'] y = params['y'] A = params['A'] unknowns['f_xy'] = x**2 + y**2 + np.sin(A).sum() unknowns['g_xy'] = np.linalg.dot(A**2, np.array([y, x**2])) if __name__ == "__main__": top = Problem() root = top.root = Group() root.add('p', MyComp()) root.add('p1', IndepVarComp('x', 3.0)) root.add('p2', IndepVarComp('y', -4.0)) root.add('p3', IndepVarComp('A', np.random.randn(2,2))) root.connect('p1.x', 'p.x') root.connect('p2.y', 'p.y') root.connect('p3.A', 'p.A') top.setup(check=False) top.run() # compare auto-generated derivatives against FD top.check_partial_derivatives()
else: raise ValueError( 'unknown uncertain_var option "%s", valid options "speed" or "direction".' % method_dict["uncertain_var"] ) method_dict["dakota_filename"] = "dakotageneral.in" n = 10 unused, weights = getPoints(method_dict, n) prob = Problem(root=Group()) prob.root.add("p", IndepVarComp("dirPowers", np.random.rand(n))) prob.root.add("w", IndepVarComp("windWeights", weights)) if method_dict["method"] == "rect": prob.root.add( "AEPComp", RectStatistics(nDirections=n, method_dict=method_dict) ) # , promotes=['*']) # No need to promote because of the explicit connection below if method_dict["method"] == "dakota": prob.root.add("AEPComp", DakotaStatistics(nDirections=n, method_dict=method_dict)) # , promotes=['*']) prob.root.connect("p.dirPowers", "AEPComp.dirPowers") prob.root.connect("w.windWeights", "AEPComp.windWeights") prob.setup() prob.run() print "AEP = ", (prob.root.AEPComp.unknowns["mean"]) print "power = ", (prob.root.AEPComp.params["dirPowers"]) print prob.root.AEPComp.params.keys() # J = prob.calc_gradient(['AEPComp.mean'], ['p.power']) # I'm not sure why this returns zero # print 'power directions gradient = ', J # This check works data = prob.check_partial_derivatives()
def test_basic_force_fd_comps(self): prob = Problem() prob.root = Group() prob.root.add('src', SrcComp()) prob.root.add('tgtF', TgtCompF()) prob.root.add('tgtC', TgtCompC()) prob.root.add('tgtK', TgtCompK()) prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1']) prob.root.connect('x1', 'src.x1') prob.root.connect('src.x2', 'tgtF.x2') prob.root.connect('src.x2', 'tgtC.x2') prob.root.connect('src.x2', 'tgtK.x2') prob.root.src.deriv_options['type'] = 'fd' prob.root.tgtF.deriv_options['type'] = 'fd' prob.root.tgtC.deriv_options['type'] = 'fd' prob.root.tgtK.deriv_options['type'] = 'fd' prob.setup(check=False) prob.run() assert_rel_error(self, prob['src.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) # Make sure we don't convert equal units self.assertEqual( prob.root.params.metadata('tgtC.x2').get('unit_conv'), None) 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) # Need to clean up after FD gradient call, so just rerun. prob.run() # Make sure check partials handles conversion data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-6) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-6) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-6) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-6) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-6) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-6) stream = cStringIO() conv = prob.root.list_unit_conv(stream=stream) self.assertTrue((('src.x2', 'tgtF.x2'), ('degC', 'degF')) in conv) self.assertTrue((('src.x2', 'tgtK.x2'), ('degC', 'degK')) in conv)
def test_basic(self): prob = Problem() prob.root = Group() prob.root.add('src', SrcComp()) prob.root.add('tgtF', TgtCompF()) prob.root.add('tgtC', TgtCompC()) prob.root.add('tgtK', TgtCompK()) prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1']) prob.root.connect('x1', 'src.x1') prob.root.connect('src.x2', 'tgtF.x2') prob.root.connect('src.x2', 'tgtC.x2') prob.root.connect('src.x2', 'tgtK.x2') prob.setup(check=False) prob.run() assert_rel_error(self, prob['src.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) # Make sure we don't convert equal units self.assertEqual(prob.root.params.metadata('tgtC.x2').get('unit_conv'), None) 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) # Need to clean up after FD gradient call, so just rerun. prob.run() # Make sure check partials handles conversion data = prob.check_partial_derivatives(out_stream=None) for key1, val1 in iteritems(data): for key2, val2 in iteritems(val1): assert_rel_error(self, val2['abs error'][0], 0.0, 1e-6) assert_rel_error(self, val2['abs error'][1], 0.0, 1e-6) assert_rel_error(self, val2['abs error'][2], 0.0, 1e-6) assert_rel_error(self, val2['rel error'][0], 0.0, 1e-6) assert_rel_error(self, val2['rel error'][1], 0.0, 1e-6) assert_rel_error(self, val2['rel error'][2], 0.0, 1e-6) stream = cStringIO() conv = prob.list_unit_conv(stream=stream) self.assertTrue((('src.x2', 'tgtF.x2'), ('degC', 'degF')) in conv) self.assertTrue((('src.x2', 'tgtK.x2'), ('degC', 'degK')) in conv)