def test_conflicting_connections(self): # verify we get an error if we have conflicting implicit and explicit connections root = Group() # promoting G1.x will create an implicit connection to G3.x # this is a conflict because G3.x (aka G3.C4.x) is already connected # to G3.C3.x G2 = root.add('G2', Group(), promotes=['x']) # BAD PROMOTE G2.add('C1', IndepVarComp('x', 5.), promotes=['x']) G1 = G2.add('G1', Group(), promotes=['x']) G1.add('C2', ExecComp('y=x*2.0'), promotes=['x']) G3 = root.add('G3', Group(), promotes=['x']) G3.add('C3', ExecComp('y=x*2.0')) G3.add('C4', ExecComp('y=x*2.0'), promotes=['x']) root.connect('G2.G1.C2.y', 'G3.C3.x') G3.connect('C3.y', 'x') prob = Problem(root) try: prob.setup(check=False) except Exception as error: msg = "Target 'G3.C4.x' is connected to multiple unknowns: ['G2.C1.x', 'G3.C3.y']" self.assertEqual(text_type(error), msg) else: self.fail("Error expected")
def test_generate_numpydocstring(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 = ScipyGMRES() test_string = prob.root.ln_solver.generate_docstring() original_string = \ """ \"\"\" Options ------- options['atol'] : float(1e-12) Absolute convergence tolerance. options['err_on_maxiter'] : bool(False) If True, raise an AnalysisError if not converged at maxiter. options['iprint'] : int(0) Set to 0 to disable printing, set to 1 to print the residual to stdout each iteration, set to 2 to print subiteration residuals as well. options['maxiter'] : int(1000) Maximum number of iterations. options['mode'] : str('auto') Derivative calculation mode, set to 'fwd' for forward mode, 'rev' for reverse mode, or 'auto' to let OpenMDAO determine the best mode. options['restart'] : int(20) Number of iterations between restarts. Larger values increase iteration cost, but may be necessary for convergence \"\"\" """ for sorig, stest in zip(original_string.split('\n'), test_string.split('\n')): self.assertEqual(sorig, stest)
def test_double_arraycomp(self): # Mainly testing a bug in the array return for multiple arrays group = Group() group.add('x_param1', IndepVarComp('x1', np.ones((2))), promotes=['*']) group.add('x_param2', IndepVarComp('x2', np.ones((2))), promotes=['*']) group.add('mycomp', DoubleArrayComp(), promotes=['*']) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() 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_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 example(): # simple test of module root = Group() root.add('bos_opex_test', FUSED_OpenMDAO(opex_csm_fused()), promotes=['*']) prob = Problem(root) prob.setup() prob[ 'machine_rating'] = 5000.0 # Need to manipulate input or underlying cprob[onent will not execute prob['net_aep'] = 1701626526.28 prob['sea_depth'] = 20.0 prob['year'] = 2009 prob['month'] = 12 prob['turbine_number'] = 100 prob.run() print( "Average annual operational expenditures for an offshore wind plant with 100 NREL 5 MW turbines" ) for io in root.unknowns: print(io + ' ' + str(root.unknowns[io])) prob['sea_depth'] = 0.0 prob.run() print( "Average annual operational expenditures for an land-based wind plant with 100 NREL 5 MW turbines" ) for io in root.unknowns: print(io + ' ' + str(root.unknowns[io]))
def test_simple_matvec(self): class VerificationComp(SimpleCompDerivMatVec): def linearize(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_simple_matvec(self): class VerificationComp(SimpleCompDerivMatVec): def linearize(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 example(): # openmdao example of execution root = Group() root.add('bos_csm_test', FUSED_OpenMDAO(bos_csm_fused()), promotes=['*']) prob = Problem(root) prob.setup() prob['machine_rating'] = 5000.0 prob['rotor_diameter'] = 126.0 prob['turbine_cost'] = 5950209.28 prob['hub_height'] = 90.0 prob['RNA_mass'] = 256634.5 # RNA mass is not used in this simple model prob['turbine_number'] = 100 prob['sea_depth'] = 20.0 prob['year'] = 2009 prob['month'] = 12 prob['multiplier'] = 1.0 prob.run() print( "Balance of Station Costs for an offshore wind plant with 100 NREL 5 MW turbines" ) for io in root.unknowns: print(io + ' ' + str(root.unknowns[io])) prob['sea_depth'] = 0.0 prob['turbine_cost'] = 5229222.77 prob.run() print( "Balance of Station Costs for an land-based wind plant with 100 NREL 5 MW turbines" ) for io in root.unknowns: print(io + ' ' + str(root.unknowns[io]))
def test_case1_vs_npss(self): root = Group() root.add('p', breakpoint_levitation.BreakPointDrag()) root.add('q', breakpoint_levitation.MagMass()) prob = Problem(root) prob.setup() prob['p.m_pod'] = 3000.0 prob['p.b_res'] = 1.48 prob['p.num_mag_hal'] = 4.0 prob['p.mag_thk'] = .15 prob['p.l_pod'] = 22.0 prob['p.gamma'] = 1.0 prob['p.w_mag'] = 3.0 prob['p.spacing'] = 0.0 prob['p.d_pod'] = 1.0 prob['p.w_strip'] = .005 prob['p.num_sheets'] = 1.0 prob['p.delta_c'] = .0005334 prob['p.strip_c'] = .0105 prob['p.rc'] = 1.713e-8 prob['p.MU0'] = 4.0 * np.pi * (1.0e-7) prob['p.track_factor'] = .75 prob['p.vel_b'] = 23.0 prob['p.h_lev'] = .01 prob['p.g'] = 9.81 prob['q.m_pod'] = 3000.0 prob['q.mag_thk'] = .15 prob['q.rho_mag'] = 7500.0 prob['q.l_pod'] = 22.0 prob['q.gamma'] = 1.0 prob['q.cost_per_kg'] = 44.0 prob['q.w_mag'] = 3.0 prob['q.d_pod'] = 1.0 prob['q.track_factor'] = .75 prob.run() # Print Statement for debugging # print('track_ind is %12.12f' % prob['comp.Drag.track_ind']) # Test Values assert np.isclose(prob['q.mag_area'], 16.500000, rtol=.01) assert np.isclose(prob['q.m_mag'], 18562.500000, rtol=.01) assert np.isclose(prob['q.cost'], 816750.000000, rtol=.01) assert np.isclose(prob['q.total_pod_mass'], 21562.500000, rtol=.01) assert np.isclose(prob['p.lam'], 0.600000, rtol=.01) assert np.isclose(prob['p.track_ind'], 4.28571e-6, rtol=.01) assert np.isclose(prob['p.b0'], 1.055475, rtol=.01) assert np.isclose(prob['p.mag_area'], 16.500000, rtol=.01) assert np.isclose(prob['p.omegab'], 240.855437, rtol=.01) assert np.isclose(prob['p.w_track'], .75, rtol=.01) assert np.isclose(prob['p.fyu'], 520814.278077, rtol=.01) assert np.isclose(prob['p.fxu'], 2430517.899848, rtol=.01) assert np.isclose(prob['p.ld_ratio'], 0.214281, rtol=.01) assert np.isclose(prob['p.pod_weight'], 29430.000000, rtol=.01) assert np.isclose(prob['p.track_res'], 0.004817, rtol=.01)
def example_turbine(): # openmdao example of execution root = Group() root.add('tcc_csm_test', FUSED_OpenMDAO(tcc_csm_fused()), promotes=['*']) prob = Problem(root) prob.setup() # simple test of module prob['rotor_diameter'] = 126.0 prob['blade_number'] = 3 prob['hub_height'] = 90.0 prob['machine_rating'] = 5000.0 # Rotor force calculations for nacelle inputs maxTipSpd = 80.0 maxEfficiency = 0.90201 ratedWindSpd = 11.5064 thrustCoeff = 0.50 airDensity = 1.225 ratedHubPower = prob['machine_rating'] / maxEfficiency rotorSpeed = (maxTipSpd/(0.5*prob['rotor_diameter'])) * (60.0 / (2*np.pi)) prob['rotor_thrust'] = airDensity * thrustCoeff * np.pi * prob['rotor_diameter']**2 * (ratedWindSpd**2) / 8 prob['rotor_torque'] = ratedHubPower/(rotorSpeed*(np.pi/30))*1000 prob['year'] = 2009 prob['month'] = 12 prob.run() print("The results for the NREL 5 MW Reference Turbine in an offshore 20 m water depth location are:") for io in root.unknowns: print(io + ' ' + str(root.unknowns[io]))
def example_finance(): # simple test of module # openmdao example of execution root = Group() root.add('fin_csm_test', FUSED_OpenMDAO(fin_csm_fused(fixed_charge_rate = 0.12, construction_finance_rate=0.0, tax_rate = 0.4, discount_rate = 0.07, \ construction_time = 1.0, project_lifetime = 20.0, sea_depth = 20.0)), promotes=['*']) prob = Problem(root) prob.setup() prob['turbine_cost'] = 6087803.555 / 50 prob['turbine_number'] = 50 preventative_opex = 401819.023 lease_opex = 22225.395 corrective_opex = 91048.387 prob['avg_annual_opex'] = preventative_opex + corrective_opex + lease_opex prob['bos_costs'] = 7668775.3 prob['net_aep'] = 15756299.843 prob['sea_depth'] = 20.0 prob.run() print( "Overall cost of energy for an offshore wind plant with 100 NREL 5 MW turbines" ) for io in root.unknowns: print(io + ' ' + str(root.unknowns[io]))
def test_double_arraycomp(self): # Mainly testing a bug in the array return for multiple arrays group = Group() group.add('x_param1', IndepVarComp('x1', np.ones((2))), promotes=['*']) group.add('x_param2', IndepVarComp('x2', np.ones((2))), promotes=['*']) group.add('mycomp', DoubleArrayComp(), promotes=['*']) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() 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_case1_vs_npss(self): root = Group() root.add('p', breakpoint_levitation.BreakPointDrag()) root.add('q', breakpoint_levitation.MagMass()) prob = Problem(root) prob.setup() prob['p.m_pod'] = 3000.0 prob['p.b_res'] = 1.48 prob['p.num_mag_hal'] = 4.0 prob['p.mag_thk'] = .15 prob['p.l_pod'] = 22.0 prob['p.gamma'] = 1.0 prob['p.w_mag'] = 3.0 prob['p.spacing'] = 0.0 prob['p.d_pod'] = 1.0 prob['p.w_strip'] = .005 prob['p.num_sheets'] = 1.0 prob['p.delta_c'] = .0005334 prob['p.strip_c'] = .0105 prob['p.rc'] = 1.713e-8 prob['p.MU0'] = 4.0*np.pi*(1.0e-7) prob['p.track_factor'] = .75 prob['p.vel_b'] = 23.0 prob['p.h_lev'] = .01 prob['p.g'] = 9.81 prob['q.m_pod'] = 3000.0 prob['q.mag_thk'] = .15 prob['q.rho_mag'] = 7500.0 prob['q.l_pod'] = 22.0 prob['q.gamma'] = 1.0 prob['q.cost_per_kg'] = 44.0 prob['q.w_mag'] = 3.0 prob['q.d_pod'] = 1.0 prob['q.track_factor'] = .75 prob.run() # Print Statement for debugging # print('track_ind is %12.12f' % prob['comp.Drag.track_ind']) # Test Values assert np.isclose(prob['q.mag_area'], 16.500000, rtol = .01) assert np.isclose(prob['q.m_mag'], 18562.500000, rtol = .01) assert np.isclose(prob['q.cost'], 816750.000000, rtol = .01) assert np.isclose(prob['q.total_pod_mass'], 21562.500000, rtol = .01) assert np.isclose(prob['p.lam'], 0.600000, rtol = .01) assert np.isclose(prob['p.track_ind'], 4.28571e-6, rtol = .01) assert np.isclose(prob['p.b0'], 1.055475, rtol = .01) assert np.isclose(prob['p.mag_area'], 16.500000, rtol = .01) assert np.isclose(prob['p.omegab'], 240.855437, rtol = .01) assert np.isclose(prob['p.w_track'], .75, rtol = .01) assert np.isclose(prob['p.fyu'], 520814.278077, rtol = .01) assert np.isclose(prob['p.fxu'], 2430517.899848, rtol = .01) assert np.isclose(prob['p.ld_ratio'], 0.214281, rtol = .01) assert np.isclose(prob['p.pod_weight'], 29430.000000, rtol = .01) assert np.isclose(prob['p.track_res'], 0.004817, rtol = .01)
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_conflicting_connections(self): # verify we get an error if we have conflicting implicit and explicit connections root = Group() # promoting G1.x will create an implicit connection to G3.x # this is a conflict because G3.x (aka G3.C4.x) is already connected # to G3.C3.x G2 = root.add('G2', Group(), promotes=['x']) # BAD PROMOTE G2.add('C1', IndepVarComp('x', 5.), promotes=['x']) G1 = G2.add('G1', Group(), promotes=['x']) G1.add('C2', ExecComp('y=x*2.0'), promotes=['x']) G3 = root.add('G3', Group(), promotes=['x']) G3.add('C3', ExecComp('y=x*2.0')) G3.add('C4', ExecComp('y=x*2.0'), promotes=['x']) root.connect('G2.G1.C2.y', 'G3.C3.x') G3.connect('C3.y', 'x') prob = Problem(root) try: prob.setup(check=False) except Exception as error: msg = "Target 'G3.C4.x' is connected to multiple unknowns: ['G2.C1.x', 'G3.C3.y']" self.assertTrue(msg in str(error)) else: self.fail("Error expected")
def test_generate_numpydocstring(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 = ScipyGMRES() test_string = prob.root.ln_solver.generate_docstring() original_string = """ \"\"\" Options ------- options['atol'] : float(1e-12) Absolute convergence tolerance. options['err_on_maxiter'] : bool(False) If True, raise an AnalysisError if not converged at maxiter. options['iprint'] : int(0) Set to 0 to disable printing, set to 1 to print iteration totals to stdout, set to 2 to print the residual each iteration to stdout. options['maxiter'] : int(1000) Maximum number of iterations. options['mode'] : str('auto') Derivative calculation mode, set to 'fwd' for forward mode, 'rev' for reverse mode, or 'auto' to let OpenMDAO determine the best mode. options['restart'] : int(20) Number of iterations between restarts. Larger values increase iteration cost, but may be necessary for convergence \"\"\" """ for sorig, stest in zip(original_string.split("\n"), test_string.split("\n")): self.assertEqual(sorig, stest)
def test_double_arraycomp(self): # Mainly testing a bug in the array return for multiple arrays group = Group() group.add("x_param1", IndepVarComp("x1", np.ones((2))), promotes=["*"]) group.add("x_param2", IndepVarComp("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_conflicting_promotions(self): # verify we get an error if we have conflicting promotions root = Group() # promoting G1.x will create an implicit connection to G3.x # this is a conflict because G3.x (aka G3.C4.x) is already connected # to G3.C3.x G2 = root.add('G2', Group()) G2.add('C1', IndepVarComp('x', 5.), promotes=['x']) G1 = G2.add('G1', Group(), promotes=['x']) G1.add('C2', ExecComp('y=x*2.0'), promotes=['x']) G3 = root.add('G3', Group(), promotes=['x']) G3.add('C3', ExecComp('y=x*2.0'), promotes=['y']) # promoting y G3.add('C4', ExecComp('y=x*2.0'), promotes=['x', 'y']) # promoting y again.. BAD prob = Problem(root) try: prob.setup(check=False) except Exception as error: msg = "'G3': promoted name 'y' matches multiple unknowns: ('G3.C3.y', 'G3.C4.y')" self.assertEqual(text_type(error), msg) else: self.fail("Error expected")
def test_conflicting_promotions(self): # verify we get an error if we have conflicting promotions root = Group() # promoting G1.x will create an implicit connection to G3.x # this is a conflict because G3.x (aka G3.C4.x) is already connected # to G3.C3.x G2 = root.add('G2', Group()) G2.add('C1', IndepVarComp('x', 5.), promotes=['x']) G1 = G2.add('G1', Group(), promotes=['x']) G1.add('C2', ExecComp('y=x*2.0'), promotes=['x']) G3 = root.add('G3', Group(), promotes=['x']) G3.add('C3', ExecComp('y=x*2.0'), promotes=['y']) # promoting y G3.add('C4', ExecComp('y=x*2.0'), promotes=['x', 'y']) # promoting y again.. BAD prob = Problem(root) try: prob.setup(check=False) except Exception as error: msg = "'G3': promoted name 'y' matches multiple unknowns: ('G3.C3.y', 'G3.C4.y')" self.assertEqual(text_type(error), msg) else: self.fail("Error expected")
def test_case1_vs_inductrack(self): root = Group() root.add('lev', levitation_group.LevGroup()) prob = Problem(root) params = (('m_pod', 3000.0, {'units': 'kg'}), ('l_pod', 22.0, {'units': 'm'}), ('d_pod', 1.0, {'units': 'm'}), ('vel_b', 23.0, {'units': 'm/s'}), ('h_lev', 0.01, {'unit': 'm'}), ('vel', 350.0, {'units': 'm/s'})) prob.root.add('input_vars', IndepVarComp(params)) prob.root.connect('input_vars.m_pod', 'lev.m_pod') prob.root.connect('input_vars.l_pod', 'lev.l_pod') prob.root.connect('input_vars.d_pod', 'lev.d_pod') prob.root.connect('input_vars.vel_b', 'lev.vel_b') prob.root.connect('input_vars.h_lev', 'lev.h_lev') prob.root.connect('input_vars.vel', 'lev.vel') prob.setup() prob['lev.Drag.b_res'] = 1.48 prob['lev.Drag.num_mag_hal'] = 4.0 prob['lev.Drag.gamma'] = 1.0 prob['lev.Drag.w_mag'] = 3.0 prob['lev.Drag.spacing'] = 0.0 prob['lev.Drag.w_strip'] = .005 prob['lev.Drag.num_sheets'] = 1.0 prob['lev.Drag.delta_c'] = .0005334 prob['lev.Drag.strip_c'] = .0105 prob['lev.Drag.rc'] = 1.713e-8 prob['lev.Drag.MU0'] = 4.0*np.pi*(1.0e-7) prob['lev.Drag.track_factor'] = .75 prob['lev.Drag.g'] = 9.81 prob['lev.Drag.mag_thk'] = .15 prob['lev.Mass.mag_thk'] = .15 prob['lev.Mass.rho_mag'] = 7500.0 prob['lev.Mass.gamma'] = 1.0 prob['lev.Mass.cost_per_kg'] = 44.0 prob['lev.Mass.w_mag'] = 3.0 prob['lev.Mass.track_factor'] = .75 prob.run() # Print Statements for debugging # print('Mag Mass %f' % prob['lev.m_mag']) # print('Mag Drag is %f' % prob['lev.mag_drag']) # Test Values assert np.isclose(prob['lev.mag_drag'], 9025.39, rtol=.01) assert np.isclose(prob['lev.total_pod_mass'], 21562.50, rtol=.01)
def test_bad_sysname(self): group = Group() try: group.add('0', ExecComp('y=x*2.0'), promotes=['x']) except NameError as err: self.assertEqual(str(err), ": '0' is not a valid system name.") try: group.add('foo:bar', ExecComp('y=x*2.0'), promotes=['x']) except NameError as err: self.assertEqual(str(err), ": 'foo:bar' is not a valid system name.")
def test_bad_sysname(self): group = Group() try: group.add("0", ExecComp("y=x*2.0"), promotes=["x"]) except NameError as err: self.assertEqual(str(err), ": '0' is not a valid system name.") try: group.add("foo:bar", ExecComp("y=x*2.0"), promotes=["x"]) except NameError as err: self.assertEqual(str(err), ": 'foo:bar' is not a valid system name.")
def test_bad_sysname(self): group = Group() try: group.add('0', ExecComp('y=x*2.0'), promotes=['x']) except NameError as err: self.assertEqual(str(err), ": '0' is not a valid system name.") try: group.add('foo:bar', ExecComp('y=x*2.0'), promotes=['x']) except NameError as err: self.assertEqual(str(err), ": 'foo:bar' is not a valid system name.")
def test_multiple_connect_alt(self): root = Group() C1 = root.add('C1', ExecComp('y=x*2.0')) C2 = root.add('C2', ExecComp('y=x*2.0')) C3 = root.add('C3', ExecComp('y=x*2.0')) with self.assertRaises(TypeError) as err: root.connect('C1.y', 'C2.x', 'C3.x') msg = "src_indices must be an index array, did you mean connect('C1.y', ['C2.x', 'C3.x'])?" self.assertEqual(msg, str(err.exception))
def test_multiple_connect_alt(self): root = Group() C1 = root.add("C1", ExecComp("y=x*2.0")) C2 = root.add("C2", ExecComp("y=x*2.0")) C3 = root.add("C3", ExecComp("y=x*2.0")) with self.assertRaises(TypeError) as err: root.connect("C1.y", "C2.x", "C3.x") msg = "src_indices must be an index array, did you mean connect('C1.y', ['C2.x', 'C3.x'])?" self.assertEqual(msg, str(err.exception))
def test_calc_gradient(self): root = Group() root.add('indep', IndepVarComp('x', np.array([1., 1., 1., 1.]))) root.add('comp', RosenSuzuki()) root.connect('indep.x', 'comp.x') subprob = Problem(root) subprob.driver.add_desvar('indep.x', lower=-10, upper=99) subprob.driver.add_objective('comp.f') subprob.driver.add_constraint('comp.g', upper=0.) prob = Problem(root=Group()) prob.root.add('desvars', IndepVarComp('x', np.ones(4))) prob.root.add('subprob', SubProblem(subprob, params=['indep.x'], unknowns=['comp.f', 'comp.g'])) prob.root.connect('desvars.x', 'subprob.indep.x') prob.setup(check=False) prob.run() indep_list = ['desvars.x'] unknown_list = ['subprob.comp.f', 'subprob.comp.g'] # check that calc_gradient returns proper dict value when mode is 'fwd' J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_almost_equal(J['subprob.comp.f']['desvars.x'], expectedJ['subprob.comp.f']['desvars.x']) assert_almost_equal(J['subprob.comp.g']['desvars.x'], expectedJ['subprob.comp.g']['desvars.x']) # check that calc_gradient returns proper array value when mode is 'fwd' J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='array') assert_almost_equal(J, expectedJ_array) # check that calc_gradient returns proper dict value when mode is 'rev' J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') assert_almost_equal(J['subprob.comp.f']['desvars.x'], expectedJ['subprob.comp.f']['desvars.x']) assert_almost_equal(J['subprob.comp.g']['desvars.x'], expectedJ['subprob.comp.g']['desvars.x']) # check that calc_gradient returns proper array value when mode is 'rev' J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='array') assert_almost_equal(J, expectedJ_array) # check that calc_gradient returns proper dict value when mode is 'fd' J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='dict') assert_almost_equal(J['subprob.comp.f']['desvars.x'], expectedJ['subprob.comp.f']['desvars.x'], decimal=5) assert_almost_equal(J['subprob.comp.g']['desvars.x'], expectedJ['subprob.comp.g']['desvars.x'], decimal=5) # check that calc_gradient returns proper array value when mode is 'fd' J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='array') assert_almost_equal(J, expectedJ_array, decimal=5)
def test_generate_numpydocstring(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 = ScipyGMRES() test_string = prob.root.ln_solver.generate_docstring() original_string = ' """\n\n Options\n -------\n options[\'atol\'] : float(1e-12)\n Absolute convergence tolerance.\n options[\'iprint\'] : int(0)\n Set to 0 to disable printing, set to 1 to print the residual to stdout each iteration, set to 2 to print subiteration residuals as well.\n options[\'maxiter\'] : int(1000)\n Maximum number of iterations.\n options[\'mode\'] : str(\'auto\')\n Derivative calculation mode, set to \'fwd\' for forward mode, \'rev\' for reverse mode, or \'auto\' to let OpenMDAO determine the best mode.\n options[\'precondition\'] : bool(False)\n Set to True to turn on preconditioning.\n options[\'restart\'] : int(20)\n Number of iterations between restarts. Larger values increase iteration cost, but may be necessary for convergence\n\n """\n' self.assertEqual(original_string, test_string)
def test_calc_gradient_with_qoi_indices(self): q_idxs = [0, 2] root = Group() root.add('parm', IndepVarComp('x', np.array([1., 1., 1., 1.]))) root.add('comp', RosenSuzuki()) root.connect('parm.x', 'comp.x') prob = Problem(root) prob.driver.add_desvar('parm.x', lower=-10, upper=99) prob.driver.add_objective('comp.f') prob.driver.add_constraint('comp.g', upper=0., indices=q_idxs) prob.setup(check=False) prob.run() indep_list = ['parm.x'] unknown_list = ['comp.f', 'comp.g'] # override expected array value to reflect qoi indices expectedJ_array = np.concatenate(( expectedJ['comp.f']['parm.x'], expectedJ['comp.g']['parm.x'][q_idxs, :] )) # check that calc_gradient returns proper dict value when mode is 'fwd' J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict') assert_almost_equal(J['comp.f']['parm.x'], expectedJ['comp.f']['parm.x']) assert_almost_equal(J['comp.g']['parm.x'], expectedJ['comp.g']['parm.x'][q_idxs, :]) # check that calc_gradient returns proper array value when mode is 'fwd' J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='array') assert_almost_equal(J, expectedJ_array) # check that calc_gradient returns proper dict value when mode is 'rev' J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict') assert_almost_equal(J['comp.f']['parm.x'], expectedJ['comp.f']['parm.x']) assert_almost_equal(J['comp.g']['parm.x'], expectedJ['comp.g']['parm.x'][q_idxs, :]) # check that calc_gradient returns proper array value when mode is 'rev' J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='array') assert_almost_equal(J, expectedJ_array) # check that calc_gradient returns proper dict value when mode is 'fd' J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='dict') assert_almost_equal(J['comp.f']['parm.x'], expectedJ['comp.f']['parm.x'], decimal=5) assert_almost_equal(J['comp.g']['parm.x'], expectedJ['comp.g']['parm.x'][q_idxs, :], decimal=5) # check that calc_gradient returns proper array value when mode is 'fd' J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='array') assert_almost_equal(J, expectedJ_array, decimal=5)
def test_variables(self): group = Group() group.add('C1', ExecComp('y=x*2.0'), promotes=['x']) group.add("C2", ExecComp('y=x*2.0'), promotes=['y']) prob = Problem() # paths must be initialized prior to calling _setup_variables group._init_sys_data('', prob._probdata) params_dict, unknowns_dict = group._setup_variables() self.assertEqual(list(params_dict.keys()), ['C1.x', 'C2.x']) self.assertEqual(list(unknowns_dict.keys()), ['C1.y', 'C2.y']) self.assertEqual([m['promoted_name'] for n,m in params_dict.items()], ['x', 'C2.x']) self.assertEqual([m['promoted_name'] for n,m in unknowns_dict.items()], ['C1.y', 'y'])
def test_simple_jac(self): group = Group() group.add("x_param", IndepVarComp("x", 1.0), promotes=["*"]) group.add("mycomp", ExecComp(["y=2.0*x"]), promotes=["x", "y"]) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() 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(self): group = Group() group.add('x_param', IndepVarComp('x', 1.0), promotes=['*']) group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() 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', IndepVarComp('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_multiple_connect(self): root = Group() C1 = root.add("C1", ExecComp("y=x*2.0")) C2 = root.add("C2", ExecComp("y=x*2.0")) C3 = root.add("C3", ExecComp("y=x*2.0")) root.connect("C1.y", ["C2.x", "C3.x"]) prob = Problem() root._init_sys_data("", prob._probdata) params_dict, unknowns_dict = root._setup_variables() # verify we get correct connection information connections = root._get_explicit_connections() expected_connections = {"C2.x": [("C1.y", None)], "C3.x": [("C1.y", None)]} self.assertEqual(connections, expected_connections)
def test_variables(self): group = Group() group.add("C1", ExecComp("y=x*2.0"), promotes=["x"]) group.add("C2", ExecComp("y=x*2.0"), promotes=["y"]) prob = Problem(root=group) prob.setup(check=False) params_dict = prob.root._params_dict unknowns_dict = prob.root._unknowns_dict self.assertEqual(list(params_dict.keys()), ["C1.x", "C2.x"]) self.assertEqual(list(unknowns_dict.keys()), ["C1.y", "C2.y"]) to_prom_name = prob.root._sysdata.to_prom_name self.assertEqual([to_prom_name[n] for n in params_dict], ["x", "C2.x"]) self.assertEqual([to_prom_name[n] for n in unknowns_dict], ["C1.y", "y"])
def test_variables(self): group = Group() group.add('C1', ExecComp('y=x*2.0'), promotes=['x']) group.add("C2", ExecComp('y=x*2.0'), promotes=['y']) prob = Problem(root=group) prob.setup(check=False) params_dict = prob.root._params_dict unknowns_dict = prob.root._unknowns_dict self.assertEqual(list(params_dict.keys()), ['C1.x', 'C2.x']) self.assertEqual(list(unknowns_dict.keys()), ['C1.y', 'C2.y']) to_prom_name = prob.root._sysdata.to_prom_name self.assertEqual([to_prom_name[n] for n in params_dict], ['x', 'C2.x']) self.assertEqual([to_prom_name[n] for n in unknowns_dict], ['C1.y', 'y'])
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 = 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_simple_jac(self): group = Group() group.add('x_param', IndepVarComp('x', 1.0), promotes=['*']) group.add('mycomp', ExecComp(['y=2.0*x']), promotes=['x', 'y']) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() 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_linear_system(self): root = Group() lingrp = root.add('lingrp', Group(), promotes=['*']) lingrp.add('lin', LinearSystem(3)) lingrp.ln_solver = ScipyGMRES() x = np.array([1, 2, -3]) A = np.array([[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]]) b = A.dot(x) root.add('p1', IndepVarComp('A', A)) root.add('p2', IndepVarComp('b', b)) root.connect('p1.A', 'lin.A') root.connect('p2.b', 'lin.b') prob = Problem(root) prob.setup(check=False) prob.run() # Make sure it gets the right answer assert_rel_error(self, prob['lin.x'], x, .0001) assert_rel_error(self, np.linalg.norm(prob.root.resids.vec), 0.0, 1e-10) # Compare against calculated derivs Ainv = np.linalg.inv(A) dx_dA = np.outer(Ainv, -x).reshape(3, 9) dx_db = Ainv J = prob.calc_gradient(['p1.A', 'p2.b'], ['lin.x'], mode='fwd', return_format='dict') assert_rel_error(self, J['lin.x']['p1.A'], dx_dA, .0001) assert_rel_error(self, J['lin.x']['p2.b'], dx_db, .0001) J = prob.calc_gradient(['p1.A', 'p2.b'], ['lin.x'], mode='rev', return_format='dict') assert_rel_error(self, J['lin.x']['p1.A'], dx_dA, .0001) assert_rel_error(self, J['lin.x']['p2.b'], dx_db, .0001) J = prob.calc_gradient(['p1.A', 'p2.b'], ['lin.x'], mode='fd', return_format='dict') assert_rel_error(self, J['lin.x']['p1.A'], dx_dA, .0001) assert_rel_error(self, J['lin.x']['p2.b'], dx_db, .0001)
def test_simple_choose_different_alg(self): group = Group() group.add('x_param', IndepVarComp('x', 1.0), promotes=['*']) group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() prob.root.ln_solver.options['ksp_type'] = 'gmres' 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_choose_different_alg(self): group = Group() group.add("x_param", IndepVarComp("x", 1.0), promotes=["*"]) group.add("mycomp", SimpleCompDerivMatVec(), promotes=["x", "y"]) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() prob.root.ln_solver.options["ksp_type"] = "gmres" 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_variables(self): group = Group() group.add('C1', ExecComp('y=x*2.0'), promotes=['x']) group.add("C2", ExecComp('y=x*2.0'), promotes=['y']) prob = Problem(root=group) prob.setup(check=False) params_dict = prob.root._params_dict unknowns_dict = prob.root._unknowns_dict self.assertEqual(list(params_dict.keys()), ['C1.x', 'C2.x']) self.assertEqual(list(unknowns_dict.keys()), ['C1.y', 'C2.y']) to_prom_name = prob.root._sysdata.to_prom_name self.assertEqual([to_prom_name[n] for n in params_dict], ['x', 'C2.x']) self.assertEqual([to_prom_name[n] for n in unknowns_dict], ['C1.y', 'y'])
def example(): root = Group() root.add('aep_test', FUSED_OpenMDAO(aep_csm_fused()), promotes=['*']) prob = Problem(root) prob.setup() prob[ 'machine_rating'] = 5000.0 #Float(units = 'kW', iotype='in', desc= 'rated machine power in kW') prob[ 'max_tip_speed'] = 80.0 #Float(units = 'm/s', iotype='in', desc= 'maximum allowable tip speed for the rotor') prob[ 'rotor_diameter'] = 126.0 #Float(units = 'm', iotype='in', desc= 'rotor diameter of the machine') prob[ 'max_power_coefficient'] = 0.488 #Float(iotype='in', desc= 'maximum power coefficient of rotor for operation in region 2') prob[ 'opt_tsr'] = 7.525 #Float(iotype='in', desc= 'optimum tip speed ratio for operation in region 2') prob[ 'cut_in_wind_speed'] = 3.0 #Float(units = 'm/s', iotype='in', desc= 'cut in wind speed for the wind turbine') prob[ 'cut_out_wind_speed'] = 25.0 #Float(units = 'm/s', iotype='in', desc= 'cut out wind speed for the wind turbine') prob[ 'hub_height'] = 90.0 #Float(units = 'm', iotype='in', desc= 'hub height of wind turbine above ground / sea level') prob[ 'altitude'] = 0.0 #Float(units = 'm', iotype='in', desc= 'altitude of wind plant') prob[ 'air_density'] = 0 #Float(units = 'kg / (m * m * m)', iotype='in', desc= 'air density at wind plant site') # default air density value is 0.0 - forces aero csm to calculate air density in model prob[ 'max_efficiency'] = 0.902 #Float(iotype='in', desc = 'maximum efficiency of rotor and drivetrain - at rated power') prob[ 'thrust_coefficient'] = 0.5 #Float(iotype='in', desc='thrust coefficient at rated power') prob['soiling_losses'] = 0.0 prob['array_losses'] = 0.1 prob['availability'] = 0.941 prob['turbine_number'] = 100 prob['shear_exponent'] = 0.1 prob['wind_speed_50m'] = 8.02 prob['weibull_k'] = 2.15 prob.run() print("AEP output") for io in root.unknowns: print(io + ' ' + str(root.unknowns[io]))
def test_simple_matvec_subbed(self): group = Group() group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y']) prob = Problem() prob.root = Group() prob.root.add('x_param', IndepVarComp('x', 1.0), promotes=['*']) prob.root.add('sub', group, promotes=['*']) 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_conflicting_promoted_state_vars(self): # verify we get an error if we have conflicting promoted state variables root = Group() comp1 = SimpleImplicitComp() comp2 = SimpleImplicitComp() root.add('c1', comp1, promotes=['z']) # promote the state, z root.add('c2', comp2, promotes=['z']) # promote the state, z, again.. BAD prob = Problem(root) with self.assertRaises(RuntimeError) as err: prob.setup(check=False) expected_msg = "'': promoted name 'z' matches multiple unknowns: ('c1.z', 'c2.z')" self.assertEqual(str(err.exception), expected_msg)
def test_multiple_connect(self): root = Group() C1 = root.add('C1', ExecComp('y=x*2.0')) C2 = root.add('C2', ExecComp('y=x*2.0')) C3 = root.add('C3', ExecComp('y=x*2.0')) root.connect('C1.y',['C2.x', 'C3.x']) prob = Problem() root._init_sys_data('', prob._probdata) params_dict, unknowns_dict = root._setup_variables() # verify we get correct connection information connections = root._get_explicit_connections() expected_connections = { 'C2.x': [('C1.y', None)], 'C3.x': [('C1.y', None)] } self.assertEqual(connections, expected_connections)
def test_multiple_connect(self): root = Group() C1 = root.add('C1', ExecComp('y=x*2.0')) C2 = root.add('C2', ExecComp('y=x*2.0')) C3 = root.add('C3', ExecComp('y=x*2.0')) root.connect('C1.y', ['C2.x', 'C3.x']) prob = Problem() root._init_sys_data('', prob._probdata) params_dict, unknowns_dict = root._setup_variables() # verify we get correct connection information connections = root._get_explicit_connections() expected_connections = { 'C2.x': [('C1.y', None)], 'C3.x': [('C1.y', None)] } self.assertEqual(connections, expected_connections)
def test_array2D(self): group = Group() group.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*']) group.add('mycomp', ArrayComp2D(), promotes=['x', 'y']) prob = Problem(impl=impl) prob.root = group prob.root.ln_solver = PetscKSP() 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_array2D(self): group = Group() group.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*']) group.add('mycomp', ArrayComp2D(), 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') 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_array2D(self): group = Group() group.add("x_param", IndepVarComp("x", np.ones((2, 2))), promotes=["*"]) group.add("mycomp", ArrayComp2D(), 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") 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_conflicting_promoted_state_vars(self): # verify we get an error if we have conflicting promoted state variables root = Group() comp1 = SimpleImplicitComp() comp2 = SimpleImplicitComp() root.add('c1', comp1, promotes=['z']) # promote the state, z root.add('c2', comp2, promotes=['z']) # promote the state, z, again.. BAD prob = Problem(root) with self.assertRaises(RuntimeError) as err: prob.setup(check=False) expected_msg = "'': promoted name 'z' matches multiple unknowns: ('c1.z', 'c2.z')" self.assertEqual(str(err.exception), expected_msg)
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 = DirectSolver() prob.root.ln_solver.options['jacobian_method'] = 'assemble' prob.setup(check=False) prob.run() with self.assertRaises(RuntimeError) as cm: J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict') expected_msg = "The 'assemble' jacobian_method is not supported when " + \ "'apply_linear' is used on a component (mycomp)." self.assertEqual(str(cm.exception), expected_msg)
def test_group_add(self): model = Group() ecomp = ExecComp('b=2.0*a', a=3.0, b=6.0) msg = "The 'add' method provides backwards compatibility with OpenMDAO <= 1.x ; " \ "use 'add_subsystem' instead." with assert_warning(DeprecationWarning, msg): comp1 = model.add('comp1', ecomp) self.assertTrue(ecomp is comp1)
def test_two_simple(self): group = Group() group.add('x_param', IndepVarComp('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_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_array2D_no_decompose(self): group = Group() group.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*']) group.add('mycomp', ArrayComp2D(), promotes=['x', 'y']) prob = Problem() prob.root = group prob.root.ln_solver = DirectSolver() prob.root.ln_solver.options['jacobian_method'] = 'assemble' prob.root.ln_solver.options['save_LU_decomposition'] = False 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_src_indices(self): size = 10 root = Group() root.add('P1', IndepVarComp('x', np.zeros(size))) root.add( 'C1', ExecComp('y = x * 2.', y=np.zeros(size // 2), x=np.zeros(size // 2))) root.add( 'C2', ExecComp('y = x * 3.', y=np.zeros(size // 2), x=np.zeros(size // 2))) root.connect('P1.x', "C1.x", src_indices=list(range(size // 2))) root.connect('P1.x', "C2.x", src_indices=list(range(size // 2, size))) prob = Problem(root) prob.setup(check=False) root.P1.unknowns['x'][0:size // 2] += 1.0 root.P1.unknowns['x'][size // 2:size] -= 1.0 prob.run() assert_rel_error(self, root.C1.params['x'], np.ones(size // 2), 0.0001) assert_rel_error(self, root.C2.params['x'], -np.ones(size // 2), 0.0001)