Merge aaa6736 into 93bd334

openmdao/components/tests/test_add_subtract_comp.py

@@ -392,29 +392,22 @@ def test(self):
         n = 3
 
         p = om.Problem()
+        model = p.model
 
-        ivc = om.IndepVarComp()
         # The vector represents forces at 3 time points (rows) in 2 dimensional plane (cols)
-        ivc.add_output(name='thrust', shape=(n, 2), units='kN')
-        ivc.add_output(name='drag', shape=(n, 2), units='kN')
-        ivc.add_output(name='lift', shape=(n, 2), units='kN')
-        ivc.add_output(name='weight', shape=(n, 2), units='kN')
-        p.model.add_subsystem(name='ivc',
-                              subsys=ivc,
-                              promotes_outputs=['thrust', 'drag', 'lift', 'weight'])
+        model.set_input_defaults('thrust', units='kN')
+        model.set_input_defaults('drag', units='kN')
+        model.set_input_defaults('lift', units='kN')
+        model.set_input_defaults('weight', units='kN')
 
         # Construct an adder/subtracter here. create a relationship through the add_equation method
         adder = om.AddSubtractComp()
         adder.add_equation('total_force', input_names=['thrust', 'drag', 'lift', 'weight'],
                            vec_size=n, length=2, scaling_factors=[1, -1, 1, -1], units='kN')
         # Note the scaling factors. we assume all forces are positive sign upstream
 
-        p.model.add_subsystem(name='totalforcecomp', subsys=adder)
-
-        p.model.connect('thrust', 'totalforcecomp.thrust')
-        p.model.connect('drag', 'totalforcecomp.drag')
-        p.model.connect('lift', 'totalforcecomp.lift')
-        p.model.connect('weight', 'totalforcecomp.weight')
+        p.model.add_subsystem(name='totalforcecomp', subsys=adder,
+                              promotes_inputs=['thrust', 'drag', 'lift', 'weight'])
 
         p.setup()
 

openmdao/components/tests/test_cross_product_comp.py

@@ -232,21 +232,14 @@ def test(self):
 
         p = om.Problem()
 
-        ivc = om.IndepVarComp()
-        ivc.add_output(name='r', shape=(n, 3))
-        ivc.add_output(name='F', shape=(n, 3))
-
-        p.model.add_subsystem(name='ivc',
-                              subsys=ivc,
-                              promotes_outputs=['r', 'F'])
+        p.model.set_input_defaults('r')
+        p.model.set_input_defaults('F')
 
         p.model.add_subsystem(name='cross_prod_comp',
                               subsys=om.CrossProductComp(vec_size=n,
                                                          a_name='r', b_name='F', c_name='torque',
-                                                         a_units='m', b_units='N', c_units='N*m'))
-
-        p.model.connect('r', 'cross_prod_comp.r')
-        p.model.connect('F', 'cross_prod_comp.F')
+                                                         a_units='m', b_units='N', c_units='N*m'),
+                              promotes_inputs=['r', 'F'])
 
         p.setup()
 

openmdao/components/tests/test_demux_comp.py

@@ -157,15 +157,10 @@ def test(self):
 
         p = om.Problem()
 
-        ivc = om.IndepVarComp()
-        ivc.add_output(name='pos_ecef', shape=(m, 3), units='km')
-
-        p.model.add_subsystem(name='ivc',
-                              subsys=ivc,
-                              promotes_outputs=['pos_ecef'])
+        p.model.set_input_defaults('pos_ecef', units='km')
 
-        mux_comp = p.model.add_subsystem(name='demux',
-                                         subsys=om.DemuxComp(vec_size=n))
+        mux_comp = p.model.add_subsystem(name='demux', subsys=om.DemuxComp(vec_size=n),
+                                         promotes_inputs=[('pos', 'pos_ecef')])
 
         mux_comp.add_var('pos', shape=(m, n), axis=1, units='km')
 
@@ -177,7 +172,6 @@ def test(self):
 
         p.model.connect('demux.pos_0', 'longitude_comp.x')
         p.model.connect('demux.pos_1', 'longitude_comp.y')
-        p.model.connect('pos_ecef', 'demux.pos')
 
         p.setup()
 

openmdao/components/tests/test_dot_product_comp.py

