def test_debug_print_response_physical(self): prob = om.Problem() model = prob.model size = 3 model.add_subsystem('p1', om.IndepVarComp('x', np.array([50.0] * size))) model.add_subsystem('p2', om.IndepVarComp('y', np.array([50.0] * size))) model.add_subsystem( 'comp', om.ExecComp('f_xy = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0', x=np.zeros(size), y=np.zeros(size), f_xy=np.zeros(size))) model.add_subsystem( 'con', om.ExecComp('c = - x + y + 1', c=np.zeros(size), x=np.zeros(size), y=np.zeros(size))) model.connect('p1.x', 'comp.x') model.connect('p2.y', 'comp.y') model.connect('p1.x', 'con.x') model.connect('p2.y', 'con.y') prob.set_solver_print(level=0) prob.driver = om.ScipyOptimizeDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1e-9 prob.driver.options['disp'] = False model.add_design_var('p1.x', indices=[1], lower=-50.0, upper=50.0) model.add_design_var('p2.y', indices=[1], lower=-50.0, upper=50.0) model.add_objective('comp.f_xy', index=1, ref=1.5) model.add_constraint('con.c', indices=[1], upper=-15.0, ref=1.02) prob.setup() prob.driver.options['debug_print'] = ['objs', 'nl_cons'] stdout = sys.stdout strout = StringIO() sys.stdout = strout try: # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): with printoptions(precision=2, legacy="1.13"): prob.run_driver() else: with printoptions(precision=2): prob.run_driver() finally: sys.stdout = stdout output = strout.getvalue().split('\n') # should see unscaled (physical) and the full arrays, not just what is indicated by indices self.assertEqual(output[3], "{'con.c': array([ 1.])}") self.assertEqual(output[6], "{'comp.f_xy': array([ 7622.])}")
def test_debug_desvar_shape(self): # Desvar should always be printed un-flattened. prob = Problem() model = prob.model model.add_subsystem( 'p', IndepVarComp('x', val=np.array([[1.0, 3, 4], [7, 2, 5]]))) model.add_design_var('p.x', np.array([[1.0, 3, 4], [7, 2, 5]])) prob.driver.options['debug_print'] = ['desvars'] prob.setup() stdout = sys.stdout strout = StringIO() sys.stdout = strout try: # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): with printoptions(precision=2, legacy="1.13"): prob.run_driver() else: with printoptions(precision=2): prob.run_driver() finally: sys.stdout = stdout output = strout.getvalue().split('\n') self.assertEqual(output[3], "{'p.x': array([[ 1., 3., 4.],") self.assertEqual(output[4], ' [ 7., 2., 5.]])}')
def test_solver_debug_print(self, name, solver): p = om.Problem() model = p.model model.add_subsystem('ground', om.IndepVarComp('V', 0., units='V')) model.add_subsystem('source', om.IndepVarComp('I', 0.1, units='A')) model.add_subsystem('circuit', Circuit()) model.connect('source.I', 'circuit.I_in') model.connect('ground.V', 'circuit.Vg') p.setup() nl = model.circuit.nonlinear_solver = solver() nl.options['debug_print'] = True nl.options['err_on_non_converge'] = True if name == 'NonlinearBlockGS': nl.options['use_apply_nonlinear'] = True # suppress solver output for test nl.options['iprint'] = model.circuit.linear_solver.options[ 'iprint'] = -1 # For Broydensolver, don't calc Jacobian try: nl.options['compute_jacobian'] = False except KeyError: pass # set some poor initial guesses so that we don't converge p['circuit.n1.V'] = 10. p['circuit.n2.V'] = 1e-3 opts = {} # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts["legacy"] = '1.13' with printoptions(**opts): # run the model and check for expected output file output = run_model(p, ignore_exception=True) expected_output = '\n'.join([ self.expected_data, "Inputs and outputs at start of iteration " "have been saved to '%s'.\n" % self.filename ]) self.assertEqual(output, expected_output) with open(self.filename, 'r') as f: self.assertEqual(f.read(), self.expected_data) # setup & run again to make sure there is no error due to existing file p.setup() with printoptions(**opts): run_model(p, ignore_exception=False)
def test_debug_print_response_physical(self): prob = Problem() model = prob.model = Group() size = 3 model.add_subsystem('p1', IndepVarComp('x', np.array([50.0] * size))) model.add_subsystem('p2', IndepVarComp('y', np.array([50.0] * size))) model.add_subsystem('comp', ExecComp('f_xy = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0', x=np.zeros(size), y=np.zeros(size), f_xy=np.zeros(size))) model.add_subsystem('con', ExecComp('c = - x + y + 1', c=np.zeros(size), x=np.zeros(size), y=np.zeros(size))) model.connect('p1.x', 'comp.x') model.connect('p2.y', 'comp.y') model.connect('p1.x', 'con.x') model.connect('p2.y', 'con.y') prob.set_solver_print(level=0) prob.driver = ScipyOptimizeDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1e-9 prob.driver.options['disp'] = False model.add_design_var('p1.x', indices=[1], lower=-50.0, upper=50.0) model.add_design_var('p2.y', indices=[1], lower=-50.0, upper=50.0) model.add_objective('comp.f_xy', index=1, ref=1.5) model.add_constraint('con.c', indices=[1], upper=-15.0, ref=1.02) prob.setup(check=False) prob.driver.options['debug_print'] = ['objs', 'nl_cons'] stdout = sys.stdout strout = StringIO() sys.stdout = strout try: # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): with printoptions(precision=2, legacy="1.13"): prob.run_driver() else: with printoptions(precision=2): prob.run_driver() finally: sys.stdout = stdout output = strout.getvalue().split('\n') # should see unscaled (physical) and the full arrays, not just what is indicated by indices self.assertEqual(output[3], "{'con.c': array([ 1.])}") self.assertEqual(output[6], "{'comp.f_xy': array([ 7622.])}")
def test_bsplines_vectorized(self): prob = om.Problem() model = prob.model n_cp = 5 n_point = 10 t = np.linspace(0, 0.5 * np.pi, n_cp) tt = np.linspace(0, 0.5 * np.pi, n_point) x = np.empty((2, n_cp)) x[0, :] = np.sin(t) x[1, :] = 2.0 * np.sin(t) t_sin = (0.5 * (1.0 + np.sin(-0.5 * np.pi + 2.0 * tt))) * np.pi * 0.5 model.add_subsystem('px', om.IndepVarComp('x', val=x)) bspline_options = {'order': 4} comp = om.SplineComp(method='bsplines', x_interp_val=t_sin, num_cp=n_cp, vec_size=2, interp_options=bspline_options) prob.model.add_subsystem('interp', comp) comp.add_spline(y_cp_name='h_cp', y_interp_name='h', y_cp_val=x, y_units='km') model.connect('px.x', 'interp.h_cp') prob.setup(force_alloc_complex=True) prob.run_model() xx = prob['interp.h'] with printoptions(precision=3, floatmode='fixed'): assert_near_equal( x[0, :], np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) assert_near_equal( x[1, :], 2.0 * np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) assert_near_equal( xx[0, :], np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5) assert_near_equal( xx[1, :], 2.0 * np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5) derivs = prob.check_partials(out_stream=None, method='cs') assert_check_partials(derivs, atol=1e-14, rtol=1e-14)
def test_renamed_vars(self): n = 1 prob = Problem(model=Group()) bal = BalanceComp() bal.add_balance('x', use_mult=True, mult_name='MUL', lhs_name='XSQ', rhs_name='TARGETXSQ') tgt = IndepVarComp(name='y_tgt', val=4) mult_ivc = IndepVarComp(name='mult', val=2.0) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='mult_comp', subsys=mult_ivc, promotes_outputs=['mult']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.TARGETXSQ') prob.model.connect('mult', 'balance.MUL') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.XSQ') prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.model.nonlinear_solver.options['maxiter'] = 100 prob.model.nonlinear_solver.options['iprint'] = 0 prob.model.jacobian = DenseJacobian() prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def _trim_str(obj, size): """ Truncate given string if it's longer than the given size. For arrays, use the norm if the size is exceeded. Parameters ---------- obj : object Object to be stringified and trimmed. size : int Max allowable size of the returned string. Returns ------- str The trimmed string. """ if isinstance(obj, np.ndarray): with printoptions(**_npy_print_opts): s = str(obj) else: s = str(obj) if len(s) > size: if isinstance(obj, np.ndarray) and np.issubdtype(obj.dtype, np.floating): s = 'shape={}, norm={:<.3}'.format(obj.shape, np.linalg.norm(obj)) else: s = s[:size - 4] + ' ...' return s
def test_partials(self): p = self.make_problem(transcription=Radau, optimizer='SLSQP') p.run_model() with printoptions(linewidth=1024, edgeitems=100): cpd = p.check_partials(method='fd', compact_print=True, out_stream=None)
def test_for_docs_array_list_vars_options(self): class ArrayAdder(om.ExplicitComponent): """ Just a simple component that has array inputs and outputs """ def __init__(self, size): super().__init__() self.size = size def setup(self): self.add_input('x', val=np.zeros(self.size), units='inch') self.add_output('y', val=np.zeros(self.size), units='ft') def compute(self, inputs, outputs): outputs['y'] = inputs['x'] + 10.0 size = 30 prob = om.Problem() prob.model.add_subsystem('des_vars', om.IndepVarComp('x', np.ones(size), units='inch'), promotes=['x']) prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y']) prob.setup() prob['x'] = np.arange(size) prob.run_driver() prob.model.list_inputs(values=True, units=True, hierarchical=True, print_arrays=True) with printoptions(edgeitems=3, infstr='inf', linewidth=75, nanstr='nan', precision=8, suppress=False, threshold=1000, formatter=None): prob.model.list_outputs(values=True, implicit=False, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=False, print_arrays=True) prob.model.list_outputs(values=True, implicit=False, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=True)
def test_scalar_example(self): prob = Problem(model=Group()) bal = BalanceComp() bal.add_balance('x', val=1.0) tgt = IndepVarComp(name='y_tgt', val=2) exec_comp = ExecComp('y=x**2') prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') # do one test in an unconverged state, to capture accuracy of partials prob.setup() prob[ 'y_tgt'] = 100000 #set rhs and lhs to very different values. Trying to capture some derivatives wrt prob['exec.y'] = .001 prob.run_model() cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5) # set an actual solver, and re-setup. Then check derivatives at a converged point prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.setup() prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_bsplines_2to3doc(self): from openmdao.utils.spline_distributions import sine_distribution prob = om.Problem() model = prob.model n_cp = 5 n_point = 10 t = np.linspace(0, 0.5 * np.pi, n_cp) x = np.empty((2, n_cp)) x[0, :] = np.sin(t) x[1, :] = 2.0 * np.sin(t) # In 2.x, the BsplinesComp had a built-in sinusoidal distribution. t_sin = sine_distribution(n_point) * np.pi * 0.5 bspline_options = {'order': 4} comp = om.SplineComp(method='bsplines', x_interp_val=t_sin, num_cp=n_cp, vec_size=2, interp_options=bspline_options) prob.model.add_subsystem('interp', comp) comp.add_spline(y_cp_name='h_cp', y_interp_name='h', y_cp_val=x, y_units='km') prob.setup() prob.run_model() xx = prob['interp.h'] with printoptions(precision=3, floatmode='fixed'): assert_near_equal( x[0, :], np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) assert_near_equal( x[1, :], 2.0 * np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) assert_near_equal( xx[0, :], np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5) assert_near_equal( xx[1, :], 2.0 * np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5)
def test_scalar_with_guess_func_additional_input(self): n = 1 prob = Problem(model=Group()) bal = BalanceComp() bal.add_balance('x', guess_func=lambda inputs, resids: inputs['guess_x']) bal.add_input('guess_x', val=0.0) ivc = IndepVarComp() ivc.add_output(name='y_tgt', val=4) ivc.add_output(name='guess_x', val=2.5) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='ivc', subsys=ivc, promotes_outputs=['y_tgt', 'guess_x']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('guess_x', 'balance.guess_x') prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.model.nonlinear_solver.options['maxiter'] = 100 prob.model.nonlinear_solver.options['iprint'] = 0 prob.model.jacobian = DenseJacobian() prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], 2.0, decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_vectorized(self): import numpy as np from openmdao.api import Problem, IndepVarComp from openmdao.components.bsplines_comp import BsplinesComp from openmdao.utils.general_utils import printoptions prob = Problem() model = prob.model n_cp = 5 n_point = 10 t = np.linspace(0, 0.5 * np.pi, n_cp) x = np.empty((2, n_cp)) x[0, :] = np.sin(t) x[1, :] = 2.0 * np.sin(t) model.add_subsystem('px', IndepVarComp('x', val=x)) model.add_subsystem( 'interp', BsplinesComp(num_control_points=n_cp, num_points=n_point, vec_size=2, in_name='h_cp', out_name='h')) model.connect('px.x', 'interp.h_cp') prob.setup(check=False) prob.run_model() xx = prob['interp.h'] with printoptions(precision=3, floatmode='fixed'): self.assertEqual('Control Points:', 'Control Points:') assert_rel_error( self, x[0, :], np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) assert_rel_error( self, x[1, :], 2.0 * np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) self.assertEqual('Output Points:', 'Output Points:') assert_rel_error( self, xx[0, :], np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5) assert_rel_error( self, xx[1, :], 2.0 * np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5)
def test_vectorized_with_default_mult(self): """ solve: 2 * x**2 = 4 expected solution: x=sqrt(2) """ n = 100 prob = Problem(model=Group()) bal = BalanceComp('x', val=np.ones(n), use_mult=True, mult_val=2.0) tgt = IndepVarComp(name='y_tgt', val=4 * np.ones(n)) exec_comp = ExecComp('y=x**2', x={'value': np.ones(n)}, y={'value': np.ones(n)}) prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.model.nonlinear_solver.options['maxiter'] = 100 prob.model.nonlinear_solver.options['iprint'] = 0 prob.model.jacobian = DenseJacobian() prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_vectorized_with_mult(self): n = 100 prob = Problem(model=Group(assembled_jac_type='dense')) bal = BalanceComp() bal.add_balance('x', val=np.ones(n), use_mult=True) tgt = IndepVarComp(name='y_tgt', val=4 * np.ones(n)) mult_ivc = IndepVarComp(name='mult', val=2.0 * np.ones(n)) exec_comp = ExecComp('y=x**2', x={'value': np.ones(n)}, y={'value': np.ones(n)}) prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='mult_comp', subsys=mult_ivc, promotes_outputs=['mult']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('mult', 'balance.mult:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver(assemble_jac=True) prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0) prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_linesearch_vector_bound_enforcement(self): top = self.top ls = top.model.nonlinear_solver.linesearch = om.BoundsEnforceLS( bound_enforcement='vector') ls.options['print_bound_enforce'] = True # Setup again because we assigned a new linesearch top.setup() # Test lower bounds: should go to the lower bound and stall top['px.x'] = 2.0 top['comp.y'] = 0. top['comp.z'] = 1.6 top.run_model() for ind in range(3): assert_near_equal(top['comp.z'][ind], [1.5], 1e-8) with printoptions(precision=3): msg = ( f"'comp.z' exceeds lower bounds\n Val: [1.333 1.333 1.333]\n Lower: [1.5 1.5 1.5]\n" ) with assert_warning(om.SolverWarning, msg): top.run_model() top.setup() # Test upper bounds: should go to the minimum upper bound and stall top['px.x'] = 0.5 top['comp.y'] = 0. top['comp.z'] = 2.4 with printoptions(precision=3): msg = ( f"'comp.z' exceeds upper bounds\n Val: [2.667 2.667 2.667]\n Upper: [2.6 2.5 2.65]\n" ) with assert_warning(om.SolverWarning, msg): top.run_model() for ind in range(3): assert_near_equal(top['comp.z'][ind], [2.5], 1e-8)
def test_solver_debug_print(self, name, solver): p = Problem() model = p.model model.add_subsystem('ground', IndepVarComp('V', 0., units='V')) model.add_subsystem('source', IndepVarComp('I', 0.1, units='A')) model.add_subsystem('circuit', Circuit()) model.connect('source.I', 'circuit.I_in') model.connect('ground.V', 'circuit.Vg') p.setup() nl = model.circuit.nonlinear_solver = solver() nl.options['debug_print'] = True nl.options['err_on_maxiter'] = True if name == 'NonlinearBlockGS': nl.options['use_apply_nonlinear'] = True # suppress solver output for test nl.options['iprint'] = model.circuit.linear_solver.options['iprint'] = -1 # For Broydensolver, don't calc Jacobian try: nl.options['compute_jacobian'] = False except KeyError: pass # set some poor initial guesses so that we don't converge p['circuit.n1.V'] = 10. p['circuit.n2.V'] = 1e-3 opts = {} # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts["legacy"] = '1.13' with printoptions(**opts): # run the model and check for expected output file output = run_model(p, ignore_exception=True) expected_output = '\n'.join([ self.expected_data, "Inputs and outputs at start of iteration " "have been saved to '%s'.\n" % self.filename ]) self.assertEqual(output, expected_output) with open(self.filename, 'r') as f: self.assertEqual(f.read(), self.expected_data)
def test_scalar_example(self): prob = Problem(model=Group()) bal = BalanceComp() bal.add_balance('x', val=1.0) tgt = IndepVarComp(name='y_tgt', val=2) exec_comp = ExecComp('y=x**2') prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') # do one test in an unconverged state, to capture accuracy of partials prob.setup() prob['y_tgt'] = 100000 #set rhs and lhs to very different values. Trying to capture some derivatives wrt prob['exec.y'] = .001 prob.run_model() cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5) # set an actual solver, and re-setup. Then check derivatives at a converged point prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.setup() prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_vectorized(self): import numpy as np from openmdao.api import Problem, IndepVarComp from openmdao.components.bsplines_comp import BsplinesComp from openmdao.utils.general_utils import printoptions prob = Problem() model = prob.model n_cp = 5 n_point = 10 t = np.linspace(0, 0.5*np.pi, n_cp) x = np.empty((2, n_cp)) x[0, :] = np.sin(t) x[1, :] = 2.0*np.sin(t) model.add_subsystem('px', IndepVarComp('x', val=x)) model.add_subsystem('interp', BsplinesComp(num_control_points=n_cp, num_points=n_point, vec_size=2, in_name='h_cp', out_name='h')) model.connect('px.x', 'interp.h_cp') prob.setup(check=False) prob.run_model() xx = prob['interp.h'] with printoptions(precision=3, floatmode='fixed'): self.assertEqual('Control Points:', 'Control Points:') assert_rel_error(self, x[0, :], np.array([ 0., 0.38268343, 0.70710678, 0.92387953, 1. ]), 1e-5) assert_rel_error(self, x[1, :], 2.0*np.array([ 0., 0.38268343, 0.70710678, 0.92387953, 1. ]), 1e-5) self.assertEqual('Output Points:', 'Output Points:') assert_rel_error(self, xx[0, :], np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5) assert_rel_error(self, xx[1, :], 2.0*np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5)
def test_scalar_with_guess_func(self): n = 1 prob = Problem(model=Group(assembled_jac_type='dense')) bal = BalanceComp() bal.add_balance( 'x', guess_func=lambda inputs, resids: np.sqrt(inputs['rhs:x'])) tgt = IndepVarComp(name='y_tgt', val=4) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver(assemble_jac=True) prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0) prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], 2.0, decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_scalar_with_guess_func_additional_input(self): n = 1 prob = Problem(model=Group(assembled_jac_type='dense')) bal = BalanceComp() bal.add_balance('x', guess_func=lambda inputs, resids: inputs['guess_x']) bal.add_input('guess_x', val=0.0) ivc = IndepVarComp() ivc.add_output(name='y_tgt', val=4) ivc.add_output(name='guess_x', val=2.5) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='ivc', subsys=ivc, promotes_outputs=['y_tgt', 'guess_x']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('guess_x', 'balance.guess_x') prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver(assemble_jac=True) prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0) prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], 2.0, decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_renamed_vars(self): n = 1 prob = Problem(model=Group(assembled_jac_type='dense')) bal = BalanceComp() bal.add_balance('x', use_mult=True, mult_name='MUL', lhs_name='XSQ', rhs_name='TARGETXSQ') tgt = IndepVarComp(name='y_tgt', val=4) mult_ivc = IndepVarComp(name='mult', val=2.0) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='mult_comp', subsys=mult_ivc, promotes_outputs=['mult']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.TARGETXSQ') prob.model.connect('mult', 'balance.MUL') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.XSQ') prob.model.linear_solver = DirectSolver(assemble_jac=True) prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0) prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_solver_debug_print_feature(self): from distutils.version import LooseVersion import numpy as np import openmdao.api as om from openmdao.test_suite.scripts.circuit_analysis import Circuit from openmdao.utils.general_utils import printoptions p = om.Problem() model = p.model model.add_subsystem('ground', om.IndepVarComp('V', 0., units='V')) model.add_subsystem('source', om.IndepVarComp('I', 0.1, units='A')) model.add_subsystem('circuit', Circuit()) model.connect('source.I', 'circuit.I_in') model.connect('ground.V', 'circuit.Vg') p.setup() nl = model.circuit.nonlinear_solver = om.NewtonSolver( solve_subsystems=False) nl.options['iprint'] = 2 nl.options['debug_print'] = True nl.options['err_on_non_converge'] = True # set some poor initial guesses so that we don't converge p['circuit.n1.V'] = 10. p['circuit.n2.V'] = 1e-3 opts = {} # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts["legacy"] = '1.13' with printoptions(**opts): # run the model try: p.run_model() except om.AnalysisError: pass with open(self.filename, 'r') as f: self.assertEqual(f.read(), self.expected_data)
def test_vectorized_with_default_mult(self): """ solve: 2 * x**2 = 4 expected solution: x=sqrt(2) """ n = 100 prob = Problem(model=Group(assembled_jac_type='dense')) bal = BalanceComp('x', val=np.ones(n), use_mult=True, mult_val=2.0) tgt = IndepVarComp(name='y_tgt', val=4 * np.ones(n)) exec_comp = ExecComp('y=x**2', x={'value': np.ones(n)}, y={'value': np.ones(n)}) prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver(assemble_jac=True) prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0) prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_solver_debug_print_feature(self): from distutils.version import LooseVersion import numpy as np from openmdao.api import Problem, IndepVarComp, NewtonSolver, AnalysisError from openmdao.test_suite.scripts.circuit_analysis import Circuit from openmdao.utils.general_utils import printoptions p = Problem() model = p.model model.add_subsystem('ground', IndepVarComp('V', 0., units='V')) model.add_subsystem('source', IndepVarComp('I', 0.1, units='A')) model.add_subsystem('circuit', Circuit()) model.connect('source.I', 'circuit.I_in') model.connect('ground.V', 'circuit.Vg') p.setup() nl = model.circuit.nonlinear_solver = NewtonSolver() nl.options['iprint'] = 2 nl.options['debug_print'] = True nl.options['err_on_maxiter'] = True # set some poor initial guesses so that we don't converge p['circuit.n1.V'] = 10. p['circuit.n2.V'] = 1e-3 opts = {} # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts["legacy"] = '1.13' with printoptions(**opts): # run the model try: p.run_model() except AnalysisError: pass with open('rank0_root_0_NLRunOnce_0_circuit_0.dat', 'r') as f: self.assertEqual(f.read(), self.expected_data)
def test_solver_debug_print(self, name, solver): p = Problem() model = p.model model.add_subsystem('ground', IndepVarComp('V', 0., units='V')) model.add_subsystem('source', IndepVarComp('I', 0.1, units='A')) model.add_subsystem('circuit', Circuit()) model.connect('source.I', 'circuit.I_in') model.connect('ground.V', 'circuit.Vg') p.setup() nl = model.circuit.nonlinear_solver = solver() nl.options['debug_print'] = True # suppress solver output for test nl.options['iprint'] = model.circuit.linear_solver.options['iprint'] = -1 # set some poor initial guesses so that we don't converge p['circuit.n1.V'] = 10. p['circuit.n2.V'] = 1e-3 opts = {} # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts["legacy"] = '1.13' with printoptions(**opts): # run the model and check for expected output file output = run_model(p) expected_output = '\n'.join([ self.expected_data, "Inputs and outputs at start of iteration " "have been saved to '%s'.\n" % self.filename ]) self.assertEqual(output, expected_output) with open(self.filename, 'r') as f: self.assertEqual(f.read(), self.expected_data)
def test_basic(self): import numpy as np import openmdao.api as om from openmdao.utils.general_utils import printoptions prob = om.Problem() model = prob.model n_cp = 5 n_point = 10 t = np.linspace(0, 0.5 * np.pi, n_cp) x = np.sin(t) model.add_subsystem('px', om.IndepVarComp('x', val=x)) model.add_subsystem( 'interp', om.BsplinesComp(num_control_points=n_cp, num_points=n_point, in_name='h_cp', out_name='h')) model.connect('px.x', 'interp.h_cp') prob.setup() prob.run_model() xx = prob['interp.h'].flatten() with printoptions(precision=3, floatmode='fixed'): self.assertEqual('Control Points:', 'Control Points:') assert_rel_error( self, x, np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5) self.assertEqual('Output Points:', 'Output Points:') assert_rel_error( self, xx, np.array([ 0., 0.06687281, 0.23486869, 0.43286622, 0.6062628, 0.74821484, 0.86228902, 0.94134389, 0.98587725, 1. ]), 1e-5)
def test_rhs_val(self): """ Test solution with a default RHS value and no connected RHS variable. """ n = 1 prob = Problem(model=Group()) bal = BalanceComp('x', rhs_val=4.0) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.model.nonlinear_solver.options['maxiter'] = 100 prob.model.nonlinear_solver.options['iprint'] = 0 prob.model.jacobian = DenseJacobian() prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], 2.0, decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_solver_debug_print_feature(self): from openmdao.api import Problem, IndepVarComp, NewtonSolver, AnalysisError from openmdao.test_suite.test_examples.test_circuit_analysis import Circuit from openmdao.utils.general_utils import printoptions p = Problem() model = p.model model.add_subsystem('ground', IndepVarComp('V', 0., units='V')) model.add_subsystem('source', IndepVarComp('I', 0.1, units='A')) model.add_subsystem('circuit', Circuit()) model.connect('source.I', 'circuit.I_in') model.connect('ground.V', 'circuit.Vg') p.setup() nl = model.circuit.nonlinear_solver = NewtonSolver() nl.options['iprint'] = 2 nl.options['debug_print'] = True nl.options['err_on_maxiter'] = True # set some poor initial guesses so that we don't converge p['circuit.n1.V'] = 10. p['circuit.n2.V'] = 1e-3 opts = {} # formatting has changed in numpy 1.14 and beyond. if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts["legacy"] = '1.13' with printoptions(**opts): # run the model try: p.run_model() except AnalysisError: pass with open('rank0_root_0_NLRunOnce_0_circuit_0.dat', 'r') as f: self.assertEqual(f.read(), self.expected_data)
def test_create_on_init(self): prob = Problem(model=Group()) bal = BalanceComp('x', val=1.0) tgt = IndepVarComp(name='y_tgt', val=2) exec_comp = ExecComp('y=x**2') prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.setup() prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) # Assert that normalization is happening assert_almost_equal(prob.model.balance._scale_factor, 1.0 / np.abs(2)) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_create_on_init(self): prob = Problem(model=Group()) bal = BalanceComp('x', val=1.0) tgt = IndepVarComp(name='y_tgt', val=2) exec_comp = ExecComp('y=x**2') prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt']) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('y_tgt', 'balance.rhs:x') prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver() prob.model.nonlinear_solver = NewtonSolver() prob.setup() prob.run_model() assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7) # Assert that normalization is happening assert_almost_equal(prob.model.balance._scale_factor, 1.0 / np.abs(2)) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_rhs_val(self): """ Test solution with a default RHS value and no connected RHS variable. """ n = 1 prob = Problem(model=Group(assembled_jac_type='dense')) bal = BalanceComp('x', rhs_val=4.0) exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1}) prob.model.add_subsystem(name='exec', subsys=exec_comp) prob.model.add_subsystem(name='balance', subsys=bal) prob.model.connect('balance.x', 'exec.x') prob.model.connect('exec.y', 'balance.lhs:x') prob.model.linear_solver = DirectSolver(assemble_jac=True) prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0) prob.setup() prob['balance.x'] = np.random.rand(n) prob.run_model() assert_almost_equal(prob['balance.x'], 2.0, decimal=7) with printoptions(linewidth=1024): cpd = prob.check_partials() for (of, wrt) in cpd['balance']: assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
if __name__ == '__main__': import openmdao.utils.mpi # this will activate use_proc_files try: module_path = os.environ.get("OPENMDAO_CURRENT_MODULE", "").strip() if module_path: stdout_save = sys.stdout # send any output to dev/null during the import so it doesn't clutter our embedded code output with open(os.devnull, "w") as f: sys.stdout = f mod = importlib.import_module(module_path) sys.stdout = stdout_save else: raise RuntimeError("OPENMDAO_CURRENT_MODULE was not specified.") code_to_run = os.environ.get("OPENMDAO_CODE_TO_RUN", "").strip() if not code_to_run: raise RuntimeError("OPENMDAO_CODE_TO_RUN has not been set.") with printoptions(precision=8): exec(code_to_run, mod.__dict__) except Exception: traceback.print_exc() sys.exit(-1) sys.exit(0)
def test_distribcomp_list_vars(self): from openmdao.test_suite.components.distributed_components import DistribComp, Summer print_opts = {'linewidth': 1024} from distutils.version import LooseVersion if LooseVersion(np.__version__) >= LooseVersion("1.14"): print_opts['legacy'] = '1.13' size = 15 model = om.Group() model.add_subsystem("indep", om.IndepVarComp('x', np.zeros(size))) model.add_subsystem("C2", DistribComp(size=size)) model.add_subsystem("C3", Summer(size=size)) model.connect('indep.x', 'C2.invec') model.connect('C2.outvec', 'C3.invec') prob = om.Problem(model) prob.setup() # prior to model execution, the global shape of a distributed variable is not available # and only the local portion of the value is available stream = cStringIO() with printoptions(**print_opts): model.C2.list_inputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Input(s) in 'C2'", '------------------', '', 'varname value shape global_shape', '------- --------------- ----- ------------', 'invec |2.82842712475| (8,) Unavailable ', ' value:', ' array([1., 1., 1., 1., 1., 1., 1., 1.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual( remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) stream = cStringIO() with printoptions(**print_opts): model.C2.list_outputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Explicit Output(s) in 'C2'", '----------------------------', '', 'varname value shape global_shape', '------- --------------- ----- ------------', 'outvec |2.82842712475| (8,) Unavailable ', ' value:', ' array([1., 1., 1., 1., 1., 1., 1., 1.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual( remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) # run the model prob['indep.x'] = np.ones(size) prob.run_model() # after model execution, the global shape of a distributed variable is available # and the complete global value is available stream = cStringIO() with printoptions(**print_opts): model.C2.list_inputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Input(s) in 'C2'", '------------------', '', 'varname value shape global_shape', '-------- --------------- ----- ------------', 'C2.invec |3.87298334621| (8,) (15,) ', ' value:', ' array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual( remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) stream = cStringIO() with printoptions(**print_opts): model.C2.list_outputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Explicit Output(s) in 'C2'", '----------------------------', '', 'varname value shape global_shape', '--------- -------------- ----- ------------', 'C2.outvec |9.74679434481| (8,) (15,) ', ' value:', ' array([ 2., 2., 2., 2., 2., 2., 2., 2., -3., -3., -3., -3., -3., -3., -3.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual( remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) # note that the shape of the input variable for the non-distributed Summer component # is different on each processor, use the all_procs argument to display on all processors stream = cStringIO() with printoptions(**print_opts): model.C3.list_inputs(hierarchical=False, shape=True, global_shape=True, all_procs=True, print_arrays=True, out_stream=stream) text = stream.getvalue().split('\n') if prob.comm.rank == 0: norm = '|5.65685424949|' shape = (8, ) value = '[2., 2., 2., 2., 2., 2., 2., 2.]' else: norm = '|7.93725393319|' shape = (7, ) value = '[-3., -3., -3., -3., -3., -3., -3.]' expected = [ "1 Input(s) in 'C3'", '------------------', '', 'varname value shape global_shape', '-------- ------------------- ----- ------------', 'C3.invec {} {} {} '.format(norm, shape, shape), ' value:', ' array({})'.format(value), ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual( remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) assert_rel_error(self, prob['C3.out'], -5.)
def assert_partials(self, p): with printoptions(linewidth=1024, edgeitems=100): cpd = p.check_partials(method='cs') assert_check_partials(cpd)
def test_array_list_vars_options(self): class ArrayAdder(om.ExplicitComponent): """ Just a simple component that has array inputs and outputs """ def __init__(self, size): super().__init__() self.size = size def setup(self): self.add_input('x', val=np.zeros(self.size), units='inch') self.add_output('y', val=np.zeros(self.size), units='ft') def compute(self, inputs, outputs): outputs['y'] = inputs['x'] + 10.0 size = 100 # how many items in the array prob = om.Problem() prob.model.add_subsystem('des_vars', om.IndepVarComp('x', np.ones(size), units='inch'), promotes=['x']) prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y']) prob.setup() prob['x'] = np.ones(size) prob.run_driver() # logging inputs # out_stream - not hierarchical - extras - no print_arrays stream = StringIO() prob.model.list_inputs(values=True, units=True, hierarchical=False, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(1, text.count("1 Input(s) in 'model'")) self.assertEqual(1, text.count('mult.x')) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(5, num_non_empty_lines) # out_stream - hierarchical - extras - no print_arrays stream = StringIO() prob.model.list_inputs(values=True, units=True, hierarchical=True, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(1, text.count("1 Input(s) in 'model'")) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(6, num_non_empty_lines) self.assertEqual(1, text.count('\nmult')) self.assertEqual(1, text.count('\n x')) # logging outputs # out_stream - not hierarchical - extras - no print_arrays stream = StringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=False, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('2 Explicit Output'), 1) # make sure they are in the correct order self.assertTrue(text.find("des_vars.x") < text.find('mult.y')) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(8, num_non_empty_lines) # Promoted names - no print arrays stream = StringIO() prob.model.list_outputs(values=True, prom_name=True, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count(' x |10.0| x'), 1) self.assertEqual(text.count(' y |110.0| y'), 1) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(num_non_empty_lines, 10) # Hierarchical - no print arrays stream = StringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('\ndes_vars'), 1) self.assertEqual(text.count('\n x'), 1) self.assertEqual(text.count('\nmult'), 1) self.assertEqual(text.count('\n y'), 1) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(num_non_empty_lines, 10) # Need to explicitly set this to make sure all ways of running this test # result in the same format of the output. When running this test from the # top level via testflo, the format comes out different than if the test is # run individually opts = { 'edgeitems': 3, 'infstr': 'inf', 'linewidth': 75, 'nanstr': 'nan', 'precision': 8, 'suppress': False, 'threshold': 1000, } from distutils.version import LooseVersion if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts['legacy'] = '1.13' with printoptions(**opts): # logging outputs # out_stream - not hierarchical - extras - print_arrays stream = StringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=False, print_arrays=True, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('2 Explicit Output'), 1) self.assertEqual(text.count('value:'), 2) self.assertEqual(text.count('resids:'), 2) self.assertEqual(text.count('['), 4) # make sure they are in the correct order self.assertTrue(text.find("des_vars.x") < text.find('mult.y')) num_non_empty_lines = sum( [1 for s in text.splitlines() if s.strip()]) self.assertEqual(46, num_non_empty_lines) # Hierarchical stream = StringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=True, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('2 Explicit Output'), 1) self.assertEqual(text.count('value:'), 2) self.assertEqual(text.count('resids:'), 2) self.assertEqual(text.count('['), 4) self.assertEqual(text.count('\ndes_vars'), 1) self.assertEqual(text.count('\n x'), 1) self.assertEqual(text.count('\nmult'), 1) self.assertEqual(text.count('\n y'), 1) num_non_empty_lines = sum( [1 for s in text.splitlines() if s.strip()]) self.assertEqual(num_non_empty_lines, 48)
def test_for_docs_array_list_vars_options(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, ExplicitComponent from openmdao.utils.general_utils import printoptions class ArrayAdder(ExplicitComponent): """ Just a simple component that has array inputs and outputs """ def __init__(self, size): super(ArrayAdder, self).__init__() self.size = size def setup(self): self.add_input('x', val=np.zeros(self.size), units='inch') self.add_output('y', val=np.zeros(self.size), units='ft') def compute(self, inputs, outputs): outputs['y'] = inputs['x'] + 10.0 size = 30 prob = Problem() prob.model = Group() prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size), units='inch'), promotes=['x']) prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y']) prob.setup(check=False) prob['x'] = np.arange(size) prob.run_driver() prob.model.list_inputs(values=True, units=True, hierarchical=True, print_arrays=True) with printoptions(edgeitems=3, infstr='inf', linewidth=75, nanstr='nan', precision=8, suppress=False, threshold=1000, formatter=None): prob.model.list_outputs(values=True, implicit=False, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=False, print_arrays=True) prob.model.list_outputs(values=True, implicit=False, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=True)
def test_parallel_list_vars(self): print_opts = {'linewidth': 1024, 'precision': 1} if LooseVersion(np.__version__) >= LooseVersion("1.14"): print_opts['legacy'] = '1.13' prob = om.Problem(FanOutGrouped()) # add another subsystem with similar prefix prob.model.add_subsystem('sub2', om.ExecComp(['y=x'])) prob.model.connect('iv.x', 'sub2.x') prob.setup() prob.run_model() # # list inputs, not hierarchical # stream = StringIO() with printoptions(**print_opts): prob.model.list_inputs(values=True, hierarchical=False, out_stream=stream) with multi_proc_exception_check(prob.comm): if prob.comm.rank == 0: # Only rank 0 prints text = stream.getvalue().split('\n') expected = [ "6 Input(s) in 'model'", '', 'varname val', '-------- -----', 'c1.x', 'sub.c2.x', 'sub.c3.x', 'c2.x', 'c3.x', 'sub2.x' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertTrue(text[i].startswith(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) # # list inputs, hierarchical # stream = StringIO() with printoptions(**print_opts): prob.model.list_inputs(values=True, hierarchical=True, out_stream=stream) with multi_proc_exception_check(prob.comm): if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "6 Input(s) in 'model'", '', 'varname val', '------- -----', 'c1', ' x', 'sub', ' c2', ' x', ' c3', ' x', 'c2', ' x', 'c3', ' x', 'sub2', ' x' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertTrue(text[i].startswith(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) # # list outputs, not hierarchical # stream = StringIO() with printoptions(**print_opts): prob.model.list_outputs(values=True, residuals=True, hierarchical=False, out_stream=stream) with multi_proc_exception_check(prob.comm): if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "7 Explicit Output(s) in 'model'", '', 'varname val resids', '-------- ---- ------', 'iv.x', 'c1.y', 'sub.c2.y', 'sub.c3.y', 'c2.y', 'c3.y', 'sub2.y', '', '', "0 Implicit Output(s) in 'model'", ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertTrue(text[i].startswith(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) # # list outputs, hierarchical # stream = StringIO() with printoptions(**print_opts): prob.model.list_outputs(values=True, residuals=True, hierarchical=True, out_stream=stream) with multi_proc_exception_check(prob.comm): if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "7 Explicit Output(s) in 'model'", '', 'varname val resids', '------- ----- ------', 'iv', ' x', 'c1', ' y', 'sub', ' c2', ' y', ' c3', ' y', 'c2', ' y', 'c3', ' y', 'sub2', ' y', '', '', "0 Implicit Output(s) in 'model'", ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertTrue(text[i].startswith(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i]))
def view_connections(root, outfile='connections.html', show_browser=True, src_filter='', tgt_filter='', precision=6): """ Generates a self-contained html file containing a detailed connection viewer. Optionally pops up a web browser to view the file. Parameters ---------- root : system or Problem The root for the desired tree. outfile : str, optional The name of the output html file. Defaults to 'connections.html'. show_browser : bool, optional If True, pop up a browser to view the generated html file. Defaults to True. src_filter : str, optional If defined, use this as the initial value for the source system filter. tgt_filter : str, optional If defined, use this as the initial value for the target system filter. precision : int, optional Sets the precision for displaying array values. """ if MPI and MPI.COMM_WORLD.rank != 0: return # since people will be used to passing the Problem as the first arg to # the N2 diagram funct, allow them to pass a Problem here as well. if isinstance(root, Problem): system = root.model else: system = root input_srcs = system._conn_global_abs_in2out connections = { tgt: src for tgt, src in iteritems(input_srcs) if src is not None } src2tgts = defaultdict(list) units = {n: data.get('units','') for n, data in iteritems(system._var_allprocs_abs2meta)} vals = {} with printoptions(precision=precision, suppress=True, threshold=10000): for t in system._var_abs_names['input']: tmeta = system._var_abs2meta[t] idxs = tmeta['src_indices'] if t in connections: s = connections[t] val = _get_output(system, s, idxs) # if there's a unit conversion, express the value in the # units of the target if units[t] and val != "<on remote_proc>": val = convert_units(val, units[s], units[t]) src2tgts[s].append(t) else: # unconnected param val = _get_input(system, t, None) if isinstance(val, np.ndarray): val = np.array2string(val) else: val = str(val) vals[t] = val noconn_srcs = sorted((n for n in system._var_abs_names['output'] if n not in src2tgts), reverse=True) for s in noconn_srcs: vals[s] = str(system._outputs[s]) vals['NO CONNECTION'] = '' src_systems = set() tgt_systems = set() for s in system._var_abs_names['output']: parts = s.split('.') for i in range(len(parts)): src_systems.add('.'.join(parts[:i])) for t in system._var_abs_names['input']: parts = t.split('.') for i in range(len(parts)): tgt_systems.add('.'.join(parts[:i])) # reverse sort so that "NO CONNECTION" shows up at the bottom src2tgts['NO CONNECTION'] = sorted([t for t in system._var_abs_names['input'] if t not in connections], reverse=True) src_systems = [{'name':n} for n in sorted(src_systems)] src_systems.insert(1, {'name': "NO CONNECTION"}) tgt_systems = [{'name':n} for n in sorted(tgt_systems)] tgt_systems.insert(1, {'name': "NO CONNECTION"}) data = { 'src2tgts': sorted(iteritems(src2tgts)), 'proms': None, 'units': units, 'vals': vals, 'src_systems': src_systems, 'tgt_systems': tgt_systems, 'noconn_srcs': noconn_srcs, 'src_filter': src_filter, 'tgt_filter': tgt_filter, } viewer = 'connect_table.html' code_dir = os.path.dirname(os.path.abspath(__file__)) with open(os.path.join(code_dir, viewer), "r") as f: template = f.read() graphjson = json.dumps(data) with open(outfile, 'w') as f: s = template.replace("<connection_data>", graphjson) f.write(s) if show_browser: webview(outfile)
def test_distribcomp_list_vars(self): print_opts = {'linewidth': 1024} if LooseVersion(np.__version__) >= LooseVersion("1.14"): print_opts['legacy'] = '1.13' size = 15 model = om.Group() model.add_subsystem("indep", om.IndepVarComp('x', np.zeros(size))) model.add_subsystem("C2", DistribComp(size=size)) model.add_subsystem("C3", Summer(size=size)) model.connect('indep.x', 'C2.invec') model.connect('C2.outvec', 'C3.invec', src_indices=om.slicer[:]) prob = om.Problem(model) prob.setup() # prior to model execution, the global shape of a distributed variable is not available # and only the local portion of the value is available stream = StringIO() with printoptions(**print_opts): model.C2.list_inputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Input(s) in 'C2'", '', 'varname val shape global_shape', '------- --------------- ----- ------------', 'invec |3.87298334621| (8,) (15,)', ' val:', ' array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) stream = StringIO() with printoptions(**print_opts): model.C2.list_outputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Explicit Output(s) in 'C2'", '', 'varname val shape global_shape', '------- --------------- ----- ------------', 'outvec |3.87298334621| (8,) (15,)', ' val:', ' array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) # run the model prob['indep.x'] = np.ones(size) prob.run_model() # after model execution, the global shape of a distributed variable is available # and the complete global value is available stream = StringIO() with printoptions(**print_opts): model.C2.list_inputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Input(s) in 'C2'", '', 'varname val shape global_shape', '------- --------------- ----- ------------', 'invec |3.87298334621| (8,) (15,)', ' val:', ' array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) stream = StringIO() with printoptions(**print_opts): model.C2.list_outputs(hierarchical=False, shape=True, global_shape=True, print_arrays=True, out_stream=stream) if prob.comm.rank == 0: text = stream.getvalue().split('\n') expected = [ "1 Explicit Output(s) in 'C2'", '', 'varname val shape global_shape', '------- -------------- ----- ------------', 'outvec |9.74679434481| (8,) (15,)', ' val:', ' array([ 2., 2., 2., 2., 2., 2., 2., 2., -3., -3., -3., -3., -3., -3., -3.])' ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) stream = StringIO() with printoptions(**print_opts): model.C3.list_inputs(hierarchical=False, shape=True, global_shape=True, all_procs=True, print_arrays=True, out_stream=stream) text = stream.getvalue().split('\n') print('\n'.join(text)) norm = '|9.74679434481|' shape = (15,) value = '[2., 2., 2., 2., 2., 2., 2., 2., -3., -3., -3., -3., -3., -3., -3.]' expected = [ "1 Input(s) in 'C3'", '', 'varname val shape global_shape', '------- ------------------- ----- ------------', 'invec {} {} {} '.format(norm, shape, shape), ' val:', ' array({})'.format(value), ] for i, line in enumerate(expected): if line and not line.startswith('-'): self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line), '\nExpected: %s\nReceived: %s\n' % (line, text[i])) assert_near_equal(prob['C3.sum'], -5.)
def run_code(code_to_run, path, module=None, cls=None, shows_plot=False, imports_not_required=False): """ Run the given code chunk and collect the output. """ skipped = False failed = False if cls is None: use_mpi = False else: try: import mpi4py except ImportError: use_mpi = False else: N_PROCS = getattr(cls, 'N_PROCS', 1) use_mpi = N_PROCS > 1 try: # use subprocess to run code to avoid any nasty interactions between codes # Move to the test directory in case there are files to read. save_dir = os.getcwd() if module is None: code_dir = os.path.dirname(os.path.abspath(path)) else: code_dir = os.path.dirname(os.path.abspath(module.__file__)) os.chdir(code_dir) if use_mpi: env = os.environ.copy() # output will be written to one file per process env['USE_PROC_FILES'] = '1' env['OPENMDAO_CURRENT_MODULE'] = module.__name__ env['OPENMDAO_CODE_TO_RUN'] = code_to_run p = subprocess.Popen(['mpirun', '-n', str(N_PROCS), 'python', _sub_runner], env=env) p.wait() # extract output blocks from all output files & merge them output = [] for i in range(N_PROCS): with open('%d.out' % i) as f: output.append(f.read()) os.remove('%d.out' % i) elif shows_plot: if module is None: # write code to a file so we can run it. fd, code_to_run_path = tempfile.mkstemp() with os.fdopen(fd, 'w') as tmp: tmp.write(code_to_run) try: p = subprocess.Popen(['python', code_to_run_path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=os.environ) output, _ = p.communicate() if p.returncode != 0: failed = True finally: os.remove(code_to_run_path) else: env = os.environ.copy() env['OPENMDAO_CURRENT_MODULE'] = module.__name__ env['OPENMDAO_CODE_TO_RUN'] = code_to_run p = subprocess.Popen(['python', _sub_runner], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env) output, _ = p.communicate() if p.returncode != 0: failed = True output = output.decode('utf-8', 'ignore') else: # just exec() the code for serial tests. # capture all output stdout = sys.stdout stderr = sys.stderr strout = cStringIO() sys.stdout = strout sys.stderr = strout # We need more precision from numpy with printoptions(precision=8): if module is None: globals_dict = { '__file__': path, '__name__': '__main__', '__package__': None, '__cached__': None, } else: if imports_not_required: # code does not need to include all imports # Get from module globals_dict = module.__dict__ else: globals_dict = {} try: exec(code_to_run, globals_dict) except Exception: # print code (with line numbers) to facilitate debugging for n, line in enumerate(code_to_run.split('\n')): print('%4d: %s' % (n, line), file=stderr) raise finally: sys.stdout = stdout sys.stderr = stderr output = strout.getvalue() except subprocess.CalledProcessError as e: output = e.output.decode('utf-8', 'ignore') # Get a traceback. if 'raise unittest.SkipTest' in output: reason_for_skip = output.splitlines()[-1][len('unittest.case.SkipTest: '):] output = reason_for_skip skipped = True else: output = "Running of embedded code {} in docs failed due to: \n\n{}".format(path, output) failed = True except unittest.SkipTest as skip: output = str(skip) skipped = True except Exception as exc: output = "Running of embedded code {} in docs failed due to: \n\n{}".format(path, traceback.format_exc()) failed = True finally: os.chdir(save_dir) return skipped, failed, output
def view_connections(root, outfile='connections.html', show_browser=True, show_values=True, precision=6, title=None): """ Generate a self-contained html file containing a detailed connection viewer. Optionally pops up a web browser to view the file. Parameters ---------- root : system or Problem The root for the desired tree. outfile : str, optional The name of the output html file. Defaults to 'connections.html'. show_browser : bool, optional If True, pop up a browser to view the generated html file. Defaults to True. show_values : bool, optional If True, retrieve the values and display them. precision : int, optional Sets the precision for displaying array values. title : str, optional Sets the title of the web page. """ if MPI and MPI.COMM_WORLD.rank != 0: return # since people will be used to passing the Problem as the first arg to # the N2 diagram funct, allow them to pass a Problem here as well. if isinstance(root, Problem): system = root.model else: system = root connections = system._problem_meta['model_ref']()._conn_global_abs_in2out src2tgts = defaultdict(list) units = defaultdict(lambda: '') for io in ('input', 'output'): for n, data in system._var_allprocs_abs2meta[io].items(): u = data.get('units', '') if u is not None: units[n] = u vals = {} prefix = system.pathname + '.' if system.pathname else '' all_vars = {} for io in ('input', 'output'): all_vars[io] = chain(system._var_abs2meta[io].items(), [(prefix + n, m) for n, m in system._var_discrete[io].items()]) with printoptions(precision=precision, suppress=True, threshold=10000): for t, meta in all_vars['input']: s = connections[t] if show_values: if s.startswith('_auto_ivc.'): val = system.get_val(t, flat=True, get_remote=True, from_src=False) else: val = system.get_val(t, flat=True, get_remote=True) # if there's a unit conversion, express the value in the # units of the target if units[t] and s in system._outputs: val = system.get_val(t, flat=True, units=units[t], get_remote=True) else: val = system.get_val(t, flat=True, get_remote=True) else: val = '' src2tgts[s].append(t) vals[t] = val NOCONN = '[NO CONNECTION]' vals[NOCONN] = '' src_systems = set() tgt_systems = set() for s, _ in all_vars['output']: parts = s.split('.') for i in range(len(parts)): src_systems.add('.'.join(parts[:i])) for t, _ in all_vars['input']: parts = t.split('.') for i in range(len(parts)): tgt_systems.add('.'.join(parts[:i])) src_systems = [{'name': n} for n in sorted(src_systems)] src_systems.insert(1, {'name': NOCONN}) tgt_systems = [{'name': n} for n in sorted(tgt_systems)] tgt_systems.insert(1, {'name': NOCONN}) tprom = system._var_allprocs_abs2prom['input'] sprom = system._var_allprocs_abs2prom['output'] table = [] idx = 1 # unique ID for use by Tabulator for tgt, src in connections.items(): usrc = units[src] utgt = units[tgt] if usrc != utgt: # prepend these with '!' so they'll be colored red if usrc: usrc = '!' + units[src] if utgt: utgt = '!' + units[tgt] row = {'id': idx, 'src': src, 'sprom': sprom[src], 'sunits': usrc, 'val': _val2str(vals[tgt]), 'tunits': utgt, 'tprom': tprom[tgt], 'tgt': tgt} table.append(row) idx += 1 # add rows for unconnected sources for src, _ in all_vars['output']: if src not in src2tgts: if show_values: v = _val2str(system._abs_get_val(src)) else: v = '' row = {'id': idx, 'src': src, 'sprom': sprom[src], 'sunits': units[src], 'val': v, 'tunits': '', 'tprom': NOCONN, 'tgt': NOCONN} table.append(row) idx += 1 if title is None: title = '' data = { 'title': title, 'table': table, 'show_values': show_values, } viewer = 'connect_table.html' code_dir = os.path.dirname(os.path.abspath(__file__)) libs_dir = os.path.join(os.path.dirname(code_dir), 'common', 'libs') style_dir = os.path.join(os.path.dirname(code_dir), 'common', 'style') with open(os.path.join(code_dir, viewer), "r") as f: template = f.read() with open(os.path.join(libs_dir, 'tabulator.min.js'), "r") as f: tabulator_src = f.read() with open(os.path.join(style_dir, 'tabulator.min.css'), "r") as f: tabulator_style = f.read() jsontxt = json.dumps(data) with open(outfile, 'w') as f: s = template.replace("<connection_data>", jsontxt) s = s.replace("<tabulator_src>", tabulator_src) s = s.replace("<tabulator_style>", tabulator_style) f.write(s) if notebook: # display in Jupyter Notebook if not colab: display(IFrame(src=outfile, width=1000, height=1000)) else: display(HTML(outfile)) elif show_browser: # open it up in the browser from openmdao.utils.webview import webview webview(outfile)
def test_array_list_vars_options(self): class ArrayAdder(ExplicitComponent): """ Just a simple component that has array inputs and outputs """ def __init__(self, size): super(ArrayAdder, self).__init__() self.size = size def setup(self): self.add_input('x', val=np.zeros(self.size), units='inch') self.add_output('y', val=np.zeros(self.size), units='ft') def compute(self, inputs, outputs): outputs['y'] = inputs['x'] + 10.0 size = 100 # how many items in the array prob = Problem() prob.model = Group() prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size), units='inch'), promotes=['x']) prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y']) prob.setup(check=False) prob['x'] = np.ones(size) prob.run_driver() # logging inputs # out_stream - not hierarchical - extras - no print_arrays stream = cStringIO() prob.model.list_inputs(values=True, units=True, hierarchical=False, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(1, text.count("1 Input(s) in 'model'")) self.assertEqual(1, text.count('mult.x')) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(5, num_non_empty_lines) # out_stream - hierarchical - extras - no print_arrays stream = cStringIO() prob.model.list_inputs(values=True, units=True, hierarchical=True, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(1, text.count("1 Input(s) in 'model'")) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(7, num_non_empty_lines) self.assertEqual(1, text.count('top')) self.assertEqual(1, text.count(' mult')) self.assertEqual(1, text.count(' x')) # logging outputs # out_stream - not hierarchical - extras - no print_arrays stream = cStringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=False, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('2 Explicit Output'), 1) # make sure they are in the correct order self.assertTrue(text.find("des_vars.x") < text.find('mult.y')) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(8, num_non_empty_lines) # Promoted names - no print arrays stream = cStringIO() prob.model.list_outputs(values=True, prom_name=True, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count(' x |10.0| x'), 1) self.assertEqual(text.count(' y |110.0| y'), 1) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(num_non_empty_lines, 11) # Hierarchical - no print arrays stream = cStringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=False, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('top'), 1) self.assertEqual(text.count(' des_vars'), 1) self.assertEqual(text.count(' x'), 1) self.assertEqual(text.count(' mult'), 1) self.assertEqual(text.count(' y'), 1) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(num_non_empty_lines, 11) # Need to explicitly set this to make sure all ways of running this test # result in the same format of the output. When running this test from the # top level via testflo, the format comes out different than if the test is # run individually opts = { 'edgeitems': 3, 'infstr': 'inf', 'linewidth': 75, 'nanstr': 'nan', 'precision': 8, 'suppress': False, 'threshold': 1000, } from distutils.version import LooseVersion if LooseVersion(np.__version__) >= LooseVersion("1.14"): opts['legacy'] = '1.13' with printoptions(**opts): # logging outputs # out_stream - not hierarchical - extras - print_arrays stream = cStringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=False, print_arrays=True, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('2 Explicit Output'), 1) self.assertEqual(text.count('value:'), 2) self.assertEqual(text.count('resids:'), 2) self.assertEqual(text.count('['), 4) # make sure they are in the correct order self.assertTrue(text.find("des_vars.x") < text.find('mult.y')) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(37, num_non_empty_lines) # Hierarchical stream = cStringIO() prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=True, out_stream=stream) text = stream.getvalue() self.assertEqual(text.count('2 Explicit Output'), 1) self.assertEqual(text.count('value:'), 2) self.assertEqual(text.count('resids:'), 2) self.assertEqual(text.count('['), 4) self.assertEqual(text.count('top'), 1) self.assertEqual(text.count(' des_vars'), 1) self.assertEqual(text.count(' x'), 1) self.assertEqual(text.count(' mult'), 1) self.assertEqual(text.count(' y'), 1) num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()]) self.assertEqual(num_non_empty_lines, 40)
def run_code(code_to_run, path, module=None, cls=None, shows_plot=False, imports_not_required=False): """ Run the given code chunk and collect the output. """ skipped = False failed = False if cls is None: use_mpi = False else: try: import mpi4py except ImportError: use_mpi = False else: N_PROCS = getattr(cls, 'N_PROCS', 1) use_mpi = N_PROCS > 1 try: # use subprocess to run code to avoid any nasty interactions between codes # Move to the test directory in case there are files to read. save_dir = os.getcwd() if module is None: code_dir = os.path.dirname(os.path.abspath(path)) else: code_dir = os.path.dirname(os.path.abspath(module.__file__)) os.chdir(code_dir) if use_mpi: env = os.environ.copy() # output will be written to one file per process env['USE_PROC_FILES'] = '1' env['OPENMDAO_CURRENT_MODULE'] = module.__name__ env['OPENMDAO_CODE_TO_RUN'] = code_to_run p = subprocess.Popen( ['mpirun', '-n', str(N_PROCS), sys.executable, _sub_runner], env=env) p.wait() # extract output blocks from all output files & merge them output = [] for i in range(N_PROCS): with open('%d.out' % i) as f: output.append(f.read()) os.remove('%d.out' % i) elif shows_plot: if module is None: # write code to a file so we can run it. fd, code_to_run_path = tempfile.mkstemp() with os.fdopen(fd, 'w') as tmp: tmp.write(code_to_run) try: p = subprocess.Popen([sys.executable, code_to_run_path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=os.environ) output, _ = p.communicate() if p.returncode != 0: failed = True finally: os.remove(code_to_run_path) else: env = os.environ.copy() env['OPENMDAO_CURRENT_MODULE'] = module.__name__ env['OPENMDAO_CODE_TO_RUN'] = code_to_run p = subprocess.Popen([sys.executable, _sub_runner], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env) output, _ = p.communicate() if p.returncode != 0: failed = True output = output.decode('utf-8', 'ignore') else: # just exec() the code for serial tests. # capture all output stdout = sys.stdout stderr = sys.stderr strout = cStringIO() sys.stdout = strout sys.stderr = strout # We need more precision from numpy with printoptions(precision=8): if module is None: globals_dict = { '__file__': path, '__name__': '__main__', '__package__': None, '__cached__': None, } else: if imports_not_required: # code does not need to include all imports # Get from module globals_dict = module.__dict__ else: globals_dict = {} try: exec(code_to_run, globals_dict) except Exception as err: # for actual errors, print code (with line numbers) to facilitate debugging if not isinstance(err, unittest.SkipTest): for n, line in enumerate(code_to_run.split('\n')): print('%4d: %s' % (n, line), file=stderr) raise finally: sys.stdout = stdout sys.stderr = stderr output = strout.getvalue() except subprocess.CalledProcessError as e: output = e.output.decode('utf-8', 'ignore') # Get a traceback. if 'raise unittest.SkipTest' in output: reason_for_skip = output.splitlines( )[-1][len('unittest.case.SkipTest: '):] output = reason_for_skip skipped = True else: output = "Running of embedded code {} in docs failed due to: \n\n{}".format( path, output) failed = True except unittest.SkipTest as skip: output = str(skip) skipped = True except Exception as exc: output = "Running of embedded code {} in docs failed due to: \n\n{}".format( path, traceback.format_exc()) failed = True finally: os.chdir(save_dir) return skipped, failed, output
module_path = os.environ.get("OPENMDAO_CURRENT_MODULE", "").strip() if module_path: stdout_save = sys.stdout # send any output to dev/null during the import so it doesn't clutter our embedded code output with open(os.devnull, "w") as f: sys.stdout = f mod = importlib.import_module(module_path) sys.stdout = stdout_save else: raise RuntimeError("OPENMDAO_CURRENT_MODULE was not specified.") if os.environ.get("USE_PROC_FILES"): from openmdao.utils.mpi import use_proc_files use_proc_files() code_to_run = os.environ.get("OPENMDAO_CODE_TO_RUN", "").strip() if not code_to_run: raise RuntimeError("OPENMDAO_CODE_TO_RUN has not been set.") with printoptions(precision=8): exec(code_to_run, mod.__dict__) except Exception: traceback.print_exc() sys.exit(-1) sys.exit(0)