示例#1
0
    def test_list_inputs(self):
        prob = SellarProblem()

        prob.model.add_recorder(self.recorder)
        prob.model.recording_options['record_residuals'] = True

        prob.setup()

        d1 = prob.model.d1  # SellarDis1withDerivatives (an ExplicitComp)
        d1.nonlinear_solver = NonlinearBlockGS(maxiter=5)
        d1.add_recorder(self.recorder)

        prob.run_driver()
        prob.cleanup()

        cr = CaseReader(self.filename)

        inputs = cr.list_inputs(None, True, True, True)

        expected_inputs = {
            'obj_cmp.x': {'value': [1.]},
            'd2.z': {'value': [5., 2.]},
            'con_cmp2.y2': {'value': [12.05848815]},
            'obj_cmp.y2': {'value': [12.05848815]},
            'obj_cmp.z': {'value': [5., 2.]},
            'd1.x': {'value': [1.]},
            'd1.z': {'value': [5., 2.]},
            'd1.y2': {'value': [12.05848815]},
            'con_cmp1.y1': {'value': [25.58830237]},
            'obj_cmp.y1': {'value': [25.58830237]},
            'd2.y1': {'value': [25.58830237]}
        }

        self.assertEqual(len(inputs), 11)
        for o in inputs:
            vals = o[1]
            name = o[0]
            expected = expected_inputs[name]
            np.testing.assert_almost_equal(vals['value'], expected['value'])

        expected_inputs_case = {
            'd1.z': {'value': [5., 2.]},
            'd1.x': {'value': [1.]},
            'd1.y2': {'value': [12.27257053]}
        }

        sys_case = cr.system_cases.get_case(1)
        inputs_case = cr.list_inputs(sys_case, True, True, True, None)

        for o in inputs_case:
            vals = o[1]
            name = o[0]
            expected = expected_inputs_case[name]
            np.testing.assert_almost_equal(vals['value'], expected['value'])
示例#2
0
    def test_list_inputs(self):
        self.setup_sellar_model()

        nonlinear_solver = self.prob.model.nonlinear_solver
        linear_solver = self.prob.model.linear_solver

        d1 = self.prob.model.d1  # instance of SellarDis1withDerivatives, a Group
        d1.nonlinear_solver = NonlinearBlockGS()
        d1.nonlinear_solver.options['maxiter'] = 5
        self.prob.model.add_recorder(self.recorder)
        self.prob.model.d1.add_recorder(self.recorder)
        self.prob.model.recording_options['record_residuals'] = True

        self.prob.setup(check=False)
        self.prob.run_driver()
        self.prob.cleanup()

        cr = CaseReader(self.filename)

        inputs = cr.list_inputs(None, True, True, True)

        expected_inputs = {
            'obj_cmp.x': {
                'value': [1.]
            },
            'd2.z': {
                'value': [5., 2.]
            },
            'con_cmp2.y2': {
                'value': [12.05848815]
            },
            'obj_cmp.y2': {
                'value': [12.05848815]
            },
            'obj_cmp.z': {
                'value': [5., 2.]
            },
            'd1.x': {
                'value': [1.]
            },
            'd1.z': {
                'value': [5., 2.]
            },
            'd1.y2': {
                'value': [12.05848815]
            },
            'con_cmp1.y1': {
                'value': [25.58830237]
            },
            'obj_cmp.y1': {
                'value': [25.58830237]
            },
            'd2.y1': {
                'value': [25.58830237]
            }
        }

        self.assertEqual(len(inputs), 11)
        for o in inputs:
            vals = o[1]
            name = o[0]
            expected = expected_inputs[name]
            np.testing.assert_almost_equal(vals['value'], expected['value'])

        expected_inputs_case = {
            'd1.z': {
                'value': [5., 2.]
            },
            'd1.x': {
                'value': [1.]
            },
            'd1.y2': {
                'value': [12.27257053]
            }
        }

        inputs_case = cr.list_inputs(1, True, True, True, None)

        for o in inputs_case:
            vals = o[1]
            name = o[0]
            expected = expected_inputs_case[name]
            np.testing.assert_almost_equal(vals['value'], expected['value'])