@@ -171,21 +171,14 @@ def test(self):
 
         p = om.Problem()
 
-        ivc = om.IndepVarComp()
-        ivc.add_output(name='force', shape=(n, 3))
-        ivc.add_output(name='vel', shape=(n, 3))
-
-        p.model.add_subsystem(name='ivc',
-                              subsys=ivc,
-                              promotes_outputs=['force', 'vel'])
+        p.model.set_input_defaults('force')
+        p.model.set_input_defaults('vel')
 
         dp_comp = om.DotProductComp(vec_size=n, length=3, a_name='F', b_name='v', c_name='P',
                                     a_units='N', b_units='m/s', c_units='W')
 
-        p.model.add_subsystem(name='dot_prod_comp', subsys=dp_comp)
-
-        p.model.connect('force', 'dot_prod_comp.F')
-        p.model.connect('vel', 'dot_prod_comp.v')
+        p.model.add_subsystem(name='dot_prod_comp', subsys=dp_comp,
+                             promotes_inputs=[('F', 'force'), ('v', 'vel')])
 
         p.setup()
 

openmdao/components/tests/test_external_code_comp.py

@@ -426,16 +426,15 @@ def test_main(self):
         prob = om.Problem()
         model = prob.model
 
-        # create and connect inputs
-        model.add_subsystem('p1', om.IndepVarComp('x', 3.0))
-        model.add_subsystem('p2', om.IndepVarComp('y', -4.0))
-        model.add_subsystem('p', ParaboloidExternalCodeComp())
-
-        model.connect('p1.x', 'p.x')
-        model.connect('p2.y', 'p.y')
+        model.add_subsystem('p', ParaboloidExternalCodeComp(), promotes_inputs=['x', 'y'])
 
         # run the ExternalCodeComp Component
         prob.setup()
+
+        # Set input values
+        prob.set_val('p.x', 3.0)
+        prob.set_val('p.y', -4.0)
+
         prob.run_model()
 
         # print the output
@@ -448,32 +447,31 @@ def test_optimize_fd(self):
         prob = om.Problem()
         model = prob.model
 
-        # create and connect inputs
-        model.add_subsystem('p1', om.IndepVarComp('x', 3.0))
-        model.add_subsystem('p2', om.IndepVarComp('y', -4.0))
         model.add_subsystem('p', ParaboloidExternalCodeCompFD())
 
-        model.connect('p1.x', 'p.x')
-        model.connect('p2.y', 'p.y')
-
         # find optimal solution with SciPy optimize
         # solution (minimum): x = 6.6667; y = -7.3333
         prob.driver = om.ScipyOptimizeDriver()
         prob.driver.options['optimizer'] = 'SLSQP'
 
-        prob.model.add_design_var('p1.x', lower=-50, upper=50)
-        prob.model.add_design_var('p2.y', lower=-50, upper=50)
+        prob.model.add_design_var('p.x', lower=-50, upper=50)
+        prob.model.add_design_var('p.y', lower=-50, upper=50)
 
         prob.model.add_objective('p.f_xy')
 
         prob.driver.options['tol'] = 1e-9
         prob.driver.options['disp'] = True
 
         prob.setup()
+
+        # Set input values
+        prob.set_val('p.x', 3.0)
+        prob.set_val('p.y', -4.0)
+
         prob.run_driver()
 
-        assert_near_equal(prob['p1.x'], 6.66666667, 1e-6)
-        assert_near_equal(prob['p2.y'], -7.3333333, 1e-6)
+        assert_near_equal(prob['p.x'], 6.66666667, 1e-6)
+        assert_near_equal(prob['p.y'], -7.3333333, 1e-6)
 
     def test_optimize_derivs(self):
         import openmdao.api as om
@@ -482,32 +480,31 @@ def test_optimize_derivs(self):
         prob = om.Problem()
         model = prob.model
 
-        # create and connect inputs
-        model.add_subsystem('p1', om.IndepVarComp('x', 3.0))
-        model.add_subsystem('p2', om.IndepVarComp('y', -4.0))
         model.add_subsystem('p', ParaboloidExternalCodeCompDerivs())
 
-        model.connect('p1.x', 'p.x')
-        model.connect('p2.y', 'p.y')
-
         # find optimal solution with SciPy optimize
         # solution (minimum): x = 6.6667; y = -7.3333
         prob.driver = om.ScipyOptimizeDriver()
         prob.driver.options['optimizer'] = 'SLSQP'
 
-        prob.model.add_design_var('p1.x', lower=-50, upper=50)
-        prob.model.add_design_var('p2.y', lower=-50, upper=50)
+        prob.model.add_design_var('p.x', lower=-50, upper=50)
+        prob.model.add_design_var('p.y', lower=-50, upper=50)
 
         prob.model.add_objective('p.f_xy')
 
         prob.driver.options['tol'] = 1e-9
         prob.driver.options['disp'] = True
 
         prob.setup()
+
+        # Set input values
+        prob.set_val('p.x', 3.0)
+        prob.set_val('p.y', -4.0)
+
         prob.run_driver()
 
-        assert_near_equal(prob['p1.x'], 6.66666667, 1e-6)
-        assert_near_equal(prob['p2.y'], -7.3333333, 1e-6)
+        assert_near_equal(prob['p.x'], 6.66666667, 1e-6)
+        assert_near_equal(prob['p.y'], -7.3333333, 1e-6)
 
 
 class TestExternalCodeImplicitCompFeature(unittest.TestCase):
@@ -601,7 +598,6 @@ def solve_nonlinear(self, inputs, outputs):
                 outputs['mach'] = mach
 
         group = om.Group()
-        group.add_subsystem('ar', om.IndepVarComp('area_ratio', 0.5))
         mach_comp = group.add_subsystem('comp', MachExternalCodeComp(), promotes=['*'])
         prob = om.Problem(model=group)
         group.nonlinear_solver = om.NewtonSolver()
@@ -614,7 +610,7 @@ def solve_nonlinear(self, inputs, outputs):
 
         area_ratio = 1.3
         super_sonic = False
-        prob['area_ratio'] = area_ratio
+        prob.set_val('area_ratio', area_ratio)
         mach_comp.options['super_sonic'] = super_sonic
         prob.run_model()
         assert_near_equal(prob['mach'], mach_solve(area_ratio, super_sonic=super_sonic), 1e-8)

openmdao/components/tests/test_ks_comp.py

@@ -212,13 +212,12 @@ def test_basic(self):
         prob = om.Problem()
         model = prob.model
 
-        model.add_subsystem('px', om.IndepVarComp('x', val=np.array([5.0, 4.0])))
+        model.set_input_defaults('x', np.array([5.0, 4.0]))
         model.add_subsystem('comp', om.ExecComp('y = 3.0*x',
                                                 x=np.zeros((2, )),
-                                                y=np.zeros((2, ))))
+                                                y=np.zeros((2, ))), promotes_inputs=['x'])
         model.add_subsystem('ks', om.KSComp(width=2))
 
-        model.connect('px.x', 'comp.x')
         model.connect('comp.y', 'ks.g')
 
         prob.setup()
@@ -234,13 +233,12 @@ def test_vectorized(self):
         prob = om.Problem()
         model = prob.model
 
-        model.add_subsystem('px', om.IndepVarComp('x', val=np.array([[5.0, 4.0], [10.0, 8.0]])))
+        model.set_input_defaults('x', np.array([[5.0, 4.0], [10.0, 8.0]]))
         model.add_subsystem('comp', om.ExecComp('y = 3.0*x',
                                                 x=np.zeros((2, 2)),
-                                                y=np.zeros((2, 2))))
+                                                y=np.zeros((2, 2))), promotes_inputs=['x'])
         model.add_subsystem('ks', om.KSComp(width=2, vec_size=2))
 
-        model.connect('px.x', 'comp.x')
         model.connect('comp.y', 'ks.g')
 
         prob.setup()
@@ -256,13 +254,12 @@ def test_upper(self):
         prob = om.Problem()
         model = prob.model
 
-        model.add_subsystem('px', om.IndepVarComp('x', val=np.array([5.0, 4.0])))
+        model.set_input_defaults('x', np.array([5.0, 4.0]))
         model.add_subsystem('comp', om.ExecComp('y = 3.0*x',
                                                 x=np.zeros((2, )),
-                                                y=np.zeros((2, ))))
+                                                y=np.zeros((2, ))), promotes_inputs=['x'])
         model.add_subsystem('ks', om.KSComp(width=2))
 
-        model.connect('px.x', 'comp.x')
         model.connect('comp.y', 'ks.g')
 
         model.ks.options['upper'] = 16.0
@@ -279,13 +276,12 @@ def test_lower_flag(self):
         prob = om.Problem()
         model = prob.model
 
-        model.add_subsystem('px', om.IndepVarComp('x', val=np.array([5.0, 4.0])))
+        model.set_input_defaults('x', np.array([5.0, 4.0]))
         model.add_subsystem('comp', om.ExecComp('y = 3.0*x',
                                                 x=np.zeros((2, )),
-                                                y=np.zeros((2, ))))
+                                                y=np.zeros((2, ))), promotes_inputs=['x'])
         model.add_subsystem('ks', om.KSComp(width=2))
 
-        model.connect('px.x', 'comp.x')
         model.connect('comp.y', 'ks.g')
 
         model.ks.options['lower_flag'] = True
@@ -305,21 +301,18 @@ def test_add_constraint(self):
 
         prob.driver = om.ScipyOptimizeDriver()
 
-        ivc = model.add_subsystem('ivc', om.IndepVarComp())
-        ivc.add_output('x', val=np.linspace(-np.pi/2, np.pi/2, n))
-        ivc.add_output('k', val=5.0)
+        model.set_input_defaults('x', np.linspace(-np.pi/2, np.pi/2, n))
+        model.set_input_defaults('k', 5.)
 
         model.add_subsystem('comp', om.ExecComp('y = -3.0*x**2 + k',
                                                 x=np.zeros((n, )),
                                                 y=np.zeros((n, )),
-                                                k=0.0))
+                                                k=0.0), promotes_inputs=['x', 'k'])
         model.add_subsystem('ks', om.KSComp(width=n, upper=4.0, add_constraint=True))
 
-        model.add_design_var('ivc.k', lower=-10, upper=10)
-        model.add_objective('ivc.k', scaler=-1)
+        model.add_design_var('k', lower=-10, upper=10)
+        model.add_objective('k', scaler=-1)
 
-        model.connect('ivc.x', 'comp.x')
-        model.connect('ivc.k', 'comp.k')
         model.connect('comp.y', 'ks.g')
 
         prob.setup()
@@ -329,15 +322,15 @@ def test_add_constraint(self):
 
         fig, ax = plt.subplots()
 
-        x = prob.get_val('ivc.x')
+        x = prob.get_val('x')
         y = prob.get_val('comp.y')
 
         ax.plot(x, y, 'r.')
         ax.plot(x, 4.0*np.ones_like(x), 'k--')
         ax.set_xlabel('x')
         ax.set_ylabel('y')
         ax.grid(True)
-        ax.text(-0.25, 0, f"k = {prob.get_val('ivc.k')[0]:6.3f}")
+        ax.text(-0.25, 0, f"k = {prob.get_val('k')[0]:6.3f}")
 
         plt.show()
 
@@ -349,21 +342,14 @@ def test_units(self):
 
         model = om.Group()
 
-        model.add_subsystem('indep', om.IndepVarComp('x', val=range(n), units='ft'))
-        model.add_subsystem('ks', om.KSComp(width=n, units='m'))
-
-        model.connect('indep.x', 'ks.g')
+        model.set_input_defaults('x', range(n), units='ft')
+        model.add_subsystem('ks', om.KSComp(width=n, units='m'), promotes_inputs=[('g', 'x')])
 
         prob = om.Problem(model=model)
         prob.setup()
         prob.run_model()
 
-        # KS is expressed in meters, while the independent variable 'x' is in feet
-        assert_near_equal(prob['ks.KS'][0], convert_units(max(prob['indep.x']), 'ft', 'm'),
-                          tolerance=1e-8)
-
-        assert_near_equal(convert_units(prob['ks.KS'][0], 'm', 'ft'), max(prob['indep.x']),
-                          tolerance=1e-8)
+        assert_near_equal(prob['ks.KS'][0], np.amax(prob['x']), tolerance=1e-8)
 
 
 if __name__ == "__main__